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
866 /* Begin counting arguments for a function call,
867 saving the data about any containing call. */
872 register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall));
874 new->next = funcall_chain;
875 new->arglist_len = arglist_len;
880 /* Return the number of arguments in a function call just terminated,
881 and restore the data for the containing function call. */
886 register int val = arglist_len;
887 register struct funcall *call = funcall_chain;
888 funcall_chain = call->next;
889 arglist_len = call->arglist_len;
894 /* Free everything in the funcall chain.
895 Used when there is an error inside parsing. */
900 register struct funcall *call, *next;
902 for (call = funcall_chain; call; call = next)
909 /* This page contains the functions for adding data to the struct expression
910 being constructed. */
912 /* Add one element to the end of the expression. */
914 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
915 a register through here */
918 write_exp_elt (expelt)
919 union exp_element expelt;
921 if (expout_ptr >= expout_size)
924 expout = (struct expression *) xrealloc (expout,
925 sizeof (struct expression)
926 + expout_size * sizeof (union exp_element));
928 expout->elts[expout_ptr++] = expelt;
932 write_exp_elt_opcode (expelt)
933 enum exp_opcode expelt;
935 union exp_element tmp;
943 write_exp_elt_sym (expelt)
944 struct symbol *expelt;
946 union exp_element tmp;
954 write_exp_elt_longcst (expelt)
957 union exp_element tmp;
959 tmp.longconst = expelt;
965 write_exp_elt_dblcst (expelt)
968 union exp_element tmp;
970 tmp.doubleconst = expelt;
976 write_exp_elt_type (expelt)
979 union exp_element tmp;
987 write_exp_elt_intern (expelt)
988 struct internalvar *expelt;
990 union exp_element tmp;
992 tmp.internalvar = expelt;
997 /* Add a string constant to the end of the expression.
998 Follow it by its length in bytes, as a separate exp_element. */
1001 write_exp_string (str)
1004 register int len = str.length;
1006 = (len + sizeof (union exp_element)) / sizeof (union exp_element);
1008 expout_ptr += lenelt;
1010 if (expout_ptr >= expout_size)
1012 expout_size = max (expout_size * 2, expout_ptr + 10);
1013 expout = (struct expression *)
1014 xrealloc (expout, (sizeof (struct expression)
1015 + (expout_size * sizeof (union exp_element))));
1017 bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len);
1018 ((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
1019 write_exp_elt_longcst ((LONGEST) len);
1022 /* During parsing of a C expression, the pointer to the next character
1023 is in this variable. */
1025 static char *lexptr;
1027 /* Tokens that refer to names do so with explicit pointer and length,
1028 so they can share the storage that lexptr is parsing.
1030 When it is necessary to pass a name to a function that expects
1031 a null-terminated string, the substring is copied out
1032 into a block of storage that namecopy points to.
1034 namecopy is allocated once, guaranteed big enough, for each parsing. */
1036 static char *namecopy;
1038 /* Current depth in parentheses within the expression. */
1040 static int paren_depth;
1042 /* Nonzero means stop parsing on first comma (if not within parentheses). */
1044 static int comma_terminates;
1046 /* Take care of parsing a number (anything that starts with a digit).
1047 Set yylval and return the token type; update lexptr.
1048 LEN is the number of characters in it. */
1050 /*** Needs some error checking for the float case ***/
1053 parse_number (p, len, parsed_float, putithere)
1059 register LONGEST n = 0;
1062 register int base = input_radix;
1065 extern double atof ();
1069 /* It's a float since it contains a point or an exponent. */
1070 putithere->dval = atof (p);
1074 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1108 if (c >= 'A' && c <= 'Z')
1110 if (c != 'l' && c != 'u')
1112 if (c >= '0' && c <= '9')
1116 if (base > 10 && c >= 'a' && c <= 'f')
1117 n += i = c - 'a' + 10;
1118 else if (len == 0 && c == 'l')
1120 else if (len == 0 && c == 'u')
1123 return ERROR; /* Char not a digit */
1126 return ERROR; /* Invalid digit in this base */
1131 putithere->ulval = n;
1136 putithere->lval = n;
1145 enum exp_opcode opcode;
1148 static struct token tokentab3[] =
1150 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1151 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1154 static struct token tokentab2[] =
1156 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1157 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1158 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1159 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1160 {"%=", ASSIGN_MODIFY, BINOP_REM},
1161 {"|=", ASSIGN_MODIFY, BINOP_LOGIOR},
1162 {"&=", ASSIGN_MODIFY, BINOP_LOGAND},
1163 {"^=", ASSIGN_MODIFY, BINOP_LOGXOR},
1164 {"++", INCREMENT, BINOP_END},
1165 {"--", DECREMENT, BINOP_END},
1166 {"->", ARROW, BINOP_END},
1167 {"&&", AND, BINOP_END},
1168 {"||", OR, BINOP_END},
1169 {"::", COLONCOLON, BINOP_END},
1170 {"<<", LSH, BINOP_END},
1171 {">>", RSH, BINOP_END},
1172 {"==", EQUAL, BINOP_END},
1173 {"!=", NOTEQUAL, BINOP_END},
1174 {"<=", LEQ, BINOP_END},
1175 {">=", GEQ, BINOP_END}
1178 /* assign machine-independent names to certain registers
1179 * (unless overridden by the REGISTER_NAMES table)
1186 { "pc", PC_REGNUM },
1189 { "fp", FP_REGNUM },
1192 { "sp", SP_REGNUM },
1195 { "ps", PS_REGNUM },
1199 #define NUM_STD_REGS (sizeof std_regs / sizeof std_regs[0])
1201 /* Read one token, getting characters through lexptr. */
1207 register int namelen;
1208 register unsigned i;
1209 register char *tokstart;
1214 /* See if it is a special token of length 3. */
1215 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1216 if (!strncmp (tokstart, tokentab3[i].operator, 3))
1219 yylval.opcode = tokentab3[i].opcode;
1220 return tokentab3[i].token;
1223 /* See if it is a special token of length 2. */
1224 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1225 if (!strncmp (tokstart, tokentab2[i].operator, 2))
1228 yylval.opcode = tokentab2[i].opcode;
1229 return tokentab2[i].token;
1232 switch (c = *tokstart)
1247 c = parse_escape (&lexptr);
1251 error ("Invalid character constant.");
1260 if (paren_depth == 0)
1267 if (comma_terminates && paren_depth == 0)
1273 /* Might be a floating point number. */
1274 if (lexptr[1] < '0' || lexptr[1] > '9')
1275 goto symbol; /* Nope, must be a symbol. */
1276 /* FALL THRU into number case. */
1289 /* It's a number. */
1290 int got_dot = 0, got_e = 0, toktype;
1291 register char *p = tokstart;
1292 int hex = input_radix > 10;
1294 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1299 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1307 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1308 got_dot = got_e = 1;
1309 else if (!hex && !got_dot && *p == '.')
1311 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1312 && (*p == '-' || *p == '+'))
1313 /* This is the sign of the exponent, not the end of the
1316 /* We will take any letters or digits. parse_number will
1317 complain if past the radix, or if L or U are not final. */
1318 else if ((*p < '0' || *p > '9')
1319 && ((*p < 'a' || *p > 'z')
1320 && (*p < 'A' || *p > 'Z')))
1323 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1324 if (toktype == ERROR)
1326 char *err_copy = (char *) alloca (p - tokstart + 1);
1328 bcopy (tokstart, err_copy, p - tokstart);
1329 err_copy[p - tokstart] = 0;
1330 error ("Invalid number \"%s\".", err_copy);
1361 for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++)
1364 c = tokstart[++namelen];
1365 if (c >= '0' && c <= '9')
1367 c = tokstart[++namelen];
1368 if (c >= '0' && c <= '9')
1369 c = tokstart[++namelen];
1372 yylval.sval.ptr = tokstart + 1;
1373 yylval.sval.length = namelen - 1;
1374 lexptr += namelen + 1;
1378 if (!(c == '_' || c == '$'
1379 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1380 /* We must have come across a bad character (e.g. ';'). */
1381 error ("Invalid character '%c' in expression.", c);
1383 /* It's a name. See how long it is. */
1385 for (c = tokstart[namelen];
1386 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1387 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1388 c = tokstart[++namelen])
1391 /* The token "if" terminates the expression and is NOT
1392 removed from the input stream. */
1393 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1400 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1401 and $$digits (equivalent to $<-digits> if you could type that).
1402 Make token type LAST, and put the number (the digits) in yylval. */
1404 if (*tokstart == '$')
1406 register int negate = 0;
1408 /* Double dollar means negate the number and add -1 as well.
1409 Thus $$ alone means -1. */
1410 if (namelen >= 2 && tokstart[1] == '$')
1417 /* Just dollars (one or two) */
1418 yylval.lval = - negate;
1421 /* Is the rest of the token digits? */
1422 for (; c < namelen; c++)
1423 if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1427 yylval.lval = atoi (tokstart + 1 + negate);
1429 yylval.lval = - yylval.lval;
1434 /* Handle tokens that refer to machine registers:
1435 $ followed by a register name. */
1437 if (*tokstart == '$') {
1438 for (c = 0; c < NUM_REGS; c++)
1439 if (namelen - 1 == strlen (reg_names[c])
1440 && !strncmp (tokstart + 1, reg_names[c], namelen - 1))
1445 for (c = 0; c < NUM_STD_REGS; c++)
1446 if (namelen - 1 == strlen (std_regs[c].name)
1447 && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1))
1449 yylval.lval = std_regs[c].regnum;
1453 /* Catch specific keywords. Should be done with a data structure. */
1457 if (!strncmp (tokstart, "unsigned", 8))
1461 if (!strncmp (tokstart, "struct", 6))
1463 if (!strncmp (tokstart, "signed", 6))
1465 if (!strncmp (tokstart, "sizeof", 6))
1469 if (!strncmp (tokstart, "union", 5))
1471 if (!strncmp (tokstart, "short", 5))
1475 if (!strncmp (tokstart, "enum", 4))
1477 if (!strncmp (tokstart, "long", 4))
1479 if (!strncmp (tokstart, "this", 4))
1481 static const char this_name[] =
1482 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1484 if (lookup_symbol (this_name, expression_context_block,
1485 VAR_NAMESPACE, 0, NULL))
1490 if (!strncmp (tokstart, "int", 3))
1497 yylval.sval.ptr = tokstart;
1498 yylval.sval.length = namelen;
1500 /* Any other names starting in $ are debugger internal variables. */
1502 if (*tokstart == '$')
1504 yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
1508 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1509 functions or symtabs. If this is not so, then ...
1510 Use token-type TYPENAME for symbols that happen to be defined
1511 currently as names of types; NAME for other symbols.
1512 The caller is not constrained to care about the distinction. */
1514 char *tmp = copy_name (yylval.sval);
1516 int is_a_field_of_this = 0;
1519 sym = lookup_symbol (tmp, expression_context_block,
1520 VAR_NAMESPACE, &is_a_field_of_this, NULL);
1521 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1522 lookup_partial_symtab (tmp))
1524 yylval.ssym.sym = sym;
1525 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1528 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1530 yylval.tsym.type = SYMBOL_TYPE (sym);
1533 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1536 /* Input names that aren't symbols but ARE valid hex numbers,
1537 when the input radix permits them, can be names or numbers
1538 depending on the parse. Note we support radixes > 16 here. */
1540 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1541 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1543 YYSTYPE newlval; /* Its value is ignored. */
1544 hextype = parse_number (tokstart, namelen, 0, &newlval);
1547 yylval.ssym.sym = sym;
1548 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1551 if (hextype == UINT)
1553 yylval.ssym.sym = sym;
1554 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1555 return NAME_OR_UINT;
1559 /* Any other kind of symbol */
1560 yylval.ssym.sym = sym;
1561 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1570 error ("Invalid syntax in expression.");
1573 /* Return a null-terminated temporary copy of the name
1574 of a string token. */
1578 struct stoken token;
1580 bcopy (token.ptr, namecopy, token.length);
1581 namecopy[token.length] = 0;
1585 /* Reverse an expression from suffix form (in which it is constructed)
1586 to prefix form (in which we can conveniently print or execute it). */
1588 static void prefixify_subexp ();
1591 prefixify_expression (expr)
1592 register struct expression *expr;
1594 register int len = sizeof (struct expression) +
1595 expr->nelts * sizeof (union exp_element);
1596 register struct expression *temp;
1597 register int inpos = expr->nelts, outpos = 0;
1599 temp = (struct expression *) alloca (len);
1601 /* Copy the original expression into temp. */
1602 bcopy (expr, temp, len);
1604 prefixify_subexp (temp, expr, inpos, outpos);
1607 /* Return the number of exp_elements in the subexpression of EXPR
1608 whose last exp_element is at index ENDPOS - 1 in EXPR. */
1611 length_of_subexp (expr, endpos)
1612 register struct expression *expr;
1613 register int endpos;
1615 register int oplen = 1;
1616 register int args = 0;
1620 error ("?error in length_of_subexp");
1622 i = (int) expr->elts[endpos - 1].opcode;
1628 oplen = 4 + ((expr->elts[endpos - 2].longconst
1629 + sizeof (union exp_element))
1630 / sizeof (union exp_element));
1641 case OP_INTERNALVAR:
1647 args = 1 + expr->elts[endpos - 2].longconst;
1656 case STRUCTOP_STRUCT:
1660 oplen = 3 + ((expr->elts[endpos - 2].longconst
1661 + sizeof (union exp_element))
1662 / sizeof (union exp_element));
1669 case BINOP_ASSIGN_MODIFY:
1680 args = 1 + (i < (int) BINOP_END);
1685 oplen += length_of_subexp (expr, endpos - oplen);
1692 /* Copy the subexpression ending just before index INEND in INEXPR
1693 into OUTEXPR, starting at index OUTBEG.
1694 In the process, convert it from suffix to prefix form. */
1697 prefixify_subexp (inexpr, outexpr, inend, outbeg)
1698 register struct expression *inexpr;
1699 struct expression *outexpr;
1703 register int oplen = 1;
1704 register int args = 0;
1707 enum exp_opcode opcode;
1709 /* Compute how long the last operation is (in OPLEN),
1710 and also how many preceding subexpressions serve as
1711 arguments for it (in ARGS). */
1713 opcode = inexpr->elts[inend - 1].opcode;
1718 oplen = 4 + ((inexpr->elts[inend - 2].longconst
1719 + sizeof (union exp_element))
1720 / sizeof (union exp_element));
1731 case OP_INTERNALVAR:
1737 args = 1 + inexpr->elts[inend - 2].longconst;
1746 case STRUCTOP_STRUCT:
1750 oplen = 3 + ((inexpr->elts[inend - 2].longconst
1751 + sizeof (union exp_element))
1752 / sizeof (union exp_element));
1760 case BINOP_ASSIGN_MODIFY:
1771 args = 1 + ((int) opcode < (int) BINOP_END);
1774 /* Copy the final operator itself, from the end of the input
1775 to the beginning of the output. */
1777 bcopy (&inexpr->elts[inend], &outexpr->elts[outbeg],
1778 oplen * sizeof (union exp_element));
1781 /* Find the lengths of the arg subexpressions. */
1782 arglens = (int *) alloca (args * sizeof (int));
1783 for (i = args - 1; i >= 0; i--)
1785 oplen = length_of_subexp (inexpr, inend);
1790 /* Now copy each subexpression, preserving the order of
1791 the subexpressions, but prefixifying each one.
1792 In this loop, inend starts at the beginning of
1793 the expression this level is working on
1794 and marches forward over the arguments.
1795 outbeg does similarly in the output. */
1796 for (i = 0; i < args; i++)
1800 prefixify_subexp (inexpr, outexpr, inend, outbeg);
1805 /* This page contains the two entry points to this file. */
1807 /* Read a C expression from the string *STRINGPTR points to,
1808 parse it, and return a pointer to a struct expression that we malloc.
1809 Use block BLOCK as the lexical context for variable names;
1810 if BLOCK is zero, use the block of the selected stack frame.
1811 Meanwhile, advance *STRINGPTR to point after the expression,
1812 at the first nonwhite character that is not part of the expression
1813 (possibly a null character).
1815 If COMMA is nonzero, stop if a comma is reached. */
1818 parse_c_1 (stringptr, block, comma)
1820 struct block *block;
1823 struct cleanup *old_chain;
1825 lexptr = *stringptr;
1828 type_stack_depth = 0;
1830 comma_terminates = comma;
1832 if (lexptr == 0 || *lexptr == 0)
1833 error_no_arg ("expression to compute");
1835 old_chain = make_cleanup (free_funcalls, 0);
1838 expression_context_block = block ? block : get_selected_block ();
1840 namecopy = (char *) alloca (strlen (lexptr) + 1);
1843 expout = (struct expression *)
1844 xmalloc (sizeof (struct expression)
1845 + expout_size * sizeof (union exp_element));
1846 make_cleanup (free_current_contents, &expout);
1849 discard_cleanups (old_chain);
1850 expout->nelts = expout_ptr;
1851 expout = (struct expression *)
1853 sizeof (struct expression)
1854 + expout_ptr * sizeof (union exp_element));
1855 prefixify_expression (expout);
1856 *stringptr = lexptr;
1860 /* Parse STRING as an expression, and complain if this fails
1861 to use up all of the contents of STRING. */
1864 parse_c_expression (string)
1867 register struct expression *exp;
1868 exp = parse_c_1 (&string, 0, 0);
1870 error ("Junk after end of expression.");
1876 enum type_pieces tp;
1878 if (type_stack_depth == type_stack_size)
1880 type_stack_size *= 2;
1881 type_stack = (enum type_pieces *)
1882 xrealloc (type_stack, type_stack_size * sizeof (enum type_pieces));
1884 type_stack[type_stack_depth++] = tp;
1887 static enum type_pieces
1890 if (type_stack_depth)
1891 return type_stack[--type_stack_depth];
1896 _initialize_expread ()
1898 type_stack_size = 80;
1899 type_stack_depth = 0;
1900 type_stack = (enum type_pieces *)
1901 xmalloc (type_stack_size * sizeof (enum type_pieces));