1 /* Parse C expressions for GDB.
2 Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 GDB is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 1, or (at your option)
11 GDB is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GDB; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* Parse a C expression from text in a string,
21 and return the result as a struct expression pointer.
22 That structure contains arithmetic operations in reverse polish,
23 with constants represented by operations that are followed by special data.
24 See expression.h for the details of the format.
25 What is important here is that it can be built up sequentially
26 during the process of parsing; the lower levels of the tree always
27 come first in the result. */
35 #include "expression.h"
39 static struct expression *expout;
40 static int expout_size;
41 static int expout_ptr;
44 static void yyerror ();
45 static void write_exp_elt ();
46 static void write_exp_elt_opcode ();
47 static void write_exp_elt_sym ();
48 static void write_exp_elt_longcst ();
49 static void write_exp_elt_dblcst ();
50 static void write_exp_elt_type ();
51 static void write_exp_elt_intern ();
52 static void write_exp_string ();
53 static void start_arglist ();
54 static int end_arglist ();
55 static void free_funcalls ();
56 static char *copy_name ();
57 static int parse_number ();
59 /* If this is nonzero, this block is used as the lexical context
62 static struct block *expression_context_block;
64 /* The innermost context required by the stack and register variables
65 we've encountered so far. */
66 struct block *innermost_block;
68 /* The block in which the most recently discovered symbol was found. */
69 struct block *block_found;
71 /* Number of arguments seen so far in innermost function call. */
72 static int arglist_len;
74 /* Data structure for saving values of arglist_len
75 for function calls whose arguments contain other function calls. */
83 struct funcall *funcall_chain;
85 /* This kind of datum is used to represent the name
102 struct stoken stoken;
104 int is_a_field_of_this;
107 /* For parsing of complicated types.
108 An array should be preceded in the list by the size of the array. */
110 {tp_end = -1, tp_pointer, tp_reference, tp_array, tp_function};
111 static enum type_pieces *type_stack;
112 static int type_stack_depth, type_stack_size;
114 static void push_type ();
115 static enum type_pieces pop_type ();
117 /* Allow debugging of parsing. */
121 /* Although the yacc "value" of an expression is not used,
122 since the result is stored in the structure being created,
123 other node types do have values. */
128 unsigned LONGEST ulval;
134 struct symtoken ssym;
137 enum exp_opcode opcode;
138 struct internalvar *ivar;
144 %type <voidval> exp exp1 start variable
145 %type <tval> type typebase
146 %type <tvec> nonempty_typelist
149 /* Fancy type parsing. */
150 %type <voidval> func_mod direct_abs_decl abs_decl
152 %type <lval> array_mod
154 %token <lval> INT CHAR
158 /* Both NAME and TYPENAME tokens represent symbols in the input,
159 and both convey their data as strings.
160 But a TYPENAME is a string that happens to be defined as a typedef
161 or builtin type name (such as int or char)
162 and a NAME is any other symbol.
164 Contexts where this distinction is not important can use the
165 nonterminal "name", which matches either NAME or TYPENAME. */
168 %token <ssym> NAME BLOCKNAME
169 %token <tsym> TYPENAME
171 %type <ssym> name_not_typename
172 %type <tsym> typename
174 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
175 but which would parse as a valid number in the current input radix.
176 E.g. "c" when input_radix==16. Depending on the parse, it will be
177 turned into a name or into a number. NAME_OR_UINT ditto. */
179 %token <ssym> NAME_OR_INT NAME_OR_UINT
181 %token STRUCT UNION ENUM SIZEOF UNSIGNED COLONCOLON
184 /* Special type cases, put in to allow the parser to distinguish different
186 %token SIGNED LONG SHORT INT_KEYWORD
188 %token <lval> LAST REGNAME
190 %token <ivar> VARIABLE
192 %token <opcode> ASSIGN_MODIFY
199 %right '=' ASSIGN_MODIFY
207 %left '<' '>' LEQ GEQ
212 %right UNARY INCREMENT DECREMENT
213 %right ARROW '.' '[' '('
221 /* Expressions, including the comma operator. */
224 { write_exp_elt_opcode (BINOP_COMMA); }
227 /* Expressions, not including the comma operator. */
228 exp : '*' exp %prec UNARY
229 { write_exp_elt_opcode (UNOP_IND); }
231 exp : '&' exp %prec UNARY
232 { write_exp_elt_opcode (UNOP_ADDR); }
234 exp : '-' exp %prec UNARY
235 { write_exp_elt_opcode (UNOP_NEG); }
238 exp : '!' exp %prec UNARY
239 { write_exp_elt_opcode (UNOP_ZEROP); }
242 exp : '~' exp %prec UNARY
243 { write_exp_elt_opcode (UNOP_LOGNOT); }
246 exp : INCREMENT exp %prec UNARY
247 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
250 exp : DECREMENT exp %prec UNARY
251 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
254 exp : exp INCREMENT %prec UNARY
255 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
258 exp : exp DECREMENT %prec UNARY
259 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
262 exp : SIZEOF exp %prec UNARY
263 { write_exp_elt_opcode (UNOP_SIZEOF); }
267 { write_exp_elt_opcode (STRUCTOP_PTR);
268 write_exp_string ($3);
269 write_exp_elt_opcode (STRUCTOP_PTR); }
272 exp : exp ARROW '*' exp
273 { write_exp_elt_opcode (STRUCTOP_MPTR); }
277 { write_exp_elt_opcode (STRUCTOP_STRUCT);
278 write_exp_string ($3);
279 write_exp_elt_opcode (STRUCTOP_STRUCT); }
282 exp : exp '.' '*' exp
283 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
286 exp : exp '[' exp1 ']'
287 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
291 /* This is to save the value of arglist_len
292 being accumulated by an outer function call. */
293 { start_arglist (); }
294 arglist ')' %prec ARROW
295 { write_exp_elt_opcode (OP_FUNCALL);
296 write_exp_elt_longcst ((LONGEST) end_arglist ());
297 write_exp_elt_opcode (OP_FUNCALL); }
307 arglist : arglist ',' exp %prec ABOVE_COMMA
311 exp : '{' type '}' exp %prec UNARY
312 { write_exp_elt_opcode (UNOP_MEMVAL);
313 write_exp_elt_type ($2);
314 write_exp_elt_opcode (UNOP_MEMVAL); }
317 exp : '(' type ')' exp %prec UNARY
318 { write_exp_elt_opcode (UNOP_CAST);
319 write_exp_elt_type ($2);
320 write_exp_elt_opcode (UNOP_CAST); }
327 /* Binary operators in order of decreasing precedence. */
330 { write_exp_elt_opcode (BINOP_REPEAT); }
334 { write_exp_elt_opcode (BINOP_MUL); }
338 { write_exp_elt_opcode (BINOP_DIV); }
342 { write_exp_elt_opcode (BINOP_REM); }
346 { write_exp_elt_opcode (BINOP_ADD); }
350 { write_exp_elt_opcode (BINOP_SUB); }
354 { write_exp_elt_opcode (BINOP_LSH); }
358 { write_exp_elt_opcode (BINOP_RSH); }
362 { write_exp_elt_opcode (BINOP_EQUAL); }
365 exp : exp NOTEQUAL exp
366 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
370 { write_exp_elt_opcode (BINOP_LEQ); }
374 { write_exp_elt_opcode (BINOP_GEQ); }
378 { write_exp_elt_opcode (BINOP_LESS); }
382 { write_exp_elt_opcode (BINOP_GTR); }
386 { write_exp_elt_opcode (BINOP_LOGAND); }
390 { write_exp_elt_opcode (BINOP_LOGXOR); }
394 { write_exp_elt_opcode (BINOP_LOGIOR); }
398 { write_exp_elt_opcode (BINOP_AND); }
402 { write_exp_elt_opcode (BINOP_OR); }
405 exp : exp '?' exp ':' exp %prec '?'
406 { write_exp_elt_opcode (TERNOP_COND); }
410 { write_exp_elt_opcode (BINOP_ASSIGN); }
413 exp : exp ASSIGN_MODIFY exp
414 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
415 write_exp_elt_opcode ($2);
416 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
420 { write_exp_elt_opcode (OP_LONG);
421 if ($1 == (int) $1 || $1 == (unsigned int) $1)
422 write_exp_elt_type (builtin_type_int);
424 write_exp_elt_type (BUILTIN_TYPE_LONGEST);
425 write_exp_elt_longcst ((LONGEST) $1);
426 write_exp_elt_opcode (OP_LONG); }
431 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
432 write_exp_elt_opcode (OP_LONG);
433 if (val.lval == (int) val.lval ||
434 val.lval == (unsigned int) val.lval)
435 write_exp_elt_type (builtin_type_int);
437 write_exp_elt_type (BUILTIN_TYPE_LONGEST);
438 write_exp_elt_longcst (val.lval);
439 write_exp_elt_opcode (OP_LONG); }
444 write_exp_elt_opcode (OP_LONG);
445 if ($1 == (unsigned int) $1)
446 write_exp_elt_type (builtin_type_unsigned_int);
448 write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
449 write_exp_elt_longcst ((LONGEST) $1);
450 write_exp_elt_opcode (OP_LONG);
456 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
457 write_exp_elt_opcode (OP_LONG);
458 if (val.ulval == (unsigned int) val.ulval)
459 write_exp_elt_type (builtin_type_unsigned_int);
461 write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
462 write_exp_elt_longcst ((LONGEST)val.ulval);
463 write_exp_elt_opcode (OP_LONG);
468 { write_exp_elt_opcode (OP_LONG);
469 write_exp_elt_type (builtin_type_char);
470 write_exp_elt_longcst ((LONGEST) $1);
471 write_exp_elt_opcode (OP_LONG); }
475 { write_exp_elt_opcode (OP_DOUBLE);
476 write_exp_elt_type (builtin_type_double);
477 write_exp_elt_dblcst ($1);
478 write_exp_elt_opcode (OP_DOUBLE); }
485 { write_exp_elt_opcode (OP_LAST);
486 write_exp_elt_longcst ((LONGEST) $1);
487 write_exp_elt_opcode (OP_LAST); }
491 { write_exp_elt_opcode (OP_REGISTER);
492 write_exp_elt_longcst ((LONGEST) $1);
493 write_exp_elt_opcode (OP_REGISTER); }
497 { write_exp_elt_opcode (OP_INTERNALVAR);
498 write_exp_elt_intern ($1);
499 write_exp_elt_opcode (OP_INTERNALVAR); }
502 exp : SIZEOF '(' type ')' %prec UNARY
503 { write_exp_elt_opcode (OP_LONG);
504 write_exp_elt_type (builtin_type_int);
505 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
506 write_exp_elt_opcode (OP_LONG); }
510 { write_exp_elt_opcode (OP_STRING);
511 write_exp_string ($1);
512 write_exp_elt_opcode (OP_STRING); }
517 { write_exp_elt_opcode (OP_THIS);
518 write_exp_elt_opcode (OP_THIS); }
526 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
530 lookup_symtab (copy_name ($1.stoken));
532 $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), 1);
534 error ("No file or function \"%s\".",
535 copy_name ($1.stoken));
540 block : block COLONCOLON name
542 = lookup_symbol (copy_name ($3), $1,
543 VAR_NAMESPACE, 0, NULL);
544 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
545 error ("No function \"%s\" in specified context.",
547 $$ = SYMBOL_BLOCK_VALUE (tem); }
550 variable: block COLONCOLON name
551 { struct symbol *sym;
552 sym = lookup_symbol (copy_name ($3), $1,
553 VAR_NAMESPACE, 0, NULL);
555 error ("No symbol \"%s\" in specified context.",
557 write_exp_elt_opcode (OP_VAR_VALUE);
558 write_exp_elt_sym (sym);
559 write_exp_elt_opcode (OP_VAR_VALUE); }
562 variable: typebase COLONCOLON name
564 struct type *type = $1;
565 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
566 && TYPE_CODE (type) != TYPE_CODE_UNION)
567 error ("`%s' is not defined as an aggregate type.",
570 write_exp_elt_opcode (OP_SCOPE);
571 write_exp_elt_type (type);
572 write_exp_string ($3);
573 write_exp_elt_opcode (OP_SCOPE);
577 char *name = copy_name ($2);
582 lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
585 write_exp_elt_opcode (OP_VAR_VALUE);
586 write_exp_elt_sym (sym);
587 write_exp_elt_opcode (OP_VAR_VALUE);
590 for (i = 0; i < misc_function_count; i++)
591 if (!strcmp (misc_function_vector[i].name, name))
594 if (i < misc_function_count)
596 enum misc_function_type mft =
597 misc_function_vector[i].type;
599 write_exp_elt_opcode (OP_LONG);
600 write_exp_elt_type (builtin_type_int);
601 write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
602 write_exp_elt_opcode (OP_LONG);
603 write_exp_elt_opcode (UNOP_MEMVAL);
604 if (mft == mf_data || mft == mf_bss)
605 write_exp_elt_type (builtin_type_int);
606 else if (mft == mf_text)
607 write_exp_elt_type (lookup_function_type (builtin_type_int));
609 write_exp_elt_type (builtin_type_char);
610 write_exp_elt_opcode (UNOP_MEMVAL);
614 && partial_symtab_list == 0)
615 error ("No symbol table is loaded. Use the \"file\" command.");
617 error ("No symbol \"%s\" in current context.", name);
621 variable: name_not_typename
622 { struct symbol *sym = $1.sym;
632 if (innermost_block == 0 ||
633 contained_in (block_found,
635 innermost_block = block_found;
637 write_exp_elt_opcode (OP_VAR_VALUE);
638 write_exp_elt_sym (sym);
639 write_exp_elt_opcode (OP_VAR_VALUE);
641 else if ($1.is_a_field_of_this)
643 /* C++: it hangs off of `this'. Must
644 not inadvertently convert from a method call
646 if (innermost_block == 0 ||
647 contained_in (block_found, innermost_block))
648 innermost_block = block_found;
649 write_exp_elt_opcode (OP_THIS);
650 write_exp_elt_opcode (OP_THIS);
651 write_exp_elt_opcode (STRUCTOP_PTR);
652 write_exp_string ($1.stoken);
653 write_exp_elt_opcode (STRUCTOP_PTR);
658 register char *arg = copy_name ($1.stoken);
660 /* FIXME, this search is linear! At least
661 optimize the strcmp with a 1-char cmp... */
662 for (i = 0; i < misc_function_count; i++)
663 if (!strcmp (misc_function_vector[i].name, arg))
666 if (i < misc_function_count)
668 enum misc_function_type mft =
669 misc_function_vector[i].type;
671 write_exp_elt_opcode (OP_LONG);
672 write_exp_elt_type (builtin_type_int);
673 write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
674 write_exp_elt_opcode (OP_LONG);
675 write_exp_elt_opcode (UNOP_MEMVAL);
676 if (mft == mf_data || mft == mf_bss)
677 write_exp_elt_type (builtin_type_int);
678 else if (mft == mf_text)
679 write_exp_elt_type (lookup_function_type (builtin_type_int));
681 write_exp_elt_type (builtin_type_char);
682 write_exp_elt_opcode (UNOP_MEMVAL);
684 else if (symtab_list == 0
685 && partial_symtab_list == 0)
686 error ("No symbol table is loaded. Use the \"file\" command.");
688 error ("No symbol \"%s\" in current context.",
689 copy_name ($1.stoken));
698 /* This is where the interesting stuff happens. */
701 struct type *follow_type = $1;
710 follow_type = lookup_pointer_type (follow_type);
713 follow_type = lookup_reference_type (follow_type);
716 array_size = (int) pop_type ();
717 if (array_size != -1)
718 follow_type = create_array_type (follow_type,
721 follow_type = lookup_pointer_type (follow_type);
724 follow_type = lookup_function_type (follow_type);
732 { push_type (tp_pointer); $$ = 0; }
734 { push_type (tp_pointer); $$ = $2; }
738 direct_abs_decl: '(' abs_decl ')'
740 | direct_abs_decl array_mod
742 push_type ((enum type_pieces) $2);
743 push_type (tp_array);
747 push_type ((enum type_pieces) $1);
748 push_type (tp_array);
751 | direct_abs_decl func_mod
752 { push_type (tp_function); }
754 { push_type (tp_function); }
768 | typebase COLONCOLON '*'
769 { $$ = lookup_member_type (builtin_type_int, $1); }
770 | type '(' typebase COLONCOLON '*' ')'
771 { $$ = lookup_member_type ($1, $3); }
772 | type '(' typebase COLONCOLON '*' ')' '(' ')'
773 { $$ = lookup_member_type
774 (lookup_function_type ($1), $3); }
775 | type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
776 { $$ = lookup_member_type
777 (lookup_function_type ($1), $3);
785 { $$ = builtin_type_int; }
787 { $$ = builtin_type_long; }
789 { $$ = builtin_type_short; }
791 { $$ = builtin_type_long; }
792 | UNSIGNED LONG INT_KEYWORD
793 { $$ = builtin_type_unsigned_long; }
795 { $$ = builtin_type_short; }
796 | UNSIGNED SHORT INT_KEYWORD
797 { $$ = builtin_type_unsigned_short; }
799 { $$ = lookup_struct (copy_name ($2),
800 expression_context_block); }
802 { $$ = lookup_union (copy_name ($2),
803 expression_context_block); }
805 { $$ = lookup_enum (copy_name ($2),
806 expression_context_block); }
808 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
810 { $$ = builtin_type_unsigned_int; }
814 { $$ = builtin_type_int; }
820 $$.stoken.ptr = "int";
821 $$.stoken.length = 3;
822 $$.type = builtin_type_int;
826 $$.stoken.ptr = "long";
827 $$.stoken.length = 4;
828 $$.type = builtin_type_long;
832 $$.stoken.ptr = "short";
833 $$.stoken.length = 5;
834 $$.type = builtin_type_short;
840 { $$ = (struct type **)xmalloc (sizeof (struct type *) * 2);
841 $$[0] = (struct type *)0;
844 | nonempty_typelist ',' type
845 { int len = sizeof (struct type *) * ++($<ivec>1[0]);
846 $$ = (struct type **)xrealloc ($1, len);
847 $$[$<ivec>$[0]] = $3;
851 name : NAME { $$ = $1.stoken; }
852 | BLOCKNAME { $$ = $1.stoken; }
853 | TYPENAME { $$ = $1.stoken; }
854 | NAME_OR_INT { $$ = $1.stoken; }
855 | NAME_OR_UINT { $$ = $1.stoken; }
858 name_not_typename : NAME
860 /* These would be useful if name_not_typename was useful, but it is just
861 a fake for "variable", so these cause reduce/reduce conflicts because
862 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
863 =exp) or just an exp. If name_not_typename was ever used in an lvalue
864 context where only a name could occur, this might be useful.
872 /* Begin counting arguments for a function call,
873 saving the data about any containing call. */
878 register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall));
880 new->next = funcall_chain;
881 new->arglist_len = arglist_len;
886 /* Return the number of arguments in a function call just terminated,
887 and restore the data for the containing function call. */
892 register int val = arglist_len;
893 register struct funcall *call = funcall_chain;
894 funcall_chain = call->next;
895 arglist_len = call->arglist_len;
900 /* Free everything in the funcall chain.
901 Used when there is an error inside parsing. */
906 register struct funcall *call, *next;
908 for (call = funcall_chain; call; call = next)
915 /* This page contains the functions for adding data to the struct expression
916 being constructed. */
918 /* Add one element to the end of the expression. */
920 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
921 a register through here */
924 write_exp_elt (expelt)
925 union exp_element expelt;
927 if (expout_ptr >= expout_size)
930 expout = (struct expression *) xrealloc (expout,
931 sizeof (struct expression)
932 + expout_size * sizeof (union exp_element));
934 expout->elts[expout_ptr++] = expelt;
938 write_exp_elt_opcode (expelt)
939 enum exp_opcode expelt;
941 union exp_element tmp;
949 write_exp_elt_sym (expelt)
950 struct symbol *expelt;
952 union exp_element tmp;
960 write_exp_elt_longcst (expelt)
963 union exp_element tmp;
965 tmp.longconst = expelt;
971 write_exp_elt_dblcst (expelt)
974 union exp_element tmp;
976 tmp.doubleconst = expelt;
982 write_exp_elt_type (expelt)
985 union exp_element tmp;
993 write_exp_elt_intern (expelt)
994 struct internalvar *expelt;
996 union exp_element tmp;
998 tmp.internalvar = expelt;
1000 write_exp_elt (tmp);
1003 /* Add a string constant to the end of the expression.
1004 Follow it by its length in bytes, as a separate exp_element. */
1007 write_exp_string (str)
1010 register int len = str.length;
1012 = (len + sizeof (union exp_element)) / sizeof (union exp_element);
1014 expout_ptr += lenelt;
1016 if (expout_ptr >= expout_size)
1018 expout_size = max (expout_size * 2, expout_ptr + 10);
1019 expout = (struct expression *)
1020 xrealloc (expout, (sizeof (struct expression)
1021 + (expout_size * sizeof (union exp_element))));
1023 bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len);
1024 ((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
1025 write_exp_elt_longcst ((LONGEST) len);
1028 /* During parsing of a C expression, the pointer to the next character
1029 is in this variable. */
1031 static char *lexptr;
1033 /* Tokens that refer to names do so with explicit pointer and length,
1034 so they can share the storage that lexptr is parsing.
1036 When it is necessary to pass a name to a function that expects
1037 a null-terminated string, the substring is copied out
1038 into a block of storage that namecopy points to.
1040 namecopy is allocated once, guaranteed big enough, for each parsing. */
1042 static char *namecopy;
1044 /* Current depth in parentheses within the expression. */
1046 static int paren_depth;
1048 /* Nonzero means stop parsing on first comma (if not within parentheses). */
1050 static int comma_terminates;
1052 /* Take care of parsing a number (anything that starts with a digit).
1053 Set yylval and return the token type; update lexptr.
1054 LEN is the number of characters in it. */
1056 /*** Needs some error checking for the float case ***/
1059 parse_number (p, len, parsed_float, putithere)
1065 register LONGEST n = 0;
1068 register int base = input_radix;
1071 extern double atof ();
1075 /* It's a float since it contains a point or an exponent. */
1076 putithere->dval = atof (p);
1080 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1114 if (c >= 'A' && c <= 'Z')
1116 if (c != 'l' && c != 'u')
1118 if (c >= '0' && c <= '9')
1122 if (base > 10 && c >= 'a' && c <= 'f')
1123 n += i = c - 'a' + 10;
1124 else if (len == 0 && c == 'l')
1126 else if (len == 0 && c == 'u')
1129 return ERROR; /* Char not a digit */
1132 return ERROR; /* Invalid digit in this base */
1137 putithere->ulval = n;
1142 putithere->lval = n;
1151 enum exp_opcode opcode;
1154 static struct token tokentab3[] =
1156 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1157 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1160 static struct token tokentab2[] =
1162 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1163 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1164 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1165 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1166 {"%=", ASSIGN_MODIFY, BINOP_REM},
1167 {"|=", ASSIGN_MODIFY, BINOP_LOGIOR},
1168 {"&=", ASSIGN_MODIFY, BINOP_LOGAND},
1169 {"^=", ASSIGN_MODIFY, BINOP_LOGXOR},
1170 {"++", INCREMENT, BINOP_END},
1171 {"--", DECREMENT, BINOP_END},
1172 {"->", ARROW, BINOP_END},
1173 {"&&", AND, BINOP_END},
1174 {"||", OR, BINOP_END},
1175 {"::", COLONCOLON, BINOP_END},
1176 {"<<", LSH, BINOP_END},
1177 {">>", RSH, BINOP_END},
1178 {"==", EQUAL, BINOP_END},
1179 {"!=", NOTEQUAL, BINOP_END},
1180 {"<=", LEQ, BINOP_END},
1181 {">=", GEQ, BINOP_END}
1184 /* assign machine-independent names to certain registers
1185 * (unless overridden by the REGISTER_NAMES table)
1192 { "pc", PC_REGNUM },
1195 { "fp", FP_REGNUM },
1198 { "sp", SP_REGNUM },
1201 { "ps", PS_REGNUM },
1205 #define NUM_STD_REGS (sizeof std_regs / sizeof std_regs[0])
1207 /* Read one token, getting characters through lexptr. */
1213 register int namelen;
1214 register unsigned i;
1215 register char *tokstart;
1220 /* See if it is a special token of length 3. */
1221 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1222 if (!strncmp (tokstart, tokentab3[i].operator, 3))
1225 yylval.opcode = tokentab3[i].opcode;
1226 return tokentab3[i].token;
1229 /* See if it is a special token of length 2. */
1230 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1231 if (!strncmp (tokstart, tokentab2[i].operator, 2))
1234 yylval.opcode = tokentab2[i].opcode;
1235 return tokentab2[i].token;
1238 switch (c = *tokstart)
1253 c = parse_escape (&lexptr);
1257 error ("Invalid character constant.");
1266 if (paren_depth == 0)
1273 if (comma_terminates && paren_depth == 0)
1279 /* Might be a floating point number. */
1280 if (lexptr[1] < '0' || lexptr[1] > '9')
1281 goto symbol; /* Nope, must be a symbol. */
1282 /* FALL THRU into number case. */
1295 /* It's a number. */
1296 int got_dot = 0, got_e = 0, toktype;
1297 register char *p = tokstart;
1298 int hex = input_radix > 10;
1300 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1305 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1313 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1314 got_dot = got_e = 1;
1315 else if (!hex && !got_dot && *p == '.')
1317 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1318 && (*p == '-' || *p == '+'))
1319 /* This is the sign of the exponent, not the end of the
1322 /* We will take any letters or digits. parse_number will
1323 complain if past the radix, or if L or U are not final. */
1324 else if ((*p < '0' || *p > '9')
1325 && ((*p < 'a' || *p > 'z')
1326 && (*p < 'A' || *p > 'Z')))
1329 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1330 if (toktype == ERROR)
1332 char *err_copy = (char *) alloca (p - tokstart + 1);
1334 bcopy (tokstart, err_copy, p - tokstart);
1335 err_copy[p - tokstart] = 0;
1336 error ("Invalid number \"%s\".", err_copy);
1367 for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++)
1370 c = tokstart[++namelen];
1371 if (c >= '0' && c <= '9')
1373 c = tokstart[++namelen];
1374 if (c >= '0' && c <= '9')
1375 c = tokstart[++namelen];
1378 yylval.sval.ptr = tokstart + 1;
1379 yylval.sval.length = namelen - 1;
1380 lexptr += namelen + 1;
1384 if (!(c == '_' || c == '$'
1385 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1386 /* We must have come across a bad character (e.g. ';'). */
1387 error ("Invalid character '%c' in expression.", c);
1389 /* It's a name. See how long it is. */
1391 for (c = tokstart[namelen];
1392 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1393 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1394 c = tokstart[++namelen])
1397 /* The token "if" terminates the expression and is NOT
1398 removed from the input stream. */
1399 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1406 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1407 and $$digits (equivalent to $<-digits> if you could type that).
1408 Make token type LAST, and put the number (the digits) in yylval. */
1410 if (*tokstart == '$')
1412 register int negate = 0;
1414 /* Double dollar means negate the number and add -1 as well.
1415 Thus $$ alone means -1. */
1416 if (namelen >= 2 && tokstart[1] == '$')
1423 /* Just dollars (one or two) */
1424 yylval.lval = - negate;
1427 /* Is the rest of the token digits? */
1428 for (; c < namelen; c++)
1429 if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1433 yylval.lval = atoi (tokstart + 1 + negate);
1435 yylval.lval = - yylval.lval;
1440 /* Handle tokens that refer to machine registers:
1441 $ followed by a register name. */
1443 if (*tokstart == '$') {
1444 for (c = 0; c < NUM_REGS; c++)
1445 if (namelen - 1 == strlen (reg_names[c])
1446 && !strncmp (tokstart + 1, reg_names[c], namelen - 1))
1451 for (c = 0; c < NUM_STD_REGS; c++)
1452 if (namelen - 1 == strlen (std_regs[c].name)
1453 && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1))
1455 yylval.lval = std_regs[c].regnum;
1459 /* Catch specific keywords. Should be done with a data structure. */
1463 if (!strncmp (tokstart, "unsigned", 8))
1467 if (!strncmp (tokstart, "struct", 6))
1469 if (!strncmp (tokstart, "signed", 6))
1471 if (!strncmp (tokstart, "sizeof", 6))
1475 if (!strncmp (tokstart, "union", 5))
1477 if (!strncmp (tokstart, "short", 5))
1481 if (!strncmp (tokstart, "enum", 4))
1483 if (!strncmp (tokstart, "long", 4))
1485 if (!strncmp (tokstart, "this", 4))
1487 static const char this_name[] =
1488 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1490 if (lookup_symbol (this_name, expression_context_block,
1491 VAR_NAMESPACE, 0, NULL))
1496 if (!strncmp (tokstart, "int", 3))
1503 yylval.sval.ptr = tokstart;
1504 yylval.sval.length = namelen;
1506 /* Any other names starting in $ are debugger internal variables. */
1508 if (*tokstart == '$')
1510 yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
1514 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1515 functions or symtabs. If this is not so, then ...
1516 Use token-type TYPENAME for symbols that happen to be defined
1517 currently as names of types; NAME for other symbols.
1518 The caller is not constrained to care about the distinction. */
1520 char *tmp = copy_name (yylval.sval);
1522 int is_a_field_of_this = 0;
1525 sym = lookup_symbol (tmp, expression_context_block,
1526 VAR_NAMESPACE, &is_a_field_of_this, NULL);
1527 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1528 lookup_partial_symtab (tmp))
1530 yylval.ssym.sym = sym;
1531 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1534 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1536 yylval.tsym.type = SYMBOL_TYPE (sym);
1539 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1542 /* Input names that aren't symbols but ARE valid hex numbers,
1543 when the input radix permits them, can be names or numbers
1544 depending on the parse. Note we support radixes > 16 here. */
1546 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1547 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1549 YYSTYPE newlval; /* Its value is ignored. */
1550 hextype = parse_number (tokstart, namelen, 0, &newlval);
1553 yylval.ssym.sym = sym;
1554 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1557 if (hextype == UINT)
1559 yylval.ssym.sym = sym;
1560 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1561 return NAME_OR_UINT;
1565 /* Any other kind of symbol */
1566 yylval.ssym.sym = sym;
1567 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1576 error ("Invalid syntax in expression.");
1579 /* Return a null-terminated temporary copy of the name
1580 of a string token. */
1584 struct stoken token;
1586 bcopy (token.ptr, namecopy, token.length);
1587 namecopy[token.length] = 0;
1591 /* Reverse an expression from suffix form (in which it is constructed)
1592 to prefix form (in which we can conveniently print or execute it). */
1594 static void prefixify_subexp ();
1597 prefixify_expression (expr)
1598 register struct expression *expr;
1600 register int len = sizeof (struct expression) +
1601 expr->nelts * sizeof (union exp_element);
1602 register struct expression *temp;
1603 register int inpos = expr->nelts, outpos = 0;
1605 temp = (struct expression *) alloca (len);
1607 /* Copy the original expression into temp. */
1608 bcopy (expr, temp, len);
1610 prefixify_subexp (temp, expr, inpos, outpos);
1613 /* Return the number of exp_elements in the subexpression of EXPR
1614 whose last exp_element is at index ENDPOS - 1 in EXPR. */
1617 length_of_subexp (expr, endpos)
1618 register struct expression *expr;
1619 register int endpos;
1621 register int oplen = 1;
1622 register int args = 0;
1626 error ("?error in length_of_subexp");
1628 i = (int) expr->elts[endpos - 1].opcode;
1634 oplen = 4 + ((expr->elts[endpos - 2].longconst
1635 + sizeof (union exp_element))
1636 / sizeof (union exp_element));
1647 case OP_INTERNALVAR:
1653 args = 1 + expr->elts[endpos - 2].longconst;
1662 case STRUCTOP_STRUCT:
1666 oplen = 3 + ((expr->elts[endpos - 2].longconst
1667 + sizeof (union exp_element))
1668 / sizeof (union exp_element));
1675 case BINOP_ASSIGN_MODIFY:
1686 args = 1 + (i < (int) BINOP_END);
1691 oplen += length_of_subexp (expr, endpos - oplen);
1698 /* Copy the subexpression ending just before index INEND in INEXPR
1699 into OUTEXPR, starting at index OUTBEG.
1700 In the process, convert it from suffix to prefix form. */
1703 prefixify_subexp (inexpr, outexpr, inend, outbeg)
1704 register struct expression *inexpr;
1705 struct expression *outexpr;
1709 register int oplen = 1;
1710 register int args = 0;
1713 enum exp_opcode opcode;
1715 /* Compute how long the last operation is (in OPLEN),
1716 and also how many preceding subexpressions serve as
1717 arguments for it (in ARGS). */
1719 opcode = inexpr->elts[inend - 1].opcode;
1724 oplen = 4 + ((inexpr->elts[inend - 2].longconst
1725 + sizeof (union exp_element))
1726 / sizeof (union exp_element));
1737 case OP_INTERNALVAR:
1743 args = 1 + inexpr->elts[inend - 2].longconst;
1752 case STRUCTOP_STRUCT:
1756 oplen = 3 + ((inexpr->elts[inend - 2].longconst
1757 + sizeof (union exp_element))
1758 / sizeof (union exp_element));
1766 case BINOP_ASSIGN_MODIFY:
1777 args = 1 + ((int) opcode < (int) BINOP_END);
1780 /* Copy the final operator itself, from the end of the input
1781 to the beginning of the output. */
1783 bcopy (&inexpr->elts[inend], &outexpr->elts[outbeg],
1784 oplen * sizeof (union exp_element));
1787 /* Find the lengths of the arg subexpressions. */
1788 arglens = (int *) alloca (args * sizeof (int));
1789 for (i = args - 1; i >= 0; i--)
1791 oplen = length_of_subexp (inexpr, inend);
1796 /* Now copy each subexpression, preserving the order of
1797 the subexpressions, but prefixifying each one.
1798 In this loop, inend starts at the beginning of
1799 the expression this level is working on
1800 and marches forward over the arguments.
1801 outbeg does similarly in the output. */
1802 for (i = 0; i < args; i++)
1806 prefixify_subexp (inexpr, outexpr, inend, outbeg);
1811 /* This page contains the two entry points to this file. */
1813 /* Read a C expression from the string *STRINGPTR points to,
1814 parse it, and return a pointer to a struct expression that we malloc.
1815 Use block BLOCK as the lexical context for variable names;
1816 if BLOCK is zero, use the block of the selected stack frame.
1817 Meanwhile, advance *STRINGPTR to point after the expression,
1818 at the first nonwhite character that is not part of the expression
1819 (possibly a null character).
1821 If COMMA is nonzero, stop if a comma is reached. */
1824 parse_c_1 (stringptr, block, comma)
1826 struct block *block;
1829 struct cleanup *old_chain;
1831 lexptr = *stringptr;
1834 type_stack_depth = 0;
1836 comma_terminates = comma;
1838 if (lexptr == 0 || *lexptr == 0)
1839 error_no_arg ("expression to compute");
1841 old_chain = make_cleanup (free_funcalls, 0);
1844 expression_context_block = block ? block : get_selected_block ();
1846 namecopy = (char *) alloca (strlen (lexptr) + 1);
1849 expout = (struct expression *)
1850 xmalloc (sizeof (struct expression)
1851 + expout_size * sizeof (union exp_element));
1852 make_cleanup (free_current_contents, &expout);
1855 discard_cleanups (old_chain);
1856 expout->nelts = expout_ptr;
1857 expout = (struct expression *)
1859 sizeof (struct expression)
1860 + expout_ptr * sizeof (union exp_element));
1861 prefixify_expression (expout);
1862 *stringptr = lexptr;
1866 /* Parse STRING as an expression, and complain if this fails
1867 to use up all of the contents of STRING. */
1870 parse_c_expression (string)
1873 register struct expression *exp;
1874 exp = parse_c_1 (&string, 0, 0);
1876 error ("Junk after end of expression.");
1882 enum type_pieces tp;
1884 if (type_stack_depth == type_stack_size)
1886 type_stack_size *= 2;
1887 type_stack = (enum type_pieces *)
1888 xrealloc (type_stack, type_stack_size * sizeof (enum type_pieces));
1890 type_stack[type_stack_depth++] = tp;
1893 static enum type_pieces
1896 if (type_stack_depth)
1897 return type_stack[--type_stack_depth];
1902 _initialize_expread ()
1904 type_stack_size = 80;
1905 type_stack_depth = 0;
1906 type_stack = (enum type_pieces *)
1907 xmalloc (type_stack_size * sizeof (enum type_pieces));