-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathParser.h
187 lines (167 loc) · 8.53 KB
/
Parser.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
/**
* Projekt : Implementace prekladace imperativniho jazyka IFJ21
* @file Parser.h
* @author Juraj Hatala (xhatal01)
* @brief hlavickovy subor parseru
*
*/
#ifndef _parcer
#define _parcer
#include <stdio.h>
#include <stdlib.h>
#include "ParserDownUp.h"
#include "error.h"
#include "symtable.h"
#include "AST.h"
#include "generator.h"
#define PARC_TRUE 0
#define PARC_FALSE 2
#define RETURN_ON_ERROR(_function) \
if ((status = _function(MyToken, mySymtable, abstractTree)) != PARC_TRUE) return status
#define RETURN_ON_ERROR_FCCALL(_withIDs) \
if ((status = fc_functionCall(MyToken, mySymtable, abstractTree, _withIDs)) != PARC_TRUE) return status
#define SCAN_TOKEN \
status = tokenScan(stdin, MyToken); \
if (status==LEXICAL_ERROR) return LEXICAL_ERROR;
typedef enum{
program,
prolog,
code,
functionDec,
statement,
global_scope, //function rozklad
function_iden,
params,
param,
nextParam,
returnTypes,
type,
nextType,
condition, //statment rozklad
loop,
assigneOrFunctioCall,
define,
expression,
nextExpression,
varlist,
var,
nextVar,
initialize,
elseCondition,
functionCall,
FCallparams,
FCallparam,
FCallnextParam,
FCreturn,
returnParams,
returnParam,
returnNextParam,
defineEquals,
statementOutOfFc
}NonTerminal;
//implementacia LL gramatiky
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
int fc_program(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //program: <prolog><code>
int fc_code(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //code: <functionDec><code><statementOutOfFc>
int fc_statementOutOfFc(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //statementOutOfFc: <functionDec>||<functionCall>(bez ids) <statementOutOfFc>
int fc_functionDec(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //functionDec: <global_scope>function<functionIden>(<params><returntypes>)<statement>end
int fc_global_scope(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //global_scope: global
int fc_functionIden(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //functionIden: <functionIden>
int fc_params(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //params: <param><nextParam>
int fc_returnTypes(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //returnTypes: :type<nextType>
int fc_statement(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //statemnet: <<loop>||<condition>||<assigne>||<define>> <statment>
int fc_param(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //param: <identifier>:<type>
int fc_nextParam(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //nextparam: ,<param><nextparam>
int fc_nextType(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //nextType: ,Type<nextType>
int fc_loop(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //loop: while<expression>do<statement>end
int fc_condition(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //condition: if<expresion>then<statement><elseCondition>end
int fc_elseCondition(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //elseCondition: else<statement>
int fc_assigne(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //assigne: <var><nextVar>=<expresion><nextExpresion>||<functionCall>
int fc_define(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //define: local|identifier:type<defineEquals>
int fc_defineEquals(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //defineEquals: =<initialize>
int fc_initialize(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //initialize: <expresion>||<functionCall>
int fc_expression(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //expression: identifier||number||integer||string||sizeof||L_bracet
int fc_nextExpression(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //nextExpression: ,<expresion><nextExpression>
int fc_var(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //var: identifier
int fc_nextVar(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //nextVar: ,<var><nextVar>
int fc_functionCall(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree,bool withIDs); //functionCall: identifier(<FCparams>)
int fc_prolog(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //prolog: requier ifj21
int fc_FCallparams(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //FCallparams: <FCallparam><FCallnextParam>
int fc_FCallparam(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //FCallparam: <expression>
int fc_FCallnextParam(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //FCallnextParam: ,<FCallparam><FCallnextparam>
int fc_FCreturn(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //FCreturn: return <FCparams>
int fc_returnParams(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //returnParams: <returnParam><returnNextParam>
int fc_returnParam(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //returnParam: <expression>
int fc_returnNextParam(Token* MyToken, symtable* mySymtable, ASTtree* abstractTree); //returnNextParam: ,<returnParam><returnNextParam>
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @brief Spusta syntakticku analizu a lexikalnu analizu pri com vytvara symtable a AST
*
* @param abstractTree
* @param mySymtable
* @return int
*/
int Parse(ASTtree* abstractTree, symtable* mySymtable);
/**
* @brief funkcia skontoluje ci je token sucastou first mnoziny zadanej funkcie
*
* @param MyToken
* @param MyNonTerminal
* @return true
* @return false
*/
bool first(Token* MyToken, NonTerminal MyNonTerminal);
/**
* @brief vypis na stdout obsah tokenu pre kontolu priebehu syntaktickej analizi ak je on true
*
* @param state
* @param MyToken
* @param on
*/
void parcerPrint(char* state ,Token* MyToken ,bool on);
/**
* @brief porovna string z tokenu a vlozeni string
*
* @param MyToken
* @param checkType
* @return true
* @return false
*/
bool chackStr(Token* MyToken, char* checkType);
/**
* @brief Porovna typ tokenu so zadanym typom chacktype, ak su zhodne naskenuje novy token ak nie vrati PARC_FALSE
*
* @param MyToken
* @param list
* @param checkType
* @return int
*/
int chackType(Token* MyToken, Token_type checkType);
/**
* @brief Porovna string ulozeny v tokene a parameter str
*
* @param MyToken
* @param Str
* @return true
* @return false
*/
bool compareTokenStr(Token* MyToken, char* Str);
/**
* @brief kontroluje ci je token typu integer string alebo number
*
* @param MyToken
* @return true
* @return false
*/
bool isTokenDataType(Token* MyToken);
/**
* @brief vypis symtable
*
* @param mySymtable
*/
void printGlobalTree(symtable* mySymtable);
#endif