1 /* YACC parser for Pascal expressions, for GDB.
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* This file is derived from c-exp.y */
23 /* Parse a Pascal expression from text in a string,
24 and return the result as a struct expression pointer.
25 That structure contains arithmetic operations in reverse polish,
26 with constants represented by operations that are followed by special data.
27 See expression.h for the details of the format.
28 What is important here is that it can be built up sequentially
29 during the process of parsing; the lower levels of the tree always
30 come first in the result.
32 Note that malloc's and realloc's in this file are transformed to
33 xmalloc and xrealloc respectively by the same sed command in the
34 makefile that remaps any other malloc/realloc inserted by the parser
35 generator. Doing this with #defines and trying to control the interaction
36 with include files (<malloc.h> and <stdlib.h> for example) just became
37 too messy, particularly when such includes can be inserted at random
38 times by the parser generator. */
40 /* Known bugs or limitations:
41 - pascal string operations are not supported at all.
42 - there are some problems with boolean types.
43 - Pascal type hexadecimal constants are not supported
44 because they conflict with the internal variables format.
45 Probably also lots of other problems, less well defined PM */
49 #include "gdb_string.h"
51 #include "expression.h"
53 #include "parser-defs.h"
56 #include "bfd.h" /* Required by objfiles.h. */
57 #include "symfile.h" /* Required by objfiles.h. */
58 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
60 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
61 as well as gratuitiously global symbol names, so we can have multiple
62 yacc generated parsers in gdb. Note that these are only the variables
63 produced by yacc. If other parser generators (bison, byacc, etc) produce
64 additional global names that conflict at link time, then those parser
65 generators need to be fixed instead of adding those names to this list. */
67 #define yymaxdepth pascal_maxdepth
68 #define yyparse pascal_parse
69 #define yylex pascal_lex
70 #define yyerror pascal_error
71 #define yylval pascal_lval
72 #define yychar pascal_char
73 #define yydebug pascal_debug
74 #define yypact pascal_pact
75 #define yyr1 pascal_r1
76 #define yyr2 pascal_r2
77 #define yydef pascal_def
78 #define yychk pascal_chk
79 #define yypgo pascal_pgo
80 #define yyact pascal_act
81 #define yyexca pascal_exca
82 #define yyerrflag pascal_errflag
83 #define yynerrs pascal_nerrs
84 #define yyps pascal_ps
85 #define yypv pascal_pv
87 #define yy_yys pascal_yys
88 #define yystate pascal_state
89 #define yytmp pascal_tmp
91 #define yy_yyv pascal_yyv
92 #define yyval pascal_val
93 #define yylloc pascal_lloc
94 #define yyreds pascal_reds /* With YYDEBUG defined */
95 #define yytoks pascal_toks /* With YYDEBUG defined */
96 #define yyname pascal_name /* With YYDEBUG defined */
97 #define yyrule pascal_rule /* With YYDEBUG defined */
98 #define yylhs pascal_yylhs
99 #define yylen pascal_yylen
100 #define yydefred pascal_yydefred
101 #define yydgoto pascal_yydgoto
102 #define yysindex pascal_yysindex
103 #define yyrindex pascal_yyrindex
104 #define yygindex pascal_yygindex
105 #define yytable pascal_yytable
106 #define yycheck pascal_yycheck
109 #define YYDEBUG 1 /* Default to yydebug support */
112 #define YYFPRINTF parser_fprintf
116 static int yylex (void);
121 static char * uptok (char *, int);
124 /* Although the yacc "value" of an expression is not used,
125 since the result is stored in the structure being created,
126 other node types do have values. */
143 struct symtoken ssym;
146 enum exp_opcode opcode;
147 struct internalvar *ivar;
154 /* YYSTYPE gets defined by %union */
156 parse_number (char *, int, int, YYSTYPE *);
158 static struct type *current_type;
160 static void push_current_type ();
161 static void pop_current_type ();
162 static int search_field;
165 %type <voidval> exp exp1 type_exp start normal_start variable qualified_name
166 %type <tval> type typebase
167 /* %type <bval> block */
169 /* Fancy type parsing. */
172 %token <typed_val_int> INT
173 %token <typed_val_float> FLOAT
175 /* Both NAME and TYPENAME tokens represent symbols in the input,
176 and both convey their data as strings.
177 But a TYPENAME is a string that happens to be defined as a typedef
178 or builtin type name (such as int or char)
179 and a NAME is any other symbol.
180 Contexts where this distinction is not important can use the
181 nonterminal "name", which matches either NAME or TYPENAME. */
184 %token <sval> FIELDNAME
185 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
186 %token <tsym> TYPENAME
188 %type <ssym> name_not_typename
190 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
191 but which would parse as a valid number in the current input radix.
192 E.g. "c" when input_radix==16. Depending on the parse, it will be
193 turned into a name or into a number. */
195 %token <ssym> NAME_OR_INT
197 %token STRUCT CLASS SIZEOF COLONCOLON
200 /* Special type cases, put in to allow the parser to distinguish different
203 %token <voidval> VARIABLE
208 %token <lval> TRUE FALSE
218 %left '<' '>' LEQ GEQ
219 %left LSH RSH DIV MOD
223 %right UNARY INCREMENT DECREMENT
224 %right ARROW '.' '[' '('
226 %token <ssym> BLOCKNAME
233 start : { current_type = NULL;
245 { write_exp_elt_opcode(OP_TYPE);
246 write_exp_elt_type($1);
247 write_exp_elt_opcode(OP_TYPE);
248 current_type = $1; } ;
250 /* Expressions, including the comma operator. */
253 { write_exp_elt_opcode (BINOP_COMMA); }
256 /* Expressions, not including the comma operator. */
257 exp : exp '^' %prec UNARY
258 { write_exp_elt_opcode (UNOP_IND);
260 current_type = TYPE_TARGET_TYPE (current_type); }
263 exp : '@' exp %prec UNARY
264 { write_exp_elt_opcode (UNOP_ADDR);
266 current_type = TYPE_POINTER_TYPE (current_type); }
269 exp : '-' exp %prec UNARY
270 { write_exp_elt_opcode (UNOP_NEG); }
273 exp : NOT exp %prec UNARY
274 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
277 exp : INCREMENT '(' exp ')' %prec UNARY
278 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
281 exp : DECREMENT '(' exp ')' %prec UNARY
282 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
285 exp : exp '.' { search_field = 1; }
288 { write_exp_elt_opcode (STRUCTOP_STRUCT);
289 write_exp_string ($4);
290 write_exp_elt_opcode (STRUCTOP_STRUCT);
293 { while (TYPE_CODE (current_type) == TYPE_CODE_PTR)
294 current_type = TYPE_TARGET_TYPE (current_type);
295 current_type = lookup_struct_elt_type (
296 current_type, $4.ptr, false); };
299 /* We need to save the current_type value */
302 arrayfieldindex = is_pascal_string_type (
303 current_type, NULL, NULL,
304 NULL, NULL, &arrayname);
307 struct stoken stringsval;
308 stringsval.ptr = alloca (strlen (arrayname) + 1);
309 stringsval.length = strlen (arrayname);
310 strcpy (stringsval.ptr, arrayname);
311 current_type = TYPE_FIELD_TYPE (current_type,
312 arrayfieldindex - 1);
313 write_exp_elt_opcode (STRUCTOP_STRUCT);
314 write_exp_string (stringsval);
315 write_exp_elt_opcode (STRUCTOP_STRUCT);
317 push_current_type (); }
319 { pop_current_type ();
320 write_exp_elt_opcode (BINOP_SUBSCRIPT);
322 current_type = TYPE_TARGET_TYPE (current_type); }
326 /* This is to save the value of arglist_len
327 being accumulated by an outer function call. */
328 { push_current_type ();
330 arglist ')' %prec ARROW
331 { write_exp_elt_opcode (OP_FUNCALL);
332 write_exp_elt_longcst ((LONGEST) end_arglist ());
333 write_exp_elt_opcode (OP_FUNCALL);
334 pop_current_type (); }
340 | arglist ',' exp %prec ABOVE_COMMA
344 exp : type '(' exp ')' %prec UNARY
345 { write_exp_elt_opcode (UNOP_CAST);
346 write_exp_elt_type ($1);
347 write_exp_elt_opcode (UNOP_CAST);
355 /* Binary operators in order of decreasing precedence. */
358 { write_exp_elt_opcode (BINOP_MUL); }
362 { write_exp_elt_opcode (BINOP_DIV); }
366 { write_exp_elt_opcode (BINOP_INTDIV); }
370 { write_exp_elt_opcode (BINOP_REM); }
374 { write_exp_elt_opcode (BINOP_ADD); }
378 { write_exp_elt_opcode (BINOP_SUB); }
382 { write_exp_elt_opcode (BINOP_LSH); }
386 { write_exp_elt_opcode (BINOP_RSH); }
390 { write_exp_elt_opcode (BINOP_EQUAL); }
393 exp : exp NOTEQUAL exp
394 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
398 { write_exp_elt_opcode (BINOP_LEQ); }
402 { write_exp_elt_opcode (BINOP_GEQ); }
406 { write_exp_elt_opcode (BINOP_LESS); }
410 { write_exp_elt_opcode (BINOP_GTR); }
414 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
418 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
422 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
426 { write_exp_elt_opcode (BINOP_ASSIGN); }
430 { write_exp_elt_opcode (OP_BOOL);
431 write_exp_elt_longcst ((LONGEST) $1);
432 write_exp_elt_opcode (OP_BOOL); }
436 { write_exp_elt_opcode (OP_BOOL);
437 write_exp_elt_longcst ((LONGEST) $1);
438 write_exp_elt_opcode (OP_BOOL); }
442 { write_exp_elt_opcode (OP_LONG);
443 write_exp_elt_type ($1.type);
444 write_exp_elt_longcst ((LONGEST)($1.val));
445 write_exp_elt_opcode (OP_LONG); }
450 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
451 write_exp_elt_opcode (OP_LONG);
452 write_exp_elt_type (val.typed_val_int.type);
453 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
454 write_exp_elt_opcode (OP_LONG);
460 { write_exp_elt_opcode (OP_DOUBLE);
461 write_exp_elt_type ($1.type);
462 write_exp_elt_dblcst ($1.dval);
463 write_exp_elt_opcode (OP_DOUBLE); }
470 /* Already written by write_dollar_variable. */
473 exp : SIZEOF '(' type ')' %prec UNARY
474 { write_exp_elt_opcode (OP_LONG);
475 write_exp_elt_type (builtin_type_int);
477 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
478 write_exp_elt_opcode (OP_LONG); }
482 { /* C strings are converted into array constants with
483 an explicit null byte added at the end. Thus
484 the array upper bound is the string length.
485 There is no such thing in C as a completely empty
487 char *sp = $1.ptr; int count = $1.length;
490 write_exp_elt_opcode (OP_LONG);
491 write_exp_elt_type (builtin_type_char);
492 write_exp_elt_longcst ((LONGEST)(*sp++));
493 write_exp_elt_opcode (OP_LONG);
495 write_exp_elt_opcode (OP_LONG);
496 write_exp_elt_type (builtin_type_char);
497 write_exp_elt_longcst ((LONGEST)'\0');
498 write_exp_elt_opcode (OP_LONG);
499 write_exp_elt_opcode (OP_ARRAY);
500 write_exp_elt_longcst ((LONGEST) 0);
501 write_exp_elt_longcst ((LONGEST) ($1.length));
502 write_exp_elt_opcode (OP_ARRAY); }
507 { write_exp_elt_opcode (OP_THIS);
508 write_exp_elt_opcode (OP_THIS); }
511 /* end of object pascal. */
516 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
520 lookup_symtab (copy_name ($1.stoken));
522 $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK);
524 error ("No file or function \"%s\".",
525 copy_name ($1.stoken));
530 block : block COLONCOLON name
532 = lookup_symbol (copy_name ($3), $1,
533 VAR_NAMESPACE, (int *) NULL,
534 (struct symtab **) NULL);
535 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
536 error ("No function \"%s\" in specified context.",
538 $$ = SYMBOL_BLOCK_VALUE (tem); }
541 variable: block COLONCOLON name
542 { struct symbol *sym;
543 sym = lookup_symbol (copy_name ($3), $1,
544 VAR_NAMESPACE, (int *) NULL,
545 (struct symtab **) NULL);
547 error ("No symbol \"%s\" in specified context.",
550 write_exp_elt_opcode (OP_VAR_VALUE);
551 /* block_found is set by lookup_symbol. */
552 write_exp_elt_block (block_found);
553 write_exp_elt_sym (sym);
554 write_exp_elt_opcode (OP_VAR_VALUE); }
557 qualified_name: typebase COLONCOLON name
559 struct type *type = $1;
560 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
561 && TYPE_CODE (type) != TYPE_CODE_UNION)
562 error ("`%s' is not defined as an aggregate type.",
565 write_exp_elt_opcode (OP_SCOPE);
566 write_exp_elt_type (type);
567 write_exp_string ($3);
568 write_exp_elt_opcode (OP_SCOPE);
572 variable: qualified_name
575 char *name = copy_name ($2);
577 struct minimal_symbol *msymbol;
580 lookup_symbol (name, (const struct block *) NULL,
581 VAR_NAMESPACE, (int *) NULL,
582 (struct symtab **) NULL);
585 write_exp_elt_opcode (OP_VAR_VALUE);
586 write_exp_elt_block (NULL);
587 write_exp_elt_sym (sym);
588 write_exp_elt_opcode (OP_VAR_VALUE);
592 msymbol = lookup_minimal_symbol (name, NULL, NULL);
595 write_exp_msymbol (msymbol,
596 lookup_function_type (builtin_type_int),
600 if (!have_full_symbols () && !have_partial_symbols ())
601 error ("No symbol table is loaded. Use the \"file\" command.");
603 error ("No symbol \"%s\" in current context.", name);
607 variable: name_not_typename
608 { struct symbol *sym = $1.sym;
612 if (symbol_read_needs_frame (sym))
614 if (innermost_block == 0 ||
615 contained_in (block_found,
617 innermost_block = block_found;
620 write_exp_elt_opcode (OP_VAR_VALUE);
621 /* We want to use the selected frame, not
622 another more inner frame which happens to
623 be in the same block. */
624 write_exp_elt_block (NULL);
625 write_exp_elt_sym (sym);
626 write_exp_elt_opcode (OP_VAR_VALUE);
627 current_type = sym->type; }
628 else if ($1.is_a_field_of_this)
630 struct value * this_val;
631 struct type * this_type;
632 /* Object pascal: it hangs off of `this'. Must
633 not inadvertently convert from a method call
635 if (innermost_block == 0 ||
636 contained_in (block_found, innermost_block))
637 innermost_block = block_found;
638 write_exp_elt_opcode (OP_THIS);
639 write_exp_elt_opcode (OP_THIS);
640 write_exp_elt_opcode (STRUCTOP_PTR);
641 write_exp_string ($1.stoken);
642 write_exp_elt_opcode (STRUCTOP_PTR);
643 /* we need type of this */
644 this_val = value_of_this (0);
646 this_type = this_val->type;
650 current_type = lookup_struct_elt_type (
652 $1.stoken.ptr, false);
658 struct minimal_symbol *msymbol;
659 register char *arg = copy_name ($1.stoken);
662 lookup_minimal_symbol (arg, NULL, NULL);
665 write_exp_msymbol (msymbol,
666 lookup_function_type (builtin_type_int),
669 else if (!have_full_symbols () && !have_partial_symbols ())
670 error ("No symbol table is loaded. Use the \"file\" command.");
672 error ("No symbol \"%s\" in current context.",
673 copy_name ($1.stoken));
682 /* We used to try to recognize more pointer to member types here, but
683 that didn't work (shift/reduce conflicts meant that these rules never
684 got executed). The problem is that
685 int (foo::bar::baz::bizzle)
686 is a function type but
687 int (foo::bar::baz::bizzle::*)
688 is a pointer to member type. Stroustrup loses again! */
691 | typebase COLONCOLON '*'
692 { $$ = lookup_member_type (builtin_type_int, $1); }
695 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
699 { $$ = lookup_struct (copy_name ($2),
700 expression_context_block); }
702 { $$ = lookup_struct (copy_name ($2),
703 expression_context_block); }
704 /* "const" and "volatile" are curently ignored. A type qualifier
705 after the type is handled in the ptype rule. I think these could
709 name : NAME { $$ = $1.stoken; }
710 | BLOCKNAME { $$ = $1.stoken; }
711 | TYPENAME { $$ = $1.stoken; }
712 | NAME_OR_INT { $$ = $1.stoken; }
715 name_not_typename : NAME
717 /* These would be useful if name_not_typename was useful, but it is just
718 a fake for "variable", so these cause reduce/reduce conflicts because
719 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
720 =exp) or just an exp. If name_not_typename was ever used in an lvalue
721 context where only a name could occur, this might be useful.
728 /* Take care of parsing a number (anything that starts with a digit).
729 Set yylval and return the token type; update lexptr.
730 LEN is the number of characters in it. */
732 /*** Needs some error checking for the float case ***/
735 parse_number (p, len, parsed_float, putithere)
741 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
742 here, and we do kind of silly things like cast to unsigned. */
743 register LONGEST n = 0;
744 register LONGEST prevn = 0;
749 register int base = input_radix;
752 /* Number of "L" suffixes encountered. */
755 /* We have found a "L" or "U" suffix. */
756 int found_suffix = 0;
759 struct type *signed_type;
760 struct type *unsigned_type;
764 /* It's a float since it contains a point or an exponent. */
766 int num = 0; /* number of tokens scanned by scanf */
767 char saved_char = p[len];
769 p[len] = 0; /* null-terminate the token */
770 if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
771 num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval,&c);
772 else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
773 num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval,&c);
776 #ifdef SCANF_HAS_LONG_DOUBLE
777 num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval,&c);
779 /* Scan it into a double, then assign it to the long double.
780 This at least wins with values representable in the range
783 num = sscanf (p, "%lg%c", &temp,&c);
784 putithere->typed_val_float.dval = temp;
787 p[len] = saved_char; /* restore the input stream */
788 if (num != 1) /* check scanf found ONLY a float ... */
790 /* See if it has `f' or `l' suffix (float or long double). */
792 c = tolower (p[len - 1]);
795 putithere->typed_val_float.type = builtin_type_float;
797 putithere->typed_val_float.type = builtin_type_long_double;
798 else if (isdigit (c) || c == '.')
799 putithere->typed_val_float.type = builtin_type_double;
806 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
840 if (c >= 'A' && c <= 'Z')
842 if (c != 'l' && c != 'u')
844 if (c >= '0' && c <= '9')
852 if (base > 10 && c >= 'a' && c <= 'f')
856 n += i = c - 'a' + 10;
869 return ERROR; /* Char not a digit */
872 return ERROR; /* Invalid digit in this base */
874 /* Portably test for overflow (only works for nonzero values, so make
875 a second check for zero). FIXME: Can't we just make n and prevn
876 unsigned and avoid this? */
877 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
878 unsigned_p = 1; /* Try something unsigned */
880 /* Portably test for unsigned overflow.
881 FIXME: This check is wrong; for example it doesn't find overflow
882 on 0x123456789 when LONGEST is 32 bits. */
883 if (c != 'l' && c != 'u' && n != 0)
885 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
886 error ("Numeric constant too large.");
891 /* An integer constant is an int, a long, or a long long. An L
892 suffix forces it to be long; an LL suffix forces it to be long
893 long. If not forced to a larger size, it gets the first type of
894 the above that it fits in. To figure out whether it fits, we
895 shift it right and see whether anything remains. Note that we
896 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
897 operation, because many compilers will warn about such a shift
898 (which always produces a zero result). Sometimes TARGET_INT_BIT
899 or TARGET_LONG_BIT will be that big, sometimes not. To deal with
900 the case where it is we just always shift the value more than
901 once, with fewer bits each time. */
903 un = (ULONGEST)n >> 2;
905 && (un >> (TARGET_INT_BIT - 2)) == 0)
907 high_bit = ((ULONGEST)1) << (TARGET_INT_BIT-1);
909 /* A large decimal (not hex or octal) constant (between INT_MAX
910 and UINT_MAX) is a long or unsigned long, according to ANSI,
911 never an unsigned int, but this code treats it as unsigned
912 int. This probably should be fixed. GCC gives a warning on
915 unsigned_type = builtin_type_unsigned_int;
916 signed_type = builtin_type_int;
919 && (un >> (TARGET_LONG_BIT - 2)) == 0)
921 high_bit = ((ULONGEST)1) << (TARGET_LONG_BIT-1);
922 unsigned_type = builtin_type_unsigned_long;
923 signed_type = builtin_type_long;
928 if (sizeof (ULONGEST) * HOST_CHAR_BIT < TARGET_LONG_LONG_BIT)
929 /* A long long does not fit in a LONGEST. */
930 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
932 shift = (TARGET_LONG_LONG_BIT - 1);
933 high_bit = (ULONGEST) 1 << shift;
934 unsigned_type = builtin_type_unsigned_long_long;
935 signed_type = builtin_type_long_long;
938 putithere->typed_val_int.val = n;
940 /* If the high bit of the worked out type is set then this number
941 has to be unsigned. */
943 if (unsigned_p || (n & high_bit))
945 putithere->typed_val_int.type = unsigned_type;
949 putithere->typed_val_int.type = signed_type;
959 struct type_push *next;
962 static struct type_push *tp_top = NULL;
964 static void push_current_type ()
966 struct type_push *tpnew;
967 tpnew = (struct type_push *) malloc (sizeof (struct type_push));
968 tpnew->next = tp_top;
969 tpnew->stored = current_type;
974 static void pop_current_type ()
976 struct type_push *tp = tp_top;
979 current_type = tp->stored;
989 enum exp_opcode opcode;
992 static const struct token tokentab3[] =
994 {"shr", RSH, BINOP_END},
995 {"shl", LSH, BINOP_END},
996 {"and", ANDAND, BINOP_END},
997 {"div", DIV, BINOP_END},
998 {"not", NOT, BINOP_END},
999 {"mod", MOD, BINOP_END},
1000 {"inc", INCREMENT, BINOP_END},
1001 {"dec", DECREMENT, BINOP_END},
1002 {"xor", XOR, BINOP_END}
1005 static const struct token tokentab2[] =
1007 {"or", OR, BINOP_END},
1008 {"<>", NOTEQUAL, BINOP_END},
1009 {"<=", LEQ, BINOP_END},
1010 {">=", GEQ, BINOP_END},
1011 {":=", ASSIGN, BINOP_END},
1012 {"::", COLONCOLON, BINOP_END} };
1014 /* Allocate uppercased var */
1015 /* make an uppercased copy of tokstart */
1016 static char * uptok (tokstart, namelen)
1021 char *uptokstart = (char *)malloc(namelen+1);
1022 for (i = 0;i <= namelen;i++)
1024 if ((tokstart[i]>='a' && tokstart[i]<='z'))
1025 uptokstart[i] = tokstart[i]-('a'-'A');
1027 uptokstart[i] = tokstart[i];
1029 uptokstart[namelen]='\0';
1032 /* Read one token, getting characters through lexptr. */
1045 int explen, tempbufindex;
1046 static char *tempbuf;
1047 static int tempbufsize;
1051 prev_lexptr = lexptr;
1054 explen = strlen (lexptr);
1055 /* See if it is a special token of length 3. */
1057 for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
1058 if (strncasecmp (tokstart, tokentab3[i].operator, 3) == 0
1059 && (!isalpha (tokentab3[i].operator[0]) || explen == 3
1060 || (!isalpha (tokstart[3]) && !isdigit (tokstart[3]) && tokstart[3] != '_')))
1063 yylval.opcode = tokentab3[i].opcode;
1064 return tokentab3[i].token;
1067 /* See if it is a special token of length 2. */
1069 for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
1070 if (strncasecmp (tokstart, tokentab2[i].operator, 2) == 0
1071 && (!isalpha (tokentab2[i].operator[0]) || explen == 2
1072 || (!isalpha (tokstart[2]) && !isdigit (tokstart[2]) && tokstart[2] != '_')))
1075 yylval.opcode = tokentab2[i].opcode;
1076 return tokentab2[i].token;
1079 switch (c = *tokstart)
1091 /* We either have a character constant ('0' or '\177' for example)
1092 or we have a quoted symbol reference ('foo(int,int)' in object pascal
1097 c = parse_escape (&lexptr);
1099 error ("Empty character constant.");
1101 yylval.typed_val_int.val = c;
1102 yylval.typed_val_int.type = builtin_type_char;
1107 namelen = skip_quoted (tokstart) - tokstart;
1110 lexptr = tokstart + namelen;
1111 if (lexptr[-1] != '\'')
1112 error ("Unmatched single quote.");
1115 uptokstart = uptok(tokstart,namelen);
1118 error ("Invalid character constant.");
1128 if (paren_depth == 0)
1135 if (comma_terminates && paren_depth == 0)
1141 /* Might be a floating point number. */
1142 if (lexptr[1] < '0' || lexptr[1] > '9')
1143 goto symbol; /* Nope, must be a symbol. */
1144 /* FALL THRU into number case. */
1157 /* It's a number. */
1158 int got_dot = 0, got_e = 0, toktype;
1159 register char *p = tokstart;
1160 int hex = input_radix > 10;
1162 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1167 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1175 /* This test includes !hex because 'e' is a valid hex digit
1176 and thus does not indicate a floating point number when
1177 the radix is hex. */
1178 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1179 got_dot = got_e = 1;
1180 /* This test does not include !hex, because a '.' always indicates
1181 a decimal floating point number regardless of the radix. */
1182 else if (!got_dot && *p == '.')
1184 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1185 && (*p == '-' || *p == '+'))
1186 /* This is the sign of the exponent, not the end of the
1189 /* We will take any letters or digits. parse_number will
1190 complain if past the radix, or if L or U are not final. */
1191 else if ((*p < '0' || *p > '9')
1192 && ((*p < 'a' || *p > 'z')
1193 && (*p < 'A' || *p > 'Z')))
1196 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1197 if (toktype == ERROR)
1199 char *err_copy = (char *) alloca (p - tokstart + 1);
1201 memcpy (err_copy, tokstart, p - tokstart);
1202 err_copy[p - tokstart] = 0;
1203 error ("Invalid number \"%s\".", err_copy);
1234 /* Build the gdb internal form of the input string in tempbuf,
1235 translating any standard C escape forms seen. Note that the
1236 buffer is null byte terminated *only* for the convenience of
1237 debugging gdb itself and printing the buffer contents when
1238 the buffer contains no embedded nulls. Gdb does not depend
1239 upon the buffer being null byte terminated, it uses the length
1240 string instead. This allows gdb to handle C strings (as well
1241 as strings in other languages) with embedded null bytes */
1243 tokptr = ++tokstart;
1247 /* Grow the static temp buffer if necessary, including allocating
1248 the first one on demand. */
1249 if (tempbufindex + 1 >= tempbufsize)
1251 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1258 /* Do nothing, loop will terminate. */
1262 c = parse_escape (&tokptr);
1267 tempbuf[tempbufindex++] = c;
1270 tempbuf[tempbufindex++] = *tokptr++;
1273 } while ((*tokptr != '"') && (*tokptr != '\0'));
1274 if (*tokptr++ != '"')
1276 error ("Unterminated string in expression.");
1278 tempbuf[tempbufindex] = '\0'; /* See note above */
1279 yylval.sval.ptr = tempbuf;
1280 yylval.sval.length = tempbufindex;
1285 if (!(c == '_' || c == '$'
1286 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1287 /* We must have come across a bad character (e.g. ';'). */
1288 error ("Invalid character '%c' in expression.", c);
1290 /* It's a name. See how long it is. */
1292 for (c = tokstart[namelen];
1293 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1294 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1296 /* Template parameter lists are part of the name.
1297 FIXME: This mishandles `print $a<4&&$a>3'. */
1301 int nesting_level = 1;
1302 while (tokstart[++i])
1304 if (tokstart[i] == '<')
1306 else if (tokstart[i] == '>')
1308 if (--nesting_level == 0)
1312 if (tokstart[i] == '>')
1318 /* do NOT uppercase internals because of registers !!! */
1319 c = tokstart[++namelen];
1322 uptokstart = uptok(tokstart,namelen);
1324 /* The token "if" terminates the expression and is NOT
1325 removed from the input stream. */
1326 if (namelen == 2 && uptokstart[0] == 'I' && uptokstart[1] == 'F')
1335 /* Catch specific keywords. Should be done with a data structure. */
1339 if (STREQ (uptokstart, "OBJECT"))
1341 if (STREQ (uptokstart, "RECORD"))
1343 if (STREQ (uptokstart, "SIZEOF"))
1347 if (STREQ (uptokstart, "CLASS"))
1349 if (STREQ (uptokstart, "FALSE"))
1356 if (STREQ (uptokstart, "TRUE"))
1361 if (STREQ (uptokstart, "SELF"))
1363 /* here we search for 'this' like
1364 inserted in FPC stabs debug info */
1365 static const char this_name[] = "this";
1367 if (lookup_symbol (this_name, expression_context_block,
1368 VAR_NAMESPACE, (int *) NULL,
1369 (struct symtab **) NULL))
1377 yylval.sval.ptr = tokstart;
1378 yylval.sval.length = namelen;
1380 if (*tokstart == '$')
1382 /* $ is the normal prefix for pascal hexadecimal values
1383 but this conflicts with the GDB use for debugger variables
1384 so in expression to enter hexadecimal values
1385 we still need to use C syntax with 0xff */
1386 write_dollar_variable (yylval.sval);
1390 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1391 functions or symtabs. If this is not so, then ...
1392 Use token-type TYPENAME for symbols that happen to be defined
1393 currently as names of types; NAME for other symbols.
1394 The caller is not constrained to care about the distinction. */
1396 char *tmp = copy_name (yylval.sval);
1398 int is_a_field_of_this = 0;
1403 if (search_field && current_type)
1404 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1408 sym = lookup_symbol (tmp, expression_context_block,
1410 &is_a_field_of_this,
1411 (struct symtab **) NULL);
1412 /* second chance uppercased (as Free Pascal does). */
1413 if (!sym && !is_a_field_of_this && !is_a_field)
1415 for (i = 0; i <= namelen; i++)
1417 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1418 tmp[i] -= ('a'-'A');
1420 if (search_field && current_type)
1421 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1425 sym = lookup_symbol (tmp, expression_context_block,
1427 &is_a_field_of_this,
1428 (struct symtab **) NULL);
1429 if (sym || is_a_field_of_this || is_a_field)
1430 for (i = 0; i <= namelen; i++)
1432 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
1433 tokstart[i] -= ('a'-'A');
1436 /* Third chance Capitalized (as GPC does). */
1437 if (!sym && !is_a_field_of_this && !is_a_field)
1439 for (i = 0; i <= namelen; i++)
1443 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1444 tmp[i] -= ('a'-'A');
1447 if ((tmp[i] >= 'A' && tmp[i] <= 'Z'))
1448 tmp[i] -= ('A'-'a');
1450 if (search_field && current_type)
1451 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1455 sym = lookup_symbol (tmp, expression_context_block,
1457 &is_a_field_of_this,
1458 (struct symtab **) NULL);
1459 if (sym || is_a_field_of_this || is_a_field)
1460 for (i = 0; i <= namelen; i++)
1464 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
1465 tokstart[i] -= ('a'-'A');
1468 if ((tokstart[i] >= 'A' && tokstart[i] <= 'Z'))
1469 tokstart[i] -= ('A'-'a');
1475 tempbuf = (char *) realloc (tempbuf, namelen + 1);
1476 strncpy (tempbuf, tokstart, namelen); tempbuf [namelen] = 0;
1477 yylval.sval.ptr = tempbuf;
1478 yylval.sval.length = namelen;
1481 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1482 no psymtabs (coff, xcoff, or some future change to blow away the
1483 psymtabs once once symbols are read). */
1484 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1485 lookup_symtab (tmp))
1487 yylval.ssym.sym = sym;
1488 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1491 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1494 /* Despite the following flaw, we need to keep this code enabled.
1495 Because we can get called from check_stub_method, if we don't
1496 handle nested types then it screws many operations in any
1497 program which uses nested types. */
1498 /* In "A::x", if x is a member function of A and there happens
1499 to be a type (nested or not, since the stabs don't make that
1500 distinction) named x, then this code incorrectly thinks we
1501 are dealing with nested types rather than a member function. */
1505 struct symbol *best_sym;
1507 /* Look ahead to detect nested types. This probably should be
1508 done in the grammar, but trying seemed to introduce a lot
1509 of shift/reduce and reduce/reduce conflicts. It's possible
1510 that it could be done, though. Or perhaps a non-grammar, but
1511 less ad hoc, approach would work well. */
1513 /* Since we do not currently have any way of distinguishing
1514 a nested type from a non-nested one (the stabs don't tell
1515 us whether a type is nested), we just ignore the
1522 /* Skip whitespace. */
1523 while (*p == ' ' || *p == '\t' || *p == '\n')
1525 if (*p == ':' && p[1] == ':')
1527 /* Skip the `::'. */
1529 /* Skip whitespace. */
1530 while (*p == ' ' || *p == '\t' || *p == '\n')
1533 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1534 || (*p >= 'a' && *p <= 'z')
1535 || (*p >= 'A' && *p <= 'Z'))
1539 struct symbol *cur_sym;
1540 /* As big as the whole rest of the expression, which is
1541 at least big enough. */
1542 char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
1546 memcpy (tmp1, tmp, strlen (tmp));
1547 tmp1 += strlen (tmp);
1548 memcpy (tmp1, "::", 2);
1550 memcpy (tmp1, namestart, p - namestart);
1551 tmp1[p - namestart] = '\0';
1552 cur_sym = lookup_symbol (ncopy, expression_context_block,
1553 VAR_NAMESPACE, (int *) NULL,
1554 (struct symtab **) NULL);
1557 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1575 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1577 yylval.tsym.type = SYMBOL_TYPE (sym);
1581 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1584 /* Input names that aren't symbols but ARE valid hex numbers,
1585 when the input radix permits them, can be names or numbers
1586 depending on the parse. Note we support radixes > 16 here. */
1588 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1589 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1591 YYSTYPE newlval; /* Its value is ignored. */
1592 hextype = parse_number (tokstart, namelen, 0, &newlval);
1595 yylval.ssym.sym = sym;
1596 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1602 /* Any other kind of symbol */
1603 yylval.ssym.sym = sym;
1604 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1614 lexptr = prev_lexptr;
1616 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);