Mercurial > repos > blastem
comparison debug.c @ 2171:4b47155965c8
Implement parentheses in debugger parser
author | Michael Pavone <pavone@retrodev.com> |
---|---|
date | Sat, 06 Aug 2022 15:03:07 -0700 |
parents | ada3130b1396 |
children | a00773a336d8 |
comparison
equal
deleted
inserted
replaced
2170:ada3130b1396 | 2171:4b47155965c8 |
---|---|
70 TOKEN_NAME, | 70 TOKEN_NAME, |
71 TOKEN_OPER, | 71 TOKEN_OPER, |
72 TOKEN_SIZE, | 72 TOKEN_SIZE, |
73 TOKEN_LBRACKET, | 73 TOKEN_LBRACKET, |
74 TOKEN_RBRACKET, | 74 TOKEN_RBRACKET, |
75 TOKEN_LPAREN, | |
76 TOKEN_RPAREN | |
75 } token_type; | 77 } token_type; |
76 | 78 |
77 static const char *token_type_names[] = { | 79 static const char *token_type_names[] = { |
78 "TOKEN_NONE", | 80 "TOKEN_NONE", |
79 "TOKEN_NUM", | 81 "TOKEN_NUM", |
80 "TOKEN_NAME", | 82 "TOKEN_NAME", |
81 "TOKEN_OPER", | 83 "TOKEN_OPER", |
82 "TOKEN_SIZE", | 84 "TOKEN_SIZE", |
83 "TOKEN_LBRACKET", | 85 "TOKEN_LBRACKET", |
84 "TOKEN_RBRACKET" | 86 "TOKEN_RBRACKET", |
87 "TOKEN_LPAREN", | |
88 "TOKEN_RPAREN" | |
85 }; | 89 }; |
86 | 90 |
87 typedef struct { | 91 typedef struct { |
88 token_type type; | 92 token_type type; |
89 union { | 93 union { |
165 case ']': | 169 case ']': |
166 *end = start + 1; | 170 *end = start + 1; |
167 return (token) { | 171 return (token) { |
168 .type = TOKEN_RBRACKET | 172 .type = TOKEN_RBRACKET |
169 }; | 173 }; |
174 case '(': | |
175 *end = start + 1; | |
176 return (token) { | |
177 .type = TOKEN_LPAREN | |
178 }; | |
179 case ')': | |
180 *end = start + 1; | |
181 return (token) { | |
182 .type = TOKEN_RPAREN | |
183 }; | |
170 } | 184 } |
171 *end = start + 1; | 185 *end = start + 1; |
172 while (**end && !isblank(**end) && **end != '.') | 186 while (**end && !isblank(**end) && **end != '.') |
173 { | 187 { |
174 ++*end; | 188 ++*end; |
262 if (size.type == TOKEN_SIZE) { | 276 if (size.type == TOKEN_SIZE) { |
263 *end = after_size; | 277 *end = after_size; |
264 ret->op = size; | 278 ret->op = size; |
265 } | 279 } |
266 return ret; | 280 return ret; |
281 } | |
282 if (first.type == TOKEN_LPAREN) { | |
283 expr *ret = parse_expression(after_first, end); | |
284 if (!ret) { | |
285 fprintf(stderr, "Expression expected after `(`\n"); | |
286 return NULL; | |
287 } | |
288 token rparen = parse_token(*end, end); | |
289 if (rparen.type != TOKEN_RPAREN) { | |
290 fprintf(stderr, "Missing closing `)`"); | |
291 free_expr(ret); | |
292 return NULL; | |
293 } | |
294 return ret; | |
295 } | |
296 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) { | |
297 fprintf(stderr, "Unexpected token %s\n", token_type_names[first.type]); | |
298 return NULL; | |
267 } | 299 } |
268 token second = parse_token(after_first, end); | 300 token second = parse_token(after_first, end); |
269 if (second.type != TOKEN_SIZE) { | 301 if (second.type != TOKEN_SIZE) { |
270 expr *ret = calloc(1, sizeof(expr)); | 302 expr *ret = calloc(1, sizeof(expr)); |
271 ret->type = EXPR_SCALAR; | 303 ret->type = EXPR_SCALAR; |
388 token size = parse_token(*end, &after_size); | 420 token size = parse_token(*end, &after_size); |
389 if (size.type == TOKEN_SIZE) { | 421 if (size.type == TOKEN_SIZE) { |
390 *end = after_size; | 422 *end = after_size; |
391 ret->op = size; | 423 ret->op = size; |
392 } | 424 } |
393 return ret; | 425 return maybe_muldiv(ret, *end, end); |
426 } | |
427 if (first.type == TOKEN_LPAREN) { | |
428 expr *ret = parse_expression(after_first, end); | |
429 if (!ret) { | |
430 fprintf(stderr, "Expression expected after `(`\n"); | |
431 return NULL; | |
432 } | |
433 token rparen = parse_token(*end, end); | |
434 if (rparen.type != TOKEN_RPAREN) { | |
435 fprintf(stderr, "Missing closing `)`"); | |
436 free_expr(ret); | |
437 return NULL; | |
438 } | |
439 return maybe_muldiv(ret, *end, end); | |
440 } | |
441 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) { | |
442 fprintf(stderr, "Unexpected token %s\n", token_type_names[first.type]); | |
443 return NULL; | |
394 } | 444 } |
395 char *after_second; | 445 char *after_second; |
396 token second = parse_token(after_first, &after_second); | 446 token second = parse_token(after_first, &after_second); |
397 if (second.type == TOKEN_OPER) { | 447 if (second.type == TOKEN_OPER) { |
398 expr *ret; | 448 expr *ret; |
484 token size = parse_token(*end, &after_size); | 534 token size = parse_token(*end, &after_size); |
485 if (size.type == TOKEN_SIZE) { | 535 if (size.type == TOKEN_SIZE) { |
486 *end = after_size; | 536 *end = after_size; |
487 ret->op = size; | 537 ret->op = size; |
488 } | 538 } |
489 return ret; | 539 return maybe_binary(ret, *end, end); |
540 } | |
541 if (first.type == TOKEN_LPAREN) { | |
542 expr *ret = parse_expression(after_first, end); | |
543 if (!ret) { | |
544 fprintf(stderr, "Expression expected after `(`\n"); | |
545 return NULL; | |
546 } | |
547 token rparen = parse_token(*end, end); | |
548 if (rparen.type != TOKEN_RPAREN) { | |
549 fprintf(stderr, "Missing closing `)`"); | |
550 free_expr(ret); | |
551 return NULL; | |
552 } | |
553 return maybe_binary(ret, *end, end); | |
554 } | |
555 if (first.type != TOKEN_NUM && first.type != TOKEN_NAME) { | |
556 fprintf(stderr, "Unexpected token %s\n", token_type_names[first.type]); | |
557 return NULL; | |
490 } | 558 } |
491 char *after_second; | 559 char *after_second; |
492 token second = parse_token(after_first, &after_second); | 560 token second = parse_token(after_first, &after_second); |
493 if (second.type == TOKEN_OPER) { | 561 if (second.type == TOKEN_OPER) { |
494 expr *bin = calloc(1, sizeof(expr)); | 562 expr *bin = calloc(1, sizeof(expr)); |