![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expread.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb|
Return to expread.y CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 root 1: /* Parse C expressions for GDB.
2: Copyright (C) 1986 Free Software Foundation, Inc.
3:
4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY
5: WARRANTY. No author or distributor accepts responsibility to anyone
6: for the consequences of using it or for whether it serves any
7: particular purpose or works at all, unless he says so in writing.
8: Refer to the GDB General Public License for full details.
9:
10: Everyone is granted permission to copy, modify and redistribute GDB,
11: but only under the conditions described in the GDB General Public
12: License. A copy of this license is supposed to have been given to you
13: along with GDB so you can know your rights and responsibilities. It
14: should be in a file named COPYING. Among other things, the copyright
15: notice and this notice must be preserved on all copies.
16:
17: In other words, go ahead and share GDB, but don't try to stop
18: anyone else from sharing it farther. Help stamp out software hoarding!
19: */
20:
21: /* Parse a C expression from text in a string,
22: and return the result as a struct expression pointer.
23: That structure contains arithmetic operations in reverse polish,
24: with constants represented by operations that are followed by special data.
25: See expression.h for the details of the format.
26: What is important here is that it can be built up sequentially
27: during the process of parsing; the lower levels of the tree always
28: come first in the result. */
29:
30: %{
31: #include "defs.h"
32: #include "param.h"
33: #include "symtab.h"
34: #include "frame.h"
35: #include "expression.h"
36:
37: #include <stdio.h>
38:
39: static struct expression *expout;
40: static int expout_size;
41: static int expout_ptr;
42:
43: static int yylex ();
44: static yyerror ();
45: static void write_exp_elt ();
46: static void write_exp_string ();
47: static void start_arglist ();
48: static int end_arglist ();
49: static void free_funcalls ();
50: static char *copy_name ();
51:
52: /* If this is nonzero, this block is used as the lexical context
53: for symbol names. */
54:
55: static struct block *expression_context_block;
56:
57: /* Number of arguments seen so far in innermost function call. */
58: static int arglist_len;
59:
60: /* Data structure for saving values of arglist_len
61: for function calls whose arguments contain other function calls. */
62:
63: struct funcall
64: {
65: struct funcall *next;
66: int arglist_len;
67: };
68:
69: struct funcall *funcall_chain;
70:
71: /* This kind of datum is used to represent the name
72: of a symbol token. */
73:
74: struct stoken
75: {
76: char *ptr;
77: int length;
78: };
79: %}
80:
81: /* Although the yacc "value" of an expression is not used,
82: since the result is stored in the structure being created,
83: other node types do have values. */
84:
85: %union
86: {
87: long lval;
88: double dval;
89: struct symbol *sym;
90: struct type *tval;
91: struct stoken sval;
92: int voidval;
93: struct block *bval;
94: enum exp_opcode opcode;
95: struct internalvar *ivar;
96: }
97:
98: %type <voidval> exp exp1 start variable
99: %type <tval> type typebase
100: %type <bval> block
101:
102: %token <lval> INT CHAR
103: %token <dval> FLOAT
104:
105: /* Both NAME and TYPENAME tokens represent symbols in the input,
106: and both convey their data as strings.
107: But a TYPENAME is a string that happens to be defined as a typedef
108: or builtin type name (such as int or char)
109: and a NAME is any other symbol.
110:
111: Contexts where this distinction is not important can use the
112: nonterminal "name", which matches either NAME or TYPENAME. */
113:
114: %token <sval> NAME TYPENAME STRING
115: %type <sval> name
116:
117: %token STRUCT UNION ENUM SIZEOF UNSIGNED COLONCOLON
118:
119: %token <lval> LAST REGNAME
120:
121: %token <ivar> VARIABLE
122:
123: %token <opcode> ASSIGN_MODIFY
124:
125: %left ','
126: %left ABOVE_COMMA
127: %right '=' ASSIGN_MODIFY
128: %left OR
129: %left AND
130: %left '|'
131: %left '^'
132: %left '&'
133: %left EQUAL NOTEQUAL
134: %left '<' '>' LEQ GEQ
135: %left LSH RSH
136: %left '+' '-'
137: %left '*' '/' '%'
138: %left '@'
139: %right UNARY INCREMENT DECREMENT
140: %right ARROW '.' '['
141: %left COLONCOLON
142:
143: %%
144:
145: start : exp1
146: ;
147:
148: /* Expressions, including the comma operator. */
149: exp1 : exp
150: | exp1 ',' exp
151: { write_exp_elt (BINOP_COMMA); }
152: ;
153:
154: /* Expressions, not including the comma operator. */
155: exp : '*' exp %prec UNARY
156: { write_exp_elt (UNOP_IND); }
157:
158: exp : '&' exp %prec UNARY
159: { write_exp_elt (UNOP_ADDR); }
160:
161: exp : '-' exp %prec UNARY
162: { write_exp_elt (UNOP_NEG); }
163: ;
164:
165: exp : '!' exp %prec UNARY
166: { write_exp_elt (UNOP_ZEROP); }
167: ;
168:
169: exp : '~' exp %prec UNARY
170: { write_exp_elt (UNOP_LOGNOT); }
171: ;
172:
173: exp : INCREMENT exp %prec UNARY
174: { write_exp_elt (UNOP_PREINCREMENT); }
175: ;
176:
177: exp : DECREMENT exp %prec UNARY
178: { write_exp_elt (UNOP_PREDECREMENT); }
179: ;
180:
181: exp : exp INCREMENT %prec UNARY
182: { write_exp_elt (UNOP_POSTINCREMENT); }
183: ;
184:
185: exp : exp DECREMENT %prec UNARY
186: { write_exp_elt (UNOP_POSTDECREMENT); }
187: ;
188:
189: exp : SIZEOF exp %prec UNARY
190: { write_exp_elt (UNOP_SIZEOF); }
191: ;
192:
193: exp : exp ARROW name
194: { write_exp_elt (STRUCTOP_PTR);
195: write_exp_string ($3);
196: write_exp_elt (STRUCTOP_PTR); }
197: ;
198:
199: exp : exp '.' name
200: { write_exp_elt (STRUCTOP_STRUCT);
201: write_exp_string ($3);
202: write_exp_elt (STRUCTOP_STRUCT); }
203: ;
204:
205: exp : exp '[' exp1 ']'
206: { write_exp_elt (BINOP_SUBSCRIPT); }
207: ;
208:
209: exp : exp '('
210: /* This is to save the value of arglist_len
211: being accumulated by an outer function call. */
212: { start_arglist (); }
213: arglist ')'
214: { write_exp_elt (OP_FUNCALL);
215: write_exp_elt (end_arglist ());
216: write_exp_elt (OP_FUNCALL); }
217: ;
218:
219: arglist :
220: ;
221:
222: arglist : exp
223: { arglist_len = 1; }
224: ;
225:
226: arglist : arglist ',' exp %prec ABOVE_COMMA
227: { arglist_len++; }
228: ;
229:
230: exp : '{' type '}' exp %prec UNARY
231: { write_exp_elt (UNOP_MEMVAL);
232: write_exp_elt ($2);
233: write_exp_elt (UNOP_MEMVAL); }
234: ;
235:
236: exp : '(' type ')' exp %prec UNARY
237: { write_exp_elt (UNOP_CAST);
238: write_exp_elt ($2);
239: write_exp_elt (UNOP_CAST); }
240: ;
241:
242: exp : '(' exp1 ')'
243: { }
244: ;
245:
246: /* Binary operators in order of decreasing precedence. */
247:
248: exp : exp '@' exp
249: { write_exp_elt (BINOP_REPEAT); }
250: ;
251:
252: exp : exp '*' exp
253: { write_exp_elt (BINOP_MUL); }
254: ;
255:
256: exp : exp '/' exp
257: { write_exp_elt (BINOP_DIV); }
258: ;
259:
260: exp : exp '%' exp
261: { write_exp_elt (BINOP_REM); }
262: ;
263:
264: exp : exp '+' exp
265: { write_exp_elt (BINOP_ADD); }
266: ;
267:
268: exp : exp '-' exp
269: { write_exp_elt (BINOP_SUB); }
270: ;
271:
272: exp : exp LSH exp
273: { write_exp_elt (BINOP_LSH); }
274: ;
275:
276: exp : exp RSH exp
277: { write_exp_elt (BINOP_RSH); }
278: ;
279:
280: exp : exp EQUAL exp
281: { write_exp_elt (BINOP_EQUAL); }
282: ;
283:
284: exp : exp NOTEQUAL exp
285: { write_exp_elt (BINOP_NOTEQUAL); }
286: ;
287:
288: exp : exp LEQ exp
289: { write_exp_elt (BINOP_LEQ); }
290: ;
291:
292: exp : exp GEQ exp
293: { write_exp_elt (BINOP_GEQ); }
294: ;
295:
296: exp : exp '<' exp
297: { write_exp_elt (BINOP_LESS); }
298: ;
299:
300: exp : exp '>' exp
301: { write_exp_elt (BINOP_GTR); }
302: ;
303:
304: exp : exp '&' exp
305: { write_exp_elt (BINOP_LOGAND); }
306: ;
307:
308: exp : exp '^' exp
309: { write_exp_elt (BINOP_LOGXOR); }
310: ;
311:
312: exp : exp '|' exp
313: { write_exp_elt (BINOP_LOGIOR); }
314: ;
315:
316: exp : exp AND exp
317: { write_exp_elt (BINOP_AND); }
318: ;
319:
320: exp : exp OR exp
321: { write_exp_elt (BINOP_OR); }
322: ;
323:
324: exp : exp '?' exp ':' exp
325: { write_exp_elt (TERNOP_COND); }
326: ;
327:
328: exp : exp '=' exp
329: { write_exp_elt (BINOP_ASSIGN); }
330: ;
331:
332: exp : exp ASSIGN_MODIFY exp
333: { write_exp_elt (BINOP_ASSIGN_MODIFY);
334: write_exp_elt ($2);
335: write_exp_elt (BINOP_ASSIGN_MODIFY); }
336: ;
337:
338: exp : INT
339: { write_exp_elt (OP_LONG);
340: write_exp_elt (builtin_type_long);
341: write_exp_elt ($1);
342: write_exp_elt (OP_LONG); }
343: ;
344:
345: exp : CHAR
346: { write_exp_elt (OP_LONG);
347: write_exp_elt (builtin_type_char);
348: write_exp_elt ($1);
349: write_exp_elt (OP_LONG); }
350: ;
351:
352: exp : FLOAT
353: { write_exp_elt (OP_DOUBLE);
354: write_exp_elt (builtin_type_double);
355: write_exp_elt ($1);
356: write_exp_elt (OP_DOUBLE); }
357: ;
358:
359: exp : variable
360: ;
361:
362: exp : LAST
363: { write_exp_elt (OP_LAST);
364: write_exp_elt ($1);
365: write_exp_elt (OP_LAST); }
366: ;
367:
368: exp : REGNAME
369: { write_exp_elt (OP_REGISTER);
370: write_exp_elt ($1);
371: write_exp_elt (OP_REGISTER); }
372: ;
373:
374: exp : VARIABLE
375: { write_exp_elt (OP_INTERNALVAR);
376: write_exp_elt ($1);
377: write_exp_elt (OP_INTERNALVAR); }
378: ;
379:
380: exp : SIZEOF '(' type ')'
381: { write_exp_elt (OP_LONG);
382: write_exp_elt (builtin_type_int);
383: write_exp_elt ((long) TYPE_LENGTH ($3));
384: write_exp_elt (OP_LONG); }
385: ;
386:
387: exp : STRING
388: { write_exp_elt (OP_STRING);
389: write_exp_string ($1);
390: write_exp_elt (OP_STRING); }
391: ;
392:
393: block : name
394: { struct symtab *tem = lookup_symtab (copy_name ($1));
395: struct symbol *sym;
396:
397: if (tem)
398: $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), 1);
399: else
400: {
401: sym = lookup_symbol (copy_name ($1),
402: expression_context_block,
403: VAR_NAMESPACE);
404: if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
405: $$ = SYMBOL_BLOCK_VALUE (sym);
406: else
407: error ("No file or function \"%s\".",
408: copy_name ($1));
409: }}
410: ;
411:
412: block : block COLONCOLON name
413: { struct symbol *tem
414: = lookup_symbol (copy_name ($3), $1, VAR_NAMESPACE);
415: if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
416: error ("No function \"%s\" in specified context.",
417: copy_name ($3));
418: $$ = SYMBOL_BLOCK_VALUE (tem); }
419: ;
420:
421: variable: block COLONCOLON name
422: { struct symbol *sym;
423: sym = lookup_symbol (copy_name ($3), $1, VAR_NAMESPACE);
424: if (sym == 0)
425: error ("No symbol \"%s\" in specified context.",
426: copy_name ($3));
427: write_exp_elt (OP_VAR_VALUE);
428: write_exp_elt (sym);
429: write_exp_elt (OP_VAR_VALUE); }
430: ;
431:
432: variable: NAME
433: { struct symbol *sym;
434: sym = lookup_symbol (copy_name ($1),
435: expression_context_block,
436: VAR_NAMESPACE);
437: if (sym)
438: {
439: write_exp_elt (OP_VAR_VALUE);
440: write_exp_elt (sym);
441: write_exp_elt (OP_VAR_VALUE);
442: }
443: else
444: {
445: register char *arg = copy_name ($1);
446: register int i;
447: for (i = 0; i < misc_function_count; i++)
448: if (!strcmp (misc_function_vector[i].name, arg))
449: break;
450:
451: if (i < misc_function_count)
452: {
453: write_exp_elt (OP_LONG);
454: write_exp_elt (builtin_type_int);
455: write_exp_elt (misc_function_vector[i].address);
456: write_exp_elt (OP_LONG);
457: write_exp_elt (UNOP_MEMVAL);
458: write_exp_elt (builtin_type_char);
459: write_exp_elt (UNOP_MEMVAL);
460: }
461: else
462: if (symtab_list == 0)
463: error ("No symbol table is loaded. Use the \"symbol-file\" command.");
464: else
465: error ("No symbol \"%s\" in current context.",
466: copy_name ($1));
467: }
468: }
469: ;
470:
471: type : typebase
472: | type '*'
473: { $$ = lookup_pointer_type ($1); }
474: ;
475:
476: typebase
477: : TYPENAME
478: { $$ = lookup_typename (copy_name ($1),
479: expression_context_block, 0); }
480: | STRUCT name
481: { $$ = lookup_struct (copy_name ($2),
482: expression_context_block); }
483: | UNION name
484: { $$ = lookup_union (copy_name ($2),
485: expression_context_block); }
486: | ENUM name
487: { $$ = lookup_enum (copy_name ($2),
488: expression_context_block); }
489: | UNSIGNED name
490: { $$ = lookup_unsigned_typename (copy_name ($2)); }
491: ;
492:
493: name : NAME
494: | TYPENAME
495: ;
496: %%
497:
498: /* Begin counting arguments for a function call,
499: saving the data about any containing call. */
500:
501: static void
502: start_arglist ()
503: {
504: register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall));
505:
506: new->next = funcall_chain;
507: new->arglist_len = arglist_len;
508: arglist_len = 0;
509: funcall_chain = new;
510: }
511:
512: /* Return the number of arguments in a function call just terminated,
513: and restore the data for the containing function call. */
514:
515: static int
516: end_arglist ()
517: {
518: register int val = arglist_len;
519: register struct funcall *call = funcall_chain;
520: funcall_chain = call->next;
521: arglist_len = call->arglist_len;
522: free (call);
523: return val;
524: }
525:
526: /* Free everything in the funcall chain.
527: Used when there is an error inside parsing. */
528:
529: static void
530: free_funcalls ()
531: {
532: register struct funcall *call, *next;
533:
534: for (call = funcall_chain; call; call = next)
535: {
536: next = call->next;
537: free (call);
538: }
539: }
540:
541: /* This page contains the functions for adding data to the struct expression
542: being constructed. */
543:
544: /* Add one element to the end of the expression. */
545:
546: static void
547: write_exp_elt (expelt)
548: union exp_element expelt;
549: {
550: if (expout_ptr >= expout_size)
551: {
552: expout_size *= 2;
553: expout = (struct expression *) xrealloc (expout,
554: sizeof (struct expression)
555: + expout_size * sizeof (union exp_element));
556: }
557: expout->elts[expout_ptr++] = expelt;
558: }
559:
560: /* Add a string constant to the end of the expression.
561: Follow it by its length in bytes, as a separate exp_element. */
562:
563: static void
564: write_exp_string (str)
565: struct stoken str;
566: {
567: register int len = str.length;
568: register int lenelt
569: = (len + sizeof (union exp_element)) / sizeof (union exp_element);
570:
571: expout_ptr += lenelt;
572:
573: if (expout_ptr >= expout_size)
574: {
575: expout_size = max (expout_size * 2, expout_ptr + 10);
576: expout = (struct expression *) xrealloc (expout,
577: sizeof (struct expression)
578: + expout_size * sizeof (union exp_element));
579: }
580: bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len);
581: ((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
582: write_exp_elt (len);
583: }
584:
585: /* During parsing of a C expression, the pointer to the next character
586: is in this variable. */
587:
588: static char *lexptr;
589:
590: /* Tokens that refer to names do so with explicit pointer and length,
591: so they can share the storage that lexptr is parsing.
592:
593: When it is necessary to pass a name to a function that expects
594: a null-terminated string, the substring is copied out
595: into a block of storage that namecopy points to.
596:
597: namecopy is allocated once, guaranteed big enough, for each parsing. */
598:
599: static char *namecopy;
600:
601: /* Current depth in parentheses within the expression. */
602:
603: static int paren_depth;
604:
605: /* Nonzero means stop parsing on first comma (if not within parentheses). */
606:
607: static int comma_terminates;
608:
609: /* Take care of parsing a number (anything that starts with a digit).
610: Set yylval and return the token type; update lexptr.
611: LEN is the number of characters in it. */
612:
613: /*** Needs some error checking for the float case ***/
614:
615: static int
616: parse_number (olen)
617: int olen;
618: {
619: register char *p = lexptr;
620: register long n = 0;
621: register int c;
622: register int base = 10;
623: register int len = olen;
624: char *err_copy;
625:
626: extern double atof ();
627:
628: for (c = 0; c < len; c++)
629: if (p[c] == '.')
630: {
631: /* It's a float since it contains a point. */
632: yylval.dval = atof (p);
633: lexptr += len;
634: return FLOAT;
635: }
636:
637: if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2)))
638: {
639: p += 2;
640: base = 16;
641: len -= 2;
642: }
643: else if (*p == '0')
644: base = 8;
645:
646: while (len-- > 0)
647: {
648: c = *p++;
649: n *= base;
650: if (c >= '0' && c <= '9')
651: n += c - '0';
652: else
653: {
654: if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
655: if (base == 16 && c >= 'a' && c <= 'f')
656: n += c - 'a' + 10;
657: else if (len == 0 && c == 'l')
658: ;
659: else
660: {
661: err_copy = (char *) alloca (olen + 1);
662: bcopy (lexptr, err_copy, olen);
663: err_copy[olen] = 0;
664: error ("Invalid number \"%s\".", err_copy);
665: }
666: }
667: }
668:
669: lexptr = p;
670: yylval.lval = n;
671: return INT;
672: }
673:
674: struct token
675: {
676: char *operator;
677: int token;
678: enum exp_opcode opcode;
679: };
680:
681: static struct token tokentab3[] =
682: {
683: {">>=", ASSIGN_MODIFY, BINOP_RSH},
684: {"<<=", ASSIGN_MODIFY, BINOP_LSH}
685: };
686:
687: static struct token tokentab2[] =
688: {
689: {"+=", ASSIGN_MODIFY, BINOP_ADD},
690: {"-=", ASSIGN_MODIFY, BINOP_SUB},
691: {"*=", ASSIGN_MODIFY, BINOP_MUL},
692: {"/=", ASSIGN_MODIFY, BINOP_DIV},
693: {"%=", ASSIGN_MODIFY, BINOP_REM},
694: {"|=", ASSIGN_MODIFY, BINOP_LOGIOR},
695: {"&=", ASSIGN_MODIFY, BINOP_LOGAND},
696: {"^=", ASSIGN_MODIFY, BINOP_LOGXOR},
697: {"++", INCREMENT, BINOP_END},
698: {"--", DECREMENT, BINOP_END},
699: {"->", ARROW, BINOP_END},
700: {"&&", AND, BINOP_END},
701: {"||", OR, BINOP_END},
702: {"::", COLONCOLON, BINOP_END},
703: {"<<", LSH, BINOP_END},
704: {">>", RSH, BINOP_END},
705: {"==", EQUAL, BINOP_END},
706: {"!=", NOTEQUAL, BINOP_END},
707: {"<=", LEQ, BINOP_END},
708: {">=", GEQ, BINOP_END}
709: };
710:
711: /* Read one token, getting characters through lexptr. */
712:
713: static int
714: yylex ()
715: {
716: register int c;
717: register int namelen;
718: register int i;
719: register char *tokstart;
720:
721: retry:
722:
723: tokstart = lexptr;
724: /* See if it is a special token of length 3. */
725: for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
726: if (!strncmp (tokstart, tokentab3[i].operator, 3))
727: {
728: lexptr += 3;
729: yylval.opcode = tokentab3[i].opcode;
730: return tokentab3[i].token;
731: }
732:
733: /* See if it is a special token of length 2. */
734: for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
735: if (!strncmp (tokstart, tokentab2[i].operator, 2))
736: {
737: lexptr += 2;
738: yylval.opcode = tokentab2[i].opcode;
739: return tokentab2[i].token;
740: }
741:
742: switch (c = *tokstart)
743: {
744: case 0:
745: return 0;
746:
747: case ' ':
748: case '\t':
749: case '\n':
750: lexptr++;
751: goto retry;
752:
753: case '\'':
754: lexptr++;
755: c = *lexptr++;
756: if (c == '\\')
757: c = parse_escape (&lexptr);
758: yylval.lval = c;
759: c = *lexptr++;
760: if (c != '\'')
761: error ("Invalid character constant.");
762: return CHAR;
763:
764: case '(':
765: paren_depth++;
766: lexptr++;
767: return c;
768:
769: case ')':
770: if (paren_depth == 0)
771: return 0;
772: paren_depth--;
773: lexptr++;
774: return c;
775:
776: case ',':
777: if (comma_terminates && paren_depth == 0)
778: return 0;
779: lexptr++;
780: return c;
781:
782: case '+':
783: case '-':
784: case '*':
785: case '/':
786: case '%':
787: case '|':
788: case '&':
789: case '^':
790: case '~':
791: case '!':
792: case '@':
793: case '<':
794: case '>':
795: case '[':
796: case ']':
797: case '.':
798: case '?':
799: case ':':
800: case '=':
801: case '{':
802: case '}':
803: lexptr++;
804: return c;
805:
806: case '"':
807: for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++)
808: if (c == '\\')
809: {
810: c = tokstart[++namelen];
811: if (c >= '0' && c <= '9')
812: {
813: c = tokstart[++namelen];
814: if (c >= '0' && c <= '9')
815: c = tokstart[++namelen];
816: }
817: }
818: yylval.sval.ptr = tokstart + 1;
819: yylval.sval.length = namelen - 1;
820: lexptr += namelen + 1;
821: return STRING;
822: }
823: if (c >= '0' && c <= '9')
824: {
825: /* It's a number */
826: for (namelen = 0;
827: c = tokstart[namelen],
828: (c == '_' || c == '$' || c == '.' || (c >= '0' && c <= '9')
829: || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
830: namelen++)
831: ;
832: return parse_number (namelen);
833: }
834:
835: if (!(c == '_' || c == '$'
836: || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
837: error ("Invalid token in expression.");
838:
839: /* It is a name. See how long it is. */
840:
841: for (namelen = 0;
842: c = tokstart[namelen],
843: (c == '_' || c == '$' || (c >= '0' && c <= '9')
844: || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
845: namelen++)
846: ;
847:
848: /* The token "if" terminates the expression and is NOT
849: removed from the input stream. */
850: if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
851: {
852: return 0;
853: }
854:
855: lexptr += namelen;
856:
857: /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
858: and $$digits (equivalent to $<-digits> if you could type that).
859: Make token type LAST, and put the number (the digits) in yylval. */
860:
861: if (*tokstart == '$')
862: {
863: register int negate = 0;
864: c = 1;
865: /* Double dollar means negate the number and add -1 as well.
866: Thus $$ alone means -1. */
867: if (namelen >= 2 && tokstart[1] == '$')
868: {
869: negate = 1;
870: c = 2;
871: }
872: if (c == namelen)
873: {
874: /* Just dollars (one or two) */
875: yylval.lval = - negate;
876: return LAST;
877: }
878: /* Is the rest of the token digits? */
879: for (; c < namelen; c++)
880: if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
881: break;
882: if (c == namelen)
883: {
884: yylval.lval = atoi (tokstart + 1 + negate);
885: if (negate)
886: yylval.lval = - yylval.lval;
887: return LAST;
888: }
889: }
890:
891: /* Handle tokens that refer to machine registers:
892: $ followed by a register name. */
893:
894: if (*tokstart == '$')
895: for (c = 0; c < NUM_REGS; c++)
896: if (namelen - 1 == strlen (reg_names[c])
897: && !strncmp (tokstart + 1, reg_names[c], namelen - 1))
898: {
899: yylval.lval = c;
900: return REGNAME;
901: }
902:
903: if (namelen == 6 && !strncmp (tokstart, "struct", 6))
904: {
905: return STRUCT;
906: }
907: if (namelen == 5 && !strncmp (tokstart, "union", 5))
908: {
909: return UNION;
910: }
911: if (namelen == 4 && !strncmp (tokstart, "enum", 4))
912: {
913: return ENUM;
914: }
915: if (namelen == 6 && !strncmp (tokstart, "sizeof", 6))
916: {
917: return SIZEOF;
918: }
919: if (namelen == 8 && !strncmp (tokstart, "unsigned", 6))
920: {
921: return UNSIGNED;
922: }
923: yylval.sval.ptr = tokstart;
924: yylval.sval.length = namelen;
925:
926: /* Any other names starting in $ are debugger internal variables. */
927:
928: if (*tokstart == '$')
929: {
930: yylval.ivar = (struct internalvar *) lookup_internalvar (copy_name (yylval.sval) + 1);
931: return VARIABLE;
932: }
933:
934: /* Use token-type TYPENAME for symbols that happen to be defined
935: currently as names of types; NAME for other symbols.
936: The caller is not constrained to care about the distinction. */
937: if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
938: return TYPENAME;
939: return NAME;
940: }
941:
942: static
943: yyerror ()
944: {
945: error ("Invalid syntax in expression.");
946: }
947:
948: /* Return a null-terminated temporary copy of the name
949: of a string token. */
950:
951: static char *
952: copy_name (token)
953: struct stoken token;
954: {
955: bcopy (token.ptr, namecopy, token.length);
956: namecopy[token.length] = 0;
957: return namecopy;
958: }
959:
960: /* Reverse an expression from suffix form (in which it is constructed)
961: to prefix form (in which we can conveniently print or execute it). */
962:
963: static void prefixify_subexp ();
964:
965: static void
966: prefixify_expression (expr)
967: register struct expression *expr;
968: {
969: register int len = sizeof (struct expression) +
970: expr->nelts * sizeof (union exp_element);
971: register struct expression *temp;
972: register int inpos = expr->nelts, outpos = 0;
973:
974: temp = (struct expression *) alloca (len);
975:
976: /* Copy the original expression into temp. */
977: bcopy (expr, temp, len);
978:
979: prefixify_subexp (temp, expr, inpos, outpos);
980: }
981:
982: /* Return the number of exp_elements in the subexpression of EXPR
983: whose last exp_element is at index ENDPOS - 1 in EXPR. */
984:
985: static int
986: length_of_subexp (expr, endpos)
987: register struct expression *expr;
988: register int endpos;
989: {
990: register int oplen = 1;
991: register int args = 0;
992: register int i;
993:
994: i = (int) expr->elts[endpos - 1].opcode;
995:
996: switch (i)
997: {
998: case OP_LONG:
999: case OP_DOUBLE:
1000: oplen = 4;
1001: break;
1002:
1003: case OP_VAR_VALUE:
1004: case OP_LAST:
1005: case OP_REGISTER:
1006: case OP_INTERNALVAR:
1007: oplen = 3;
1008: break;
1009:
1010: case OP_FUNCALL:
1011: oplen = 3;
1012: args = 1 + expr->elts[endpos - 2].longconst;
1013: break;
1014:
1015: case UNOP_CAST:
1016: case UNOP_MEMVAL:
1017: oplen = 3;
1018: args = 1;
1019: break;
1020:
1021: case STRUCTOP_STRUCT:
1022: case STRUCTOP_PTR:
1023: args = 1;
1024: case OP_STRING:
1025: oplen = 3 + ((expr->elts[endpos - 2].longconst
1026: + sizeof (union exp_element))
1027: / sizeof (union exp_element));
1028:
1029: break;
1030:
1031: case TERNOP_COND:
1032: args = 3;
1033: break;
1034:
1035: case BINOP_ASSIGN_MODIFY:
1036: oplen = 3;
1037: args = 2;
1038: break;
1039:
1040: default:
1041: args = 1 + (i < (int) BINOP_END);
1042: }
1043:
1044: while (args > 0)
1045: {
1046: oplen += length_of_subexp (expr, endpos - oplen);
1047: args--;
1048: }
1049:
1050: return oplen;
1051: }
1052:
1053: /* Copy the subexpression ending just before index INEND in INEXPR
1054: into OUTEXPR, starting at index OUTBEG.
1055: In the process, convert it from suffix to prefix form. */
1056:
1057: static void
1058: prefixify_subexp (inexpr, outexpr, inend, outbeg)
1059: register struct expression *inexpr;
1060: struct expression *outexpr;
1061: register int inend;
1062: int outbeg;
1063: {
1064: register int oplen = 1;
1065: register int args = 0;
1066: register int i;
1067: int *arglens;
1068: enum exp_opcode opcode;
1069:
1070: /* Compute how long the last operation is (in OPLEN),
1071: and also how many preceding subexpressions serve as
1072: arguments for it (in ARGS). */
1073:
1074: opcode = inexpr->elts[inend - 1].opcode;
1075: switch (opcode)
1076: {
1077: case OP_LONG:
1078: case OP_DOUBLE:
1079: oplen = 4;
1080: break;
1081:
1082: case OP_VAR_VALUE:
1083: case OP_LAST:
1084: case OP_REGISTER:
1085: case OP_INTERNALVAR:
1086: oplen = 3;
1087: break;
1088:
1089: case OP_FUNCALL:
1090: oplen = 3;
1091: args = 1 + inexpr->elts[inend - 2].longconst;
1092: break;
1093:
1094: case UNOP_CAST:
1095: case UNOP_MEMVAL:
1096: oplen = 3;
1097: args = 1;
1098: break;
1099:
1100: case STRUCTOP_STRUCT:
1101: case STRUCTOP_PTR:
1102: args = 1;
1103: case OP_STRING:
1104: oplen = 3 + ((inexpr->elts[inend - 2].longconst
1105: + sizeof (union exp_element))
1106: / sizeof (union exp_element));
1107:
1108: break;
1109:
1110: case TERNOP_COND:
1111: args = 3;
1112: break;
1113:
1114: case BINOP_ASSIGN_MODIFY:
1115: oplen = 3;
1116: args = 2;
1117: break;
1118:
1119: default:
1120: args = 1 + ((int) opcode < (int) BINOP_END);
1121: }
1122:
1123: /* Copy the final operator itself, from the end of the input
1124: to the beginning of the output. */
1125: inend -= oplen;
1126: bcopy (&inexpr->elts[inend], &outexpr->elts[outbeg],
1127: oplen * sizeof (union exp_element));
1128: outbeg += oplen;
1129:
1130: /* Find the lengths of the arg subexpressions. */
1131: arglens = (int *) alloca (args * sizeof (int));
1132: for (i = args - 1; i >= 0; i--)
1133: {
1134: oplen = length_of_subexp (inexpr, inend);
1135: arglens[i] = oplen;
1136: inend -= oplen;
1137: }
1138:
1139: /* Now copy each subexpression, preserving the order of
1140: the subexpressions, but prefixifying each one.
1141: In this loop, inend starts at the beginning of
1142: the expression this level is working on
1143: and marches forward over the arguments.
1144: outbeg does similarly in the output. */
1145: for (i = 0; i < args; i++)
1146: {
1147: oplen = arglens[i];
1148: inend += oplen;
1149: prefixify_subexp (inexpr, outexpr, inend, outbeg);
1150: outbeg += oplen;
1151: }
1152: }
1153:
1154: /* This page contains the two entry points to this file. */
1155:
1156: /* Read a C expression from the string *STRINGPTR points to,
1157: parse it, and return a pointer to a struct expression that we malloc.
1158: Use block BLOCK as the lexical context for variable names;
1159: if BLOCK is zero, use the block of the selected stack frame.
1160: Meanwhile, advance *STRINGPTR to point after the expression,
1161: at the first nonwhite character that is not part of the expression
1162: (possibly a null character).
1163:
1164: If COMMA is nonzero, stop if a comma is reached. */
1165:
1166: struct expression *
1167: parse_c_1 (stringptr, block, comma)
1168: char **stringptr;
1169: struct block *block;
1170: {
1171: struct cleanup *old_chain;
1172:
1173: lexptr = *stringptr;
1174:
1175: comma_terminates = comma;
1176:
1177: if (lexptr == 0 || *lexptr == 0)
1178: error_no_arg ("expression to compute");
1179:
1180: old_chain = make_cleanup (free_funcalls, 0);
1181: funcall_chain = 0;
1182:
1183: expression_context_block = block ? block : get_selected_block ();
1184:
1185: namecopy = (char *) alloca (strlen (lexptr) + 1);
1186: expout_size = 10;
1187: expout_ptr = 0;
1188: expout = (struct expression *) xmalloc (sizeof (struct expression)
1189: + expout_size * sizeof (union exp_element));
1190: make_cleanup (free_current_contents, &expout);
1191: if (yyparse ())
1192: yyerror ();
1193: discard_cleanups (old_chain);
1194: expout->nelts = expout_ptr;
1195: expout = (struct expression *)
1196: xrealloc (expout,
1197: sizeof (struct expression)
1198: + expout_ptr * sizeof (union exp_element));
1199: prefixify_expression (expout);
1200: *stringptr = lexptr;
1201: return expout;
1202: }
1203:
1204: /* Parse STRING as an expression, and complain if this fails
1205: to use up all of the contents of STRING. */
1206:
1207: struct expression *
1208: parse_c_expression (string)
1209: char *string;
1210: {
1211: register struct expression *exp;
1212: exp = parse_c_1 (&string, 0, 0);
1213: if (*string)
1214: error ("Junk after end of expression.");
1215: return exp;
1216: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.