diff options
Diffstat (limited to '')
-rw-r--r-- | LuaSL/src/LuaSL_LSL_tree.c | 278 |
1 files changed, 235 insertions, 43 deletions
diff --git a/LuaSL/src/LuaSL_LSL_tree.c b/LuaSL/src/LuaSL_LSL_tree.c index 7cebecc..9137692 100644 --- a/LuaSL/src/LuaSL_LSL_tree.c +++ b/LuaSL/src/LuaSL_LSL_tree.c | |||
@@ -2,83 +2,275 @@ | |||
2 | * Implementation of functions used to build the abstract syntax tree. | 2 | * Implementation of functions used to build the abstract syntax tree. |
3 | */ | 3 | */ |
4 | 4 | ||
5 | |||
6 | #define LSL_Keywords_define | ||
7 | #define LSL_Tokens_define | ||
5 | #include "LuaSL_LSL_tree.h" | 8 | #include "LuaSL_LSL_tree.h" |
6 | #include <stdlib.h> | 9 | #include <stdlib.h> |
7 | 10 | ||
11 | |||
8 | /** | 12 | /** |
9 | * @brief Allocates space for expression | 13 | * @brief Allocates space for an AST leaf |
10 | * @return The expression or NULL if not enough memory | 14 | * @return The expression or NULL if not enough memory |
11 | */ | 15 | */ |
12 | static SExpression* newExpression(EOperationType type, SExpression *left, SExpression *right, int value) | 16 | |
17 | /* | ||
18 | static LSL_AST *newLeaf(LSL_Type type, LSL_AST *left, LSL_AST *right) | ||
13 | { | 19 | { |
14 | SExpression* b = malloc(sizeof *b); | 20 | LSL_AST *leaf = malloc(sizeof(LSL_AST)); |
15 | 21 | ||
16 | if (b == NULL) return NULL; | 22 | if (leaf == NULL) return NULL; |
17 | 23 | ||
18 | b->type = type; | 24 | leaf->type = type; |
19 | b->value = value; | 25 | leaf->left = left; |
20 | b->left = left; | 26 | leaf->right = right; |
21 | b->right = right; | 27 | leaf->line = -1; |
28 | leaf->character = -1; | ||
22 | 29 | ||
23 | return b; | 30 | return leaf; |
24 | } | 31 | } |
32 | */ | ||
25 | 33 | ||
26 | SExpression* createNumber(int value) | 34 | void burnLeaf(LSL_AST *leaf) |
27 | { | 35 | { |
28 | return newExpression(eVALUE, NULL, NULL, value); | 36 | if (leaf == NULL) return; |
37 | |||
38 | burnLeaf(leaf->left); | ||
39 | burnLeaf(leaf->right); | ||
40 | free(leaf); | ||
29 | } | 41 | } |
30 | 42 | ||
31 | SExpression *createOperation(EOperationType type, SExpression *left, SExpression *right) | 43 | static LSL_Expression *newLSLExpression(LSL_Type type, LSL_Expression *left, LSL_Expression *right) |
32 | { | 44 | { |
33 | return newExpression(type, left, right, 0); | 45 | LSL_Expression *exp = malloc(sizeof(LSL_Expression)); |
46 | |||
47 | if (exp == NULL) return NULL; | ||
48 | |||
49 | exp->type = type; | ||
50 | exp->left = left; | ||
51 | exp->right = right; | ||
52 | exp->expression=0; | ||
53 | |||
54 | return exp; | ||
34 | } | 55 | } |
35 | 56 | ||
36 | int evaluate(SExpression *e) | 57 | void burnLSLExpression(LSL_Expression *exp) |
37 | { | 58 | { |
38 | switch(e->type) | 59 | if (exp == NULL) return; |
39 | { | 60 | |
40 | case eVALUE: | 61 | burnLSLExpression(exp->left); |
41 | return e->value; | 62 | burnLSLExpression(exp->right); |
42 | case eMULTIPLY: | 63 | free(exp); |
43 | return evaluate(e->left) * evaluate(e->right); | 64 | } |
44 | case ePLUS: | 65 | |
45 | return evaluate(e->left) + evaluate(e->right); | 66 | LSL_Expression *addInteger(int value) |
46 | default: | 67 | { |
47 | // shouldn't be here | 68 | LSL_Expression *exp = newLSLExpression(LSL_INTEGER, NULL, NULL); |
48 | return 0; | 69 | |
49 | } | 70 | if (exp) |
71 | exp->value.integerValue = value; | ||
72 | |||
73 | return exp; | ||
50 | } | 74 | } |
51 | 75 | ||
52 | void deleteExpression(SExpression *b) | 76 | LSL_Expression *addOperation(LSL_Operation type, LSL_Expression *left, LSL_Expression *right) |
53 | { | 77 | { |
54 | if (b == NULL) return; | 78 | LSL_Expression *exp = newLSLExpression(LSL_EXPRESSION, left, right); |
55 | 79 | ||
56 | deleteExpression(b->left); | 80 | if (exp) |
57 | deleteExpression(b->right); | 81 | exp->expression = type; |
58 | 82 | ||
59 | free(b); | 83 | return exp; |
60 | } | 84 | } |
61 | 85 | ||
62 | SExpression *getAST(const char *expr) | 86 | LSL_Expression *newTree(const char *expr) |
63 | { | 87 | { |
64 | SParserParam p; | 88 | LuaSL_yyparseParam param; |
65 | YY_BUFFER_STATE state; | 89 | YY_BUFFER_STATE state; |
66 | 90 | ||
67 | p.expression = NULL; | 91 | param.expression = NULL; |
68 | if (yylex_init(&(p.scanner))) | 92 | if (yylex_init(&(param.scanner))) |
69 | return NULL; | 93 | return NULL; |
94 | |||
95 | state = yy_scan_string(expr, param.scanner); | ||
96 | if (yyparse(¶m)) | ||
97 | return NULL; | ||
70 | 98 | ||
71 | state = yy_scan_string(expr, p.scanner); | 99 | yy_delete_buffer(state, param.scanner); |
72 | if (yyparse(&p)) | 100 | yylex_destroy(param.scanner); |
73 | return NULL; | ||
74 | 101 | ||
75 | yy_delete_buffer(state, p.scanner); | 102 | return param.expression; |
76 | yylex_destroy(p.scanner); | 103 | } |
77 | return p.expression; | 104 | |
105 | int evaluateExpression(LSL_Expression *exp, int old) | ||
106 | { | ||
107 | switch(exp->type) | ||
108 | { | ||
109 | case LSL_COMMENT : | ||
110 | case LSL_TYPE : | ||
111 | case LSL_NAME : | ||
112 | case LSL_IDENTIFIER : | ||
113 | break; | ||
114 | case LSL_FLOAT : return (int) exp->value.floatValue; | ||
115 | case LSL_INTEGER : return exp->value.integerValue; | ||
116 | case LSL_STRING : | ||
117 | case LSL_KEY : | ||
118 | case LSL_VECTOR : | ||
119 | case LSL_ROTATION : | ||
120 | case LSL_LIST : | ||
121 | case LSL_LABEL : | ||
122 | break; | ||
123 | case LSL_EXPRESSION : | ||
124 | { | ||
125 | switch (exp->expression) | ||
126 | { | ||
127 | case LSL_COMMA : | ||
128 | case LSL_INCREMENT_PRE : | ||
129 | case LSL_INCREMENT_POST : | ||
130 | case LSL_DECREMENT_PRE : | ||
131 | case LSL_DECREMENT_POST : | ||
132 | case LSL_DOT : | ||
133 | case LSL_ASSIGNMENT_PLAIN : | ||
134 | case LSL_ASSIGNMENT_DIVIDE : | ||
135 | case LSL_ASSIGNMENT_MODULO : | ||
136 | case LSL_ASSIGNMENT_MULTIPLY : | ||
137 | case LSL_ASSIGNMENT_SUBTRACT : | ||
138 | case LSL_ASSIGNMENT_ADD : | ||
139 | case LSL_ASSIGNMENT_CONCATENATE : | ||
140 | case LSL_PARENTHESIS_OPEN : | ||
141 | case LSL_PARENTHESIS_CLOSE : | ||
142 | case LSL_BRACKET_OPEN : | ||
143 | case LSL_BRACKET_CLOSE : | ||
144 | case LSL_ANGLE_OPEN : | ||
145 | case LSL_ANGLE_CLOSE : | ||
146 | case LSL_TYPECAST : | ||
147 | case LSL_BIT_NOT : | ||
148 | case LSL_BOOL_NOT : | ||
149 | case LSL_NEGATION : | ||
150 | break; | ||
151 | case LSL_DIVIDE : return evaluateExpression(exp->left, old) / evaluateExpression(exp->right, old); | ||
152 | case LSL_MODULO : return evaluateExpression(exp->left, old) % evaluateExpression(exp->right, old); | ||
153 | case LSL_MULTIPLY : return evaluateExpression(exp->left, old) * evaluateExpression(exp->right, old); | ||
154 | case LSL_DOT_PRODUCT : break; | ||
155 | case LSL_CROSS_PRODUCT : break; | ||
156 | case LSL_SUBTRACT : return evaluateExpression(exp->left, old) - evaluateExpression(exp->right, old); | ||
157 | case LSL_ADD : return evaluateExpression(exp->left, old) + evaluateExpression(exp->right, old); | ||
158 | case LSL_CONCATENATE : break; | ||
159 | case LSL_LEFT_SHIFT : return evaluateExpression(exp->left, old) << evaluateExpression(exp->right, old); | ||
160 | case LSL_RIGHT_SHIFT : return evaluateExpression(exp->left, old) >> evaluateExpression(exp->right, old); | ||
161 | case LSL_LESS_THAN : return evaluateExpression(exp->left, old) < evaluateExpression(exp->right, old); | ||
162 | case LSL_GREATER_THAN : return evaluateExpression(exp->left, old) > evaluateExpression(exp->right, old); | ||
163 | case LSL_LESS_EQUAL : return evaluateExpression(exp->left, old) <= evaluateExpression(exp->right, old); | ||
164 | case LSL_GREATER_EQUAL : return evaluateExpression(exp->left, old) >= evaluateExpression(exp->right, old); | ||
165 | case LSL_EQUAL : return evaluateExpression(exp->left, old) == evaluateExpression(exp->right, old); | ||
166 | case LSL_NOT_EQUAL : return evaluateExpression(exp->left, old) != evaluateExpression(exp->right, old); | ||
167 | case LSL_BIT_AND : return evaluateExpression(exp->left, old) & evaluateExpression(exp->right, old); | ||
168 | case LSL_BIT_XOR : return evaluateExpression(exp->left, old) ^ evaluateExpression(exp->right, old); | ||
169 | case LSL_BIT_OR : return evaluateExpression(exp->left, old) | evaluateExpression(exp->right, old); | ||
170 | case LSL_BOOL_OR : return evaluateExpression(exp->left, old) || evaluateExpression(exp->right, old); | ||
171 | case LSL_BOOL_AND : return evaluateExpression(exp->left, old) && evaluateExpression(exp->right, old); | ||
172 | } | ||
173 | break; | ||
174 | } | ||
175 | case LSL_DO : | ||
176 | case LSL_FOR : | ||
177 | case LSL_IF : | ||
178 | case LSL_ELSE : | ||
179 | case LSL_ELSEIF : | ||
180 | case LSL_JUMP : | ||
181 | case LSL_STATE_CHANGE : | ||
182 | case LSL_WHILE : | ||
183 | case LSL_RETURN : | ||
184 | case LSL_STATEMENT : | ||
185 | case LSL_BLOCK : | ||
186 | case LSL_PARAMETER : | ||
187 | case LSL_FUNCTION : | ||
188 | case LSL_STATE : | ||
189 | case LSL_SCRIPT : | ||
190 | break; | ||
191 | } | ||
192 | |||
193 | return old; | ||
194 | |||
195 | } | ||
196 | |||
197 | void outputExpression(LSL_Expression *exp) | ||
198 | { | ||
199 | switch(exp->type) | ||
200 | { | ||
201 | case LSL_COMMENT : return; | ||
202 | case LSL_TYPE : return; | ||
203 | case LSL_NAME : return; | ||
204 | case LSL_IDENTIFIER : return; | ||
205 | case LSL_FLOAT : printf("%f", exp->value.floatValue); break; | ||
206 | case LSL_INTEGER : printf("%d", exp->value.integerValue); break; | ||
207 | case LSL_STRING : return; | ||
208 | case LSL_KEY : return; | ||
209 | case LSL_VECTOR : return; | ||
210 | case LSL_ROTATION : return; | ||
211 | case LSL_LIST : return; | ||
212 | case LSL_LABEL : return; | ||
213 | case LSL_EXPRESSION : | ||
214 | outputExpression(exp->left); | ||
215 | printf(" %s ", LSL_Tokens[exp->expression].token); | ||
216 | outputExpression(exp->right); | ||
217 | break; | ||
218 | case LSL_DO : return; | ||
219 | case LSL_FOR : return; | ||
220 | case LSL_IF : return; | ||
221 | case LSL_ELSE : return; | ||
222 | case LSL_ELSEIF : return; | ||
223 | case LSL_JUMP : return; | ||
224 | case LSL_STATE_CHANGE : return; | ||
225 | case LSL_WHILE : return; | ||
226 | case LSL_RETURN : return; | ||
227 | case LSL_STATEMENT : return; | ||
228 | case LSL_BLOCK : return; | ||
229 | case LSL_PARAMETER : return; | ||
230 | case LSL_FUNCTION : return; | ||
231 | case LSL_STATE : return; | ||
232 | case LSL_SCRIPT : return; | ||
233 | } | ||
234 | } | ||
235 | |||
236 | void convertExpression2Lua(LSL_Expression *exp) | ||
237 | { | ||
238 | switch(exp->type) | ||
239 | { | ||
240 | case LSL_COMMENT : return; | ||
241 | case LSL_TYPE : return; | ||
242 | case LSL_NAME : return; | ||
243 | case LSL_IDENTIFIER : return; | ||
244 | case LSL_FLOAT : return; | ||
245 | case LSL_INTEGER : return; | ||
246 | case LSL_STRING : return; | ||
247 | case LSL_KEY : return; | ||
248 | case LSL_VECTOR : return; | ||
249 | case LSL_ROTATION : return; | ||
250 | case LSL_LIST : return; | ||
251 | case LSL_LABEL : return; | ||
252 | case LSL_EXPRESSION : return; | ||
253 | case LSL_DO : return; | ||
254 | case LSL_FOR : return; | ||
255 | case LSL_IF : return; | ||
256 | case LSL_ELSE : return; | ||
257 | case LSL_ELSEIF : return; | ||
258 | case LSL_JUMP : return; | ||
259 | case LSL_STATE_CHANGE : return; | ||
260 | case LSL_WHILE : return; | ||
261 | case LSL_RETURN : return; | ||
262 | case LSL_STATEMENT : return; | ||
263 | case LSL_BLOCK : return; | ||
264 | case LSL_PARAMETER : return; | ||
265 | case LSL_FUNCTION : return; | ||
266 | case LSL_STATE : return; | ||
267 | case LSL_SCRIPT : return; | ||
268 | } | ||
78 | } | 269 | } |
79 | 270 | ||
80 | int yyerror(const char *msg) | 271 | int yyerror(const char *msg) |
81 | { | 272 | { |
82 | fprintf(stderr,"Error:%s\n",msg); return 0; | 273 | fprintf(stderr, "Parser error: %s\n", msg); |
274 | return 0; | ||
83 | } | 275 | } |
84 | 276 | ||