Mercurial > hg-old > index.cgi
annotate src/expr.c @ 51:04868fa52a15
Fixed context counting for second pass so local symbols work correctly
author | lost |
---|---|
date | Sun, 04 Jan 2009 20:14:54 +0000 |
parents | 804d7465e0f9 |
children | 73423b66e511 |
rev | line source |
---|---|
13
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
1 /* |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
2 expr.c |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
3 Copyright © 2008 William Astle |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
4 |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
5 This file is part of LWASM. |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
6 |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
7 LWASM is free software: you can redistribute it and/or modify it under the |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
8 terms of the GNU General Public License as published by the Free Software |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
9 Foundation, either version 3 of the License, or (at your option) any later |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
10 version. |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
11 |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
12 This program is distributed in the hope that it will be useful, but WITHOUT |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
15 more details. |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
16 |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
17 You should have received a copy of the GNU General Public License along with |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
18 this program. If not, see <http://www.gnu.org/licenses/>. |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
19 */ |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
20 |
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
21 /* |
18 | 22 This file contains the actual expression evaluator |
13
05d4115b4860
Started work on new expression evaluator system and major code re-work for next release
lost
parents:
diff
changeset
|
23 */ |
14 | 24 |
25 #define __expr_c_seen__ | |
15 | 26 |
18 | 27 #include <ctype.h> |
15 | 28 #include <stdlib.h> |
18 | 29 #include <string.h> |
15 | 30 |
14 | 31 #include "expr.h" |
17 | 32 #include "util.h" |
40
d2cee0c335e7
adjusted symbol rules to accept symbols starting with @ but not @<digit>
lost
parents:
39
diff
changeset
|
33 #include "lwasm.h" |
39 | 34 |
17 | 35 lwasm_expr_stack_t *lwasm_expr_stack_create(void) |
36 { | |
37 lwasm_expr_stack_t *s; | |
38 | |
39 s = lwasm_alloc(sizeof(lwasm_expr_stack_t)); | |
40 s -> head = NULL; | |
41 s -> tail = NULL; | |
42 return s; | |
43 } | |
15 | 44 |
17 | 45 void lwasm_expr_stack_free(lwasm_expr_stack_t *s) |
46 { | |
47 while (s -> head) | |
48 { | |
49 s -> tail = s -> head; | |
50 s -> head = s -> head -> next; | |
51 lwasm_expr_term_free(s -> tail -> term); | |
52 lwasm_free(s -> tail); | |
53 } | |
54 lwasm_free(s); | |
55 } | |
14 | 56 |
17 | 57 void lwasm_expr_term_free(lwasm_expr_term_t *t) |
58 { | |
59 if (t) | |
60 { | |
44 | 61 if (t -> term_type == LWASM_TERM_SYM) |
17 | 62 lwasm_free(t -> symbol); |
63 lwasm_free(t); | |
64 } | |
65 } | |
66 | |
67 lwasm_expr_term_t *lwasm_expr_term_create_oper(int oper) | |
68 { | |
69 lwasm_expr_term_t *t; | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
70 |
39 | 71 debug_message(10, "Creating operator term: %d", oper); |
17 | 72 |
73 t = lwasm_alloc(sizeof(lwasm_expr_term_t)); | |
74 t -> term_type = LWASM_TERM_OPER; | |
75 t -> value = oper; | |
76 return t; | |
77 } | |
15 | 78 |
17 | 79 lwasm_expr_term_t *lwasm_expr_term_create_int(int val) |
14 | 80 { |
17 | 81 lwasm_expr_term_t *t; |
39 | 82 debug_message(10, "Creating integer term: %d", val); |
17 | 83 |
84 t = lwasm_alloc(sizeof(lwasm_expr_term_t)); | |
85 t -> term_type = LWASM_TERM_INT; | |
86 t -> value = val; | |
87 return t; | |
88 } | |
89 | |
90 lwasm_expr_term_t *lwasm_expr_term_create_sym(char *sym) | |
91 { | |
92 lwasm_expr_term_t *t; | |
14 | 93 |
39 | 94 debug_message(10, "Creating symbol term: %s", sym); |
95 | |
17 | 96 t = lwasm_alloc(sizeof(lwasm_expr_term_t)); |
97 t -> term_type = LWASM_TERM_SYM; | |
98 t -> symbol = lwasm_strdup(sym); | |
99 return t; | |
100 } | |
15 | 101 |
17 | 102 lwasm_expr_term_t *lwasm_expr_term_dup(lwasm_expr_term_t *t) |
103 { | |
104 switch (t -> term_type) | |
15 | 105 { |
17 | 106 case LWASM_TERM_INT: |
107 return lwasm_expr_term_create_int(t -> value); | |
108 | |
109 case LWASM_TERM_OPER: | |
110 return lwasm_expr_term_create_oper(t -> value); | |
111 | |
112 case LWASM_TERM_SYM: | |
113 return lwasm_expr_term_create_sym(t -> symbol); | |
114 | |
115 default: | |
39 | 116 debug_message(0, "lwasm_expr_term_dup(): invalid term type %d", t -> term_type); |
17 | 117 exit(1); |
118 } | |
119 // can't get here | |
120 } | |
121 | |
122 void lwasm_expr_stack_push(lwasm_expr_stack_t *s, lwasm_expr_term_t *t) | |
123 { | |
124 lwasm_expr_stack_node_t *n; | |
125 | |
126 if (!s) | |
127 { | |
39 | 128 debug_message(0, "lwasm_expr_stack_push(): invalid stack pointer"); |
17 | 129 exit(1); |
15 | 130 } |
131 | |
17 | 132 n = lwasm_alloc(sizeof(lwasm_expr_stack_node_t)); |
133 n -> next = NULL; | |
134 n -> prev = s -> tail; | |
135 n -> term = lwasm_expr_term_dup(t); | |
136 | |
137 if (s -> head) | |
138 { | |
139 s -> tail -> next = n; | |
140 s -> tail = n; | |
141 } | |
142 else | |
15 | 143 { |
17 | 144 s -> head = n; |
145 s -> tail = n; | |
146 } | |
147 } | |
148 | |
149 lwasm_expr_term_t *lwasm_expr_stack_pop(lwasm_expr_stack_t *s) | |
150 { | |
151 lwasm_expr_term_t *t; | |
152 lwasm_expr_stack_node_t *n; | |
153 | |
154 if (!(s -> tail)) | |
155 return NULL; | |
156 | |
157 n = s -> tail; | |
158 s -> tail = n -> prev; | |
159 if (!(n -> prev)) | |
160 { | |
161 s -> head = NULL; | |
15 | 162 } |
14 | 163 |
17 | 164 t = n -> term; |
165 n -> term = NULL; | |
166 | |
167 lwasm_free(n); | |
168 | |
169 return t; | |
14 | 170 } |
18 | 171 |
172 // the following two functions are co-routines which actually parse | |
173 // an infix expression onto the expression stack, each returns -1 | |
174 // if an error is encountered | |
175 | |
176 /* | |
177 parse a term and push it onto the stack | |
178 | |
179 this function handles unary prefix operators (-, +, .not., .com.) | |
180 as well as () | |
181 */ | |
182 int lwasm_expr_parse_term(lwasm_expr_stack_t *s, const char **p) | |
183 { | |
184 lwasm_expr_term_t *t; | |
39 | 185 debug_message(2, "Expression string %s", *p); |
186 | |
18 | 187 eval_next: |
188 if (**p == '(') | |
189 { | |
39 | 190 debug_message(3, "Starting paren"); |
18 | 191 (*p)++; |
192 lwasm_expr_parse_expr(s, p, 0); | |
193 if (**p != ')') | |
194 return -1; | |
195 (*p)++; | |
196 return 0; | |
197 } | |
198 | |
199 if (**p == '+') | |
200 { | |
39 | 201 debug_message(3, "Unary +"); |
18 | 202 (*p)++; |
203 goto eval_next; | |
204 } | |
205 | |
206 if (**p == '-') | |
207 { | |
208 // parse expression following "-" | |
209 (*p)++; | |
210 if (lwasm_expr_parse_expr(s, p, 200) < 0) | |
211 return -1; | |
212 t = lwasm_expr_term_create_oper(LWASM_OPER_NEG); | |
213 lwasm_expr_stack_push(s, t); | |
214 lwasm_expr_term_free(t); | |
215 return 0; | |
216 } | |
217 | |
23 | 218 if (**p == '^') |
219 { | |
220 // parse expression following "^" | |
221 (*p)++; | |
222 if (lwasm_expr_parse_expr(s, p, 200) < 0) | |
223 return -1; | |
224 t = lwasm_expr_term_create_oper(LWASM_OPER_COM); | |
225 lwasm_expr_stack_push(s, t); | |
226 lwasm_expr_term_free(t); | |
227 return 0; | |
228 } | |
229 | |
18 | 230 /* |
231 we have an actual term here so evaluate it | |
232 | |
233 it could be one of the following: | |
234 | |
235 1. a decimal constant | |
236 2. a hexadecimal constant | |
237 3. an octal constant | |
238 4. a binary constant | |
239 5. a symbol reference | |
240 6. the "current" instruction address (*) | |
241 7. the "current" data address (.) | |
242 8. a "back reference" (<) | |
243 9. a "forward reference" (>) | |
244 | |
245 items 6 through 9 are stored as symbol references | |
246 | |
247 (a . followed by a . or a alpha char or number is a symbol) | |
248 */ | |
249 if (**p == '*' | |
250 || ( | |
251 **p == '.' | |
252 && (*p)[1] != '.' | |
253 && !((*p)[1] >= 'A' && (*p)[1] <= 'Z') | |
254 && !((*p)[1] >= 'a' && (*p)[1] <= 'z') | |
255 && !((*p)[1] >= '0' && (*p)[1] <= '9') | |
256 ) | |
257 || **p == '<' | |
258 || **p == '>') | |
259 { | |
260 char tstr[2]; | |
261 tstr[0] = **p; | |
262 tstr[1] = '\0'; | |
263 t = lwasm_expr_term_create_sym(tstr); | |
264 lwasm_expr_stack_push(s, t); | |
265 lwasm_expr_term_free(t); | |
266 (*p)++; | |
267 return 0; | |
268 } | |
269 | |
270 /* | |
271 - a symbol will be a string of characters introduced by a letter, ".", | |
272 "_" but NOT a number | |
273 - a decimal constant will consist of only digits, optionally prefixed | |
274 with "&" | |
275 - a binary constant will consist of only 0s and 1s either prefixed with % | |
276 or suffixed with "B" | |
277 - a hex constant will consist of 0-9A-F either prefixed with $ or | |
278 suffixed with "H"; a hex number starting with A-F must be prefixed | |
279 with $ or start with 0 and end with H | |
280 - an octal constant will consist of 0-7 either prefixed with @ or | |
281 suffixed with "O" or "Q" | |
282 - an ascii constant will be a single character prefixed with a ' | |
283 - a double ascii constant will be two characters prefixed with a " | |
284 | |
285 */ | |
286 if (**p == '"') | |
287 { | |
288 // double ascii constant | |
289 int val; | |
290 (*p)++; | |
291 if (!**p) | |
292 return -1; | |
293 if (!*((*p)+1)) | |
294 return -1; | |
295 val = **p << 8 | *((*p) + 1); | |
296 (*p) += 2; | |
297 t = lwasm_expr_term_create_int(val); | |
298 lwasm_expr_stack_push(s, t); | |
299 lwasm_expr_term_free(t); | |
300 return 0; | |
301 } | |
302 else if (**p == '\'') | |
303 { | |
304 // single ascii constant | |
305 int val; | |
306 (*p)++; | |
307 if (!**p) | |
308 return -1; | |
309 val = **p; | |
310 (*p)++; | |
311 t = lwasm_expr_term_create_int(val); | |
312 lwasm_expr_stack_push(s, t); | |
313 lwasm_expr_term_free(t); | |
314 } | |
315 else if (**p == '&') | |
316 { | |
317 // decimal constant | |
318 int val = 0; | |
319 | |
320 (*p)++; | |
47
804d7465e0f9
Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents:
44
diff
changeset
|
321 while (**p && strchr("0123456789", **p)) |
18 | 322 { |
323 val = val * 10 + (**p - '0'); | |
324 (*p)++; | |
325 } | |
326 t = lwasm_expr_term_create_int(val); | |
327 lwasm_expr_stack_push(s, t); | |
328 lwasm_expr_term_free(t); | |
329 return 0; | |
330 } | |
331 else if (**p == '%') | |
332 { | |
333 // binary constant | |
334 int val = 0; | |
335 | |
336 (*p)++; | |
337 while (**p == '0' || **p == '1') | |
338 { | |
339 val = val * 2 + (**p - '0'); | |
340 (*p)++; | |
341 } | |
342 t = lwasm_expr_term_create_int(val); | |
343 lwasm_expr_stack_push(s, t); | |
344 lwasm_expr_term_free(t); | |
345 return 0; | |
346 } | |
347 else if (**p == '$') | |
348 { | |
349 // hexadecimal constant | |
350 int val = 0, val2; | |
351 | |
352 (*p)++; | |
47
804d7465e0f9
Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents:
44
diff
changeset
|
353 debug_message(3, "Found prefix hex constant: %s", *p); |
804d7465e0f9
Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents:
44
diff
changeset
|
354 while (**p && strchr("0123456789ABCDEFabcdef", **p)) |
18 | 355 { |
356 val2 = toupper(**p) - '0'; | |
357 if (val2 > 9) | |
358 val2 -= 7; | |
47
804d7465e0f9
Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents:
44
diff
changeset
|
359 debug_message(3, "Got char: %c (%d)", **p, val2); |
18 | 360 val = val * 16 + val2; |
361 (*p)++; | |
362 } | |
363 t = lwasm_expr_term_create_int(val); | |
364 lwasm_expr_stack_push(s, t); | |
365 lwasm_expr_term_free(t); | |
366 return 0; | |
367 } | |
40
d2cee0c335e7
adjusted symbol rules to accept symbols starting with @ but not @<digit>
lost
parents:
39
diff
changeset
|
368 // an @ followed by a digit is an octal number |
d2cee0c335e7
adjusted symbol rules to accept symbols starting with @ but not @<digit>
lost
parents:
39
diff
changeset
|
369 // but if it's followed by anything else, it is a symbol |
d2cee0c335e7
adjusted symbol rules to accept symbols starting with @ but not @<digit>
lost
parents:
39
diff
changeset
|
370 else if (**p == '@' && isdigit(*(*p + 1))) |
18 | 371 { |
372 // octal constant | |
373 int val = 0; | |
374 | |
375 (*p)++; | |
47
804d7465e0f9
Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents:
44
diff
changeset
|
376 while (**p && strchr("01234567", **p)) |
18 | 377 { |
378 val = val * 8 + (**p - '0'); | |
379 (*p)++; | |
380 } | |
381 t = lwasm_expr_term_create_int(val); | |
382 lwasm_expr_stack_push(s, t); | |
383 lwasm_expr_term_free(t); | |
384 return 0; | |
385 } | |
386 | |
387 // symbol or bare decimal or suffix identified constant here | |
388 // all numbers will start with a digit at this point | |
389 if (**p < '0' || **p > '9') | |
390 { | |
391 int l = 0; | |
392 char *sb; | |
393 | |
394 // evaluate a symbol here | |
41 | 395 static const char *symchars = "_.$@?abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; |
396 while ((*p)[l] && strchr(symchars, (*p)[l])) | |
18 | 397 l++; |
398 | |
399 if (l == 0) | |
400 return -1; | |
401 | |
402 sb = lwasm_alloc(l + 1); | |
403 sb[l] = '\0'; | |
404 memcpy(sb, *p, l); | |
405 t = lwasm_expr_term_create_sym(sb); | |
406 lwasm_expr_stack_push(s, t); | |
407 lwasm_expr_term_free(t); | |
41 | 408 (*p) += l; |
409 debug_message(3, "Symbol: '%s'; (%s)", sb, *p); | |
18 | 410 lwasm_free(sb); |
411 return 0; | |
412 } | |
413 | |
414 if (!**p) | |
415 return -1; | |
416 | |
417 // evaluate a suffix based constant | |
418 { | |
419 int decval = 0, binval = 0, hexval = 0, octval = 0; | |
420 int valtype = 15; // 1 = bin, 2 = oct, 4 = dec, 8 = hex | |
421 int bindone = 0; | |
422 int val; | |
423 int dval; | |
424 | |
425 while (1) | |
426 { | |
427 if (!**p || !strchr("0123456789ABCDEFabcdefqhoQHO", **p)) | |
428 { | |
429 // we can legally have bin or decimal here | |
430 if (bindone) | |
431 { | |
432 // we just finished a binary value | |
433 val = binval; | |
434 break; | |
435 } | |
436 else if (valtype & 4) | |
437 { | |
438 // otherwise we must be decimal (if we're still allowed one) | |
439 val = decval; | |
39 | 440 debug_message(3, "End of decimal value"); |
18 | 441 break; |
442 } | |
443 else | |
444 { | |
445 // bad value | |
446 return -1; | |
447 } | |
448 } | |
449 | |
450 dval = toupper(**p); | |
451 (*p)++; | |
452 | |
453 if (bindone) | |
454 { | |
455 // any characters past "B" means it is not binary | |
456 bindone = 0; | |
457 valtype &= 14; | |
458 } | |
459 | |
460 switch (dval) | |
461 { | |
462 case 'Q': | |
463 case 'O': | |
464 if (valtype & 2) | |
465 { | |
466 val = octval; | |
467 valtype = -1; | |
468 break; | |
469 } | |
470 else | |
471 { | |
472 // not a valid octal value | |
473 return -1; | |
474 } | |
475 /* can't get here */ | |
476 | |
477 case 'H': | |
478 if (valtype & 8) | |
479 { | |
480 val = hexval; | |
481 valtype = -1; | |
482 break; | |
483 } | |
484 else | |
485 { | |
486 // not a valid hex number | |
487 return -1; | |
488 } | |
489 /* can't get here */ | |
490 | |
491 case 'B': | |
492 // this is a bit of a sticky one since B is a legit hex | |
493 // digit so this may or may not be the end of the number | |
494 // so we fall through to the digit case | |
495 | |
496 if (valtype & 1) | |
497 { | |
498 // could still be binary | |
499 bindone = 1; | |
500 valtype = 9; // hex and binary | |
501 } | |
502 /* fall through intentional */ | |
503 | |
504 default: | |
505 // digit | |
506 dval -= '0'; | |
507 if (dval > 9) | |
508 dval -= 7; | |
39 | 509 debug_message(3, "Got digit: %d", dval); |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
510 // if (dval > 1) |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
511 // valtype &= 14; |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
512 // if (dval > 7) |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
513 // valtype &= 12; |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
514 // if (dval > 9) |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
515 // valtype &= 8; |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
516 |
18 | 517 if (valtype & 8) |
518 { | |
519 hexval = hexval * 16 + dval; | |
520 } | |
521 if (valtype & 4) | |
522 { | |
523 if (dval > 9) | |
524 valtype &= 11; | |
525 else | |
526 decval = decval * 10 + dval; | |
527 } | |
528 if (valtype & 2) | |
529 { | |
530 if (dval > 7) | |
531 valtype &= 13; | |
532 else | |
533 octval = octval * 8 + dval; | |
534 } | |
535 if (valtype & 1) | |
536 { | |
537 if (dval > 1) | |
538 valtype &= 14; | |
539 else | |
540 binval = binval * 2 + dval; | |
541 } | |
542 } | |
543 // break out if we have a return value | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
544 if (valtype == -1) |
18 | 545 break; |
546 // return if no more valid possibilities! | |
547 if (valtype == 0) | |
548 return -1; | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
549 val = decval; // in case we fall through |
18 | 550 } |
551 | |
552 // we get here when we have a value to return | |
553 t = lwasm_expr_term_create_int(val); | |
554 lwasm_expr_stack_push(s, t); | |
555 lwasm_expr_term_free(t); | |
556 return 0; | |
557 } | |
558 /* can't get here */ | |
559 } | |
560 | |
561 // parse an expression and push the result onto the stack | |
562 // if an operator of lower precedence than the value of "prec" is found, | |
563 int lwasm_expr_parse_expr(lwasm_expr_stack_t *s, const char **p, int prec) | |
564 { | |
565 static const struct operinfo | |
566 { | |
567 int opernum; | |
568 char *operstr; | |
569 int operprec; | |
570 } operators[] = | |
571 { | |
572 { LWASM_OPER_PLUS, "+", 100 }, | |
573 { LWASM_OPER_MINUS, "-", 100 }, | |
574 { LWASM_OPER_TIMES, "*", 150 }, | |
575 { LWASM_OPER_DIVIDE, "/", 150 }, | |
576 { LWASM_OPER_MOD, "%", 150 }, | |
577 { LWASM_OPER_INTDIV, "\\", 150 }, | |
578 | |
579 { LWASM_OPER_NONE, "", 0 } | |
580 }; | |
581 int opern, i; | |
582 lwasm_expr_term_t *operterm; | |
583 | |
584 // return if we are at the end of the expression or a subexpression | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
585 if (!**p || isspace(**p) || **p == ')' || **p == ',') |
18 | 586 return 0; |
587 | |
588 if (lwasm_expr_parse_term(s, p) < 0) | |
589 return -1; | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
590 |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
591 eval_next: |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
592 if (!**p || isspace(**p) || **p == ')' || **p == ',') |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
593 return 0; |
18 | 594 |
595 // expecting an operator here | |
596 for (opern = 0; operators[opern].opernum != LWASM_OPER_NONE; opern++) | |
597 { | |
598 for (i = 0; (*p)[i] && operators[opern].operstr[i] && (*p[i] == operators[opern].operstr[i]); i++) | |
599 /* do nothing */ ; | |
600 if (operators[opern].operstr[i] == '\0') | |
601 break; | |
602 } | |
603 if (operators[opern].opernum == LWASM_OPER_NONE) | |
604 { | |
605 // unrecognized operator | |
606 return -1; | |
607 } | |
608 | |
609 // the operator number in question is in opern; i is the length of the | |
610 // operator string | |
611 | |
612 // logic: | |
613 // if the precedence of this operation is <= to the "prec" flag, | |
614 // we simply return without advancing the input pointer; the operator | |
615 // will be evaluated again in the enclosing function call | |
616 if (operators[opern].operprec <= prec) | |
617 return 0; | |
618 | |
619 // logic: | |
620 // we have a higher precedence operator here so we will advance the | |
621 // input pointer to the next term and let the expression evaluator | |
622 // loose on it after which time we will push our operator onto the | |
623 // stack and then go on with the expression evaluation | |
624 (*p) += i; // advance input pointer | |
625 | |
626 // evaluate next expression(s) of higher precedence | |
627 if (lwasm_expr_parse_expr(s, p, operators[opern].operprec) < 0) | |
628 return -1; | |
629 | |
630 operterm = lwasm_expr_term_create_oper(operators[opern].opernum); | |
631 lwasm_expr_stack_push(s, operterm); | |
632 lwasm_expr_term_free(operterm); | |
633 | |
634 // return if we are at the end of the expression or a subexpression | |
635 if (!**p || isspace(**p) || **p == ')') | |
636 return 0; | |
637 | |
638 // continue evaluating | |
639 goto eval_next; | |
640 } | |
641 | |
642 /* | |
643 actually evaluate an expression | |
644 | |
645 This happens in two stages. The first stage merely parses the expression into | |
646 a lwasm_expr_stack_t * which is then evaluated as much as possible before the | |
647 result is returned. | |
648 | |
649 Returns NULL on a parse error or otherwise invalid expression. *outp will | |
650 contain the pointer to the next character after the expression if and only | |
651 if there is no error. In the case of an error, *outp is undefined. | |
652 */ | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
653 lwasm_expr_stack_t *lwasm_expr_eval(const char *inp, const char **outp, int (*sfunc)(char *sym, void *state, int *val), void *state) |
18 | 654 { |
655 lwasm_expr_stack_t *s; | |
656 const char *p; | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
657 int rval; |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
658 |
18 | 659 // actually parse the expression |
660 p = inp; | |
661 s = lwasm_expr_stack_create(); | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
662 |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
663 rval = lwasm_expr_parse_expr(s, &p, 0); |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
664 if (rval < 0) |
18 | 665 goto cleanup_error; |
666 | |
667 // save end of expression | |
668 if (outp) | |
669 (*outp) = p; | |
670 | |
671 // return potentially partial expression | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
672 if (lwasm_expr_reval(s, sfunc, state) < 0) |
18 | 673 goto cleanup_error; |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
674 |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
675 if (lwasm_expr_is_constant(s)) |
39 | 676 debug_message(3, "Constant expression evaluates to: %d", lwasm_expr_get_value(s)); |
18 | 677 |
678 return s; | |
679 | |
680 cleanup_error: | |
681 lwasm_expr_stack_free(s); | |
682 return NULL; | |
683 } | |
684 | |
685 /* | |
686 take an expression stack s and scan for operations that can be completed | |
687 | |
688 return -1 on error, 0 on no error | |
689 | |
690 possible errors are: division by zero or unknown operator | |
691 | |
692 theory of operation: | |
693 | |
694 scan the stack for an operator which has two constants preceding it (binary) | |
695 or 1 constant preceding it (unary) and if found, perform the calculation | |
696 and replace the operator and its operands with the result | |
697 | |
698 repeat the scan until no futher simplications are found or if there are no | |
699 further operators or only a single term remains | |
700 | |
701 */ | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
702 int lwasm_expr_reval(lwasm_expr_stack_t *s, int (*sfunc)(char *sym, void *state, int *val), void *state) |
18 | 703 { |
704 lwasm_expr_stack_node_t *n; | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
705 int sval; |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
706 |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
707 // resolve symbols |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
708 // symbols that do not resolve to a constant are left alone |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
709 for (n = s -> head; n; n = n -> next) |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
710 { |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
711 if (n -> term -> term_type == LWASM_TERM_SYM) |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
712 { |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
713 if (sfunc(n -> term -> symbol, state, &sval) == 0) |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
714 { |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
715 n -> term -> term_type = LWASM_TERM_INT; |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
716 n -> term -> value = sval; |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
717 lwasm_free(n -> term -> symbol); |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
718 n -> term -> symbol = NULL; |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
719 } |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
720 } |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
23
diff
changeset
|
721 } |
18 | 722 |
723 next_iter: | |
724 // a single term | |
725 if (s -> head == s -> tail) | |
726 return 0; | |
727 | |
728 // search for an operator | |
729 for (n = s -> head; n; n = n -> next) | |
730 { | |
731 if (n -> term -> term_type == LWASM_TERM_OPER) | |
732 { | |
733 if (n -> term -> value == LWASM_OPER_NEG | |
734 || n -> term -> value == LWASM_OPER_COM | |
735 ) | |
736 { | |
737 // unary operator | |
738 if (n -> prev && n -> prev -> term -> term_type == LWASM_TERM_INT) | |
739 { | |
740 // a unary operator we can resolve | |
741 // we do the op then remove the term "n" is pointing at | |
742 if (n -> term -> value == LWASM_OPER_NEG) | |
743 { | |
744 n -> prev -> term -> value = -(n -> prev -> term -> value); | |
745 } | |
746 else if (n -> term -> value == LWASM_OPER_COM) | |
747 { | |
748 n -> prev -> term -> value = ~(n -> prev -> term -> value); | |
749 } | |
750 n -> prev -> next = n -> next; | |
751 if (n -> next) | |
752 n -> next -> prev = n -> prev; | |
753 else | |
754 s -> tail = n -> prev; | |
755 | |
756 lwasm_expr_term_free(n -> term); | |
757 lwasm_free(n); | |
758 break; | |
759 } | |
760 } | |
761 else | |
762 { | |
763 // binary operator | |
764 if (n -> prev && n -> prev -> prev && n -> prev -> term -> term_type == LWASM_TERM_INT && n -> prev -> prev -> term -> term_type == LWASM_TERM_INT) | |
765 { | |
766 // a binary operator we can resolve | |
767 switch (n -> term -> value) | |
768 { | |
769 case LWASM_OPER_PLUS: | |
770 n -> prev -> prev -> term -> value += n -> prev -> term -> value; | |
771 break; | |
772 | |
773 case LWASM_OPER_MINUS: | |
774 n -> prev -> prev -> term -> value -= n -> prev -> term -> value; | |
775 break; | |
776 | |
777 case LWASM_OPER_TIMES: | |
778 n -> prev -> prev -> term -> value *= n -> prev -> term -> value; | |
779 break; | |
780 | |
781 case LWASM_OPER_DIVIDE: | |
782 if (n -> prev -> term -> value == 0) | |
783 return -1; | |
784 n -> prev -> prev -> term -> value /= n -> prev -> term -> value; | |
785 break; | |
786 | |
787 case LWASM_OPER_MOD: | |
788 if (n -> prev -> term -> value == 0) | |
789 return -1; | |
790 n -> prev -> prev -> term -> value %= n -> prev -> term -> value; | |
791 break; | |
792 | |
793 case LWASM_OPER_INTDIV: | |
794 if (n -> prev -> term -> value == 0) | |
795 return -1; | |
796 n -> prev -> prev -> term -> value /= n -> prev -> term -> value; | |
797 break; | |
798 | |
799 case LWASM_OPER_BWAND: | |
800 n -> prev -> prev -> term -> value &= n -> prev -> term -> value; | |
801 break; | |
802 | |
803 case LWASM_OPER_BWOR: | |
804 n -> prev -> prev -> term -> value |= n -> prev -> term -> value; | |
805 break; | |
806 | |
807 case LWASM_OPER_BWXOR: | |
808 n -> prev -> prev -> term -> value ^= n -> prev -> term -> value; | |
809 break; | |
810 | |
811 case LWASM_OPER_AND: | |
812 n -> prev -> prev -> term -> value = (n -> prev -> term -> value && n -> prev -> prev -> term -> value) ? 1 : 0; | |
813 break; | |
814 | |
815 case LWASM_OPER_OR: | |
816 n -> prev -> prev -> term -> value = (n -> prev -> term -> value || n -> prev -> prev -> term -> value) ? 1 : 0; | |
817 break; | |
818 | |
819 default: | |
820 // return error if unknown operator! | |
821 return -1; | |
822 } | |
823 | |
824 // now remove the two unneeded entries from the stack | |
825 n -> prev -> prev -> next = n -> next; | |
826 if (n -> next) | |
827 n -> next -> prev = n -> prev -> prev; | |
828 else | |
829 s -> tail = n -> prev -> prev; | |
830 | |
831 lwasm_expr_term_free(n -> term); | |
832 lwasm_expr_term_free(n -> prev -> term); | |
833 lwasm_free(n -> prev); | |
834 lwasm_free(n); | |
835 break; | |
836 } | |
837 } | |
838 } | |
839 } | |
840 // note for the terminally confused about dynamic memory and pointers: | |
841 // n will not be NULL even after the lwasm_free calls above so | |
842 // this test will still work (n will be a dangling pointer) | |
843 // (n will only be NULL if we didn't find any operators to simplify) | |
844 if (n) | |
845 goto next_iter; | |
846 | |
847 return 0; | |
848 } |