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