aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/LuaSL/src/LuaSL_LSL_tree.c
diff options
context:
space:
mode:
Diffstat (limited to 'LuaSL/src/LuaSL_LSL_tree.c')
-rw-r--r--LuaSL/src/LuaSL_LSL_tree.c278
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 */
12static SExpression* newExpression(EOperationType type, SExpression *left, SExpression *right, int value) 16
17/*
18static 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
26SExpression* createNumber(int value) 34void 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
31SExpression *createOperation(EOperationType type, SExpression *left, SExpression *right) 43static 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
36int evaluate(SExpression *e) 57void 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); 66LSL_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
52void deleteExpression(SExpression *b) 76LSL_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
62SExpression *getAST(const char *expr) 86LSL_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(&param))
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
105int 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
197void 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
236void 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
80int yyerror(const char *msg) 271int 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
generated by cgit v1.1 at 2024-07-06 18:07:59 +0000