1 /* YACC parser for Pascal expressions, for GDB.
2 Copyright (C) 2000, 2006-2012 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program 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 3 of the License, or
9 (at your option) any later version.
11 This program 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 this program. If not, see <http://www.gnu.org/licenses/>. */
19 /* This file is derived from c-exp.y */
21 /* Parse a Pascal expression from text in a string,
22 and return the result as a struct expression pointer.
23 That structure contains arithmetic operations in reverse polish,
24 with constants represented by operations that are followed by special data.
25 See expression.h for the details of the format.
26 What is important here is that it can be built up sequentially
27 during the process of parsing; the lower levels of the tree always
28 come first in the result.
30 Note that malloc's and realloc's in this file are transformed to
31 xmalloc and xrealloc respectively by the same sed command in the
32 makefile that remaps any other malloc/realloc inserted by the parser
33 generator. Doing this with #defines and trying to control the interaction
34 with include files (<malloc.h> and <stdlib.h> for example) just became
35 too messy, particularly when such includes can be inserted at random
36 times by the parser generator. */
38 /* Known bugs or limitations:
39 - pascal string operations are not supported at all.
40 - there are some problems with boolean types.
41 - Pascal type hexadecimal constants are not supported
42 because they conflict with the internal variables format.
43 Probably also lots of other problems, less well defined PM. */
47 #include "gdb_string.h"
49 #include "expression.h"
51 #include "parser-defs.h"
54 #include "bfd.h" /* Required by objfiles.h. */
55 #include "symfile.h" /* Required by objfiles.h. */
56 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols. */
59 #define parse_type builtin_type (parse_gdbarch)
61 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
62 as well as gratuitiously global symbol names, so we can have multiple
63 yacc generated parsers in gdb. Note that these are only the variables
64 produced by yacc. If other parser generators (bison, byacc, etc) produce
65 additional global names that conflict at link time, then those parser
66 generators need to be fixed instead of adding those names to this list. */
68 #define yymaxdepth pascal_maxdepth
69 #define yyparse pascal_parse
70 #define yylex pascal_lex
71 #define yyerror pascal_error
72 #define yylval pascal_lval
73 #define yychar pascal_char
74 #define yydebug pascal_debug
75 #define yypact pascal_pact
76 #define yyr1 pascal_r1
77 #define yyr2 pascal_r2
78 #define yydef pascal_def
79 #define yychk pascal_chk
80 #define yypgo pascal_pgo
81 #define yyact pascal_act
82 #define yyexca pascal_exca
83 #define yyerrflag pascal_errflag
84 #define yynerrs pascal_nerrs
85 #define yyps pascal_ps
86 #define yypv pascal_pv
88 #define yy_yys pascal_yys
89 #define yystate pascal_state
90 #define yytmp pascal_tmp
92 #define yy_yyv pascal_yyv
93 #define yyval pascal_val
94 #define yylloc pascal_lloc
95 #define yyreds pascal_reds /* With YYDEBUG defined */
96 #define yytoks pascal_toks /* With YYDEBUG defined */
97 #define yyname pascal_name /* With YYDEBUG defined */
98 #define yyrule pascal_rule /* With YYDEBUG defined */
99 #define yylhs pascal_yylhs
100 #define yylen pascal_yylen
101 #define yydefred pascal_yydefred
102 #define yydgoto pascal_yydgoto
103 #define yysindex pascal_yysindex
104 #define yyrindex pascal_yyrindex
105 #define yygindex pascal_yygindex
106 #define yytable pascal_yytable
107 #define yycheck pascal_yycheck
110 #define YYDEBUG 1 /* Default to yydebug support */
113 #define YYFPRINTF parser_fprintf
117 static int yylex (void);
119 void yyerror (char *);
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 */
155 static int parse_number (char *, int, int, YYSTYPE *);
157 static struct type *current_type;
158 static struct internalvar *intvar;
159 static int leftdiv_is_integer;
160 static void push_current_type (void);
161 static void pop_current_type (void);
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 <voidval> COMPLETE
186 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
187 %token <tsym> TYPENAME
189 %type <ssym> name_not_typename
191 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
192 but which would parse as a valid number in the current input radix.
193 E.g. "c" when input_radix==16. Depending on the parse, it will be
194 turned into a name or into a number. */
196 %token <ssym> NAME_OR_INT
198 %token STRUCT CLASS SIZEOF COLONCOLON
201 /* Special type cases, put in to allow the parser to distinguish different
204 %token <voidval> VARIABLE
209 %token <lval> TRUEKEYWORD FALSEKEYWORD
219 %left '<' '>' LEQ GEQ
220 %left LSH RSH DIV MOD
224 %right UNARY INCREMENT DECREMENT
225 %right ARROW '.' '[' '('
227 %token <ssym> BLOCKNAME
234 start : { current_type = NULL;
237 leftdiv_is_integer = 0;
248 { write_exp_elt_opcode(OP_TYPE);
249 write_exp_elt_type($1);
250 write_exp_elt_opcode(OP_TYPE);
251 current_type = $1; } ;
253 /* Expressions, including the comma operator. */
256 { write_exp_elt_opcode (BINOP_COMMA); }
259 /* Expressions, not including the comma operator. */
260 exp : exp '^' %prec UNARY
261 { write_exp_elt_opcode (UNOP_IND);
263 current_type = TYPE_TARGET_TYPE (current_type); }
266 exp : '@' exp %prec UNARY
267 { write_exp_elt_opcode (UNOP_ADDR);
269 current_type = TYPE_POINTER_TYPE (current_type); }
272 exp : '-' exp %prec UNARY
273 { write_exp_elt_opcode (UNOP_NEG); }
276 exp : NOT exp %prec UNARY
277 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
280 exp : INCREMENT '(' exp ')' %prec UNARY
281 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
284 exp : DECREMENT '(' exp ')' %prec UNARY
285 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
289 field_exp : exp '.' %prec UNARY
290 { search_field = 1; }
293 exp : field_exp FIELDNAME
294 { write_exp_elt_opcode (STRUCTOP_STRUCT);
295 write_exp_string ($2);
296 write_exp_elt_opcode (STRUCTOP_STRUCT);
300 while (TYPE_CODE (current_type)
303 TYPE_TARGET_TYPE (current_type);
304 current_type = lookup_struct_elt_type (
305 current_type, $2.ptr, 0);
312 { mark_struct_expression ();
313 write_exp_elt_opcode (STRUCTOP_STRUCT);
314 write_exp_string ($2);
315 write_exp_elt_opcode (STRUCTOP_STRUCT);
319 while (TYPE_CODE (current_type)
322 TYPE_TARGET_TYPE (current_type);
323 current_type = lookup_struct_elt_type (
324 current_type, $2.ptr, 0);
329 exp : field_exp COMPLETE
331 mark_struct_expression ();
332 write_exp_elt_opcode (STRUCTOP_STRUCT);
335 write_exp_string (s);
336 write_exp_elt_opcode (STRUCTOP_STRUCT); }
340 /* We need to save the current_type value. */
343 arrayfieldindex = is_pascal_string_type (
344 current_type, NULL, NULL,
345 NULL, NULL, &arrayname);
348 struct stoken stringsval;
349 stringsval.ptr = alloca (strlen (arrayname) + 1);
350 stringsval.length = strlen (arrayname);
351 strcpy (stringsval.ptr, arrayname);
352 current_type = TYPE_FIELD_TYPE (current_type,
353 arrayfieldindex - 1);
354 write_exp_elt_opcode (STRUCTOP_STRUCT);
355 write_exp_string (stringsval);
356 write_exp_elt_opcode (STRUCTOP_STRUCT);
358 push_current_type (); }
360 { pop_current_type ();
361 write_exp_elt_opcode (BINOP_SUBSCRIPT);
363 current_type = TYPE_TARGET_TYPE (current_type); }
367 /* This is to save the value of arglist_len
368 being accumulated by an outer function call. */
369 { push_current_type ();
371 arglist ')' %prec ARROW
372 { write_exp_elt_opcode (OP_FUNCALL);
373 write_exp_elt_longcst ((LONGEST) end_arglist ());
374 write_exp_elt_opcode (OP_FUNCALL);
377 current_type = TYPE_TARGET_TYPE (current_type);
384 | arglist ',' exp %prec ABOVE_COMMA
388 exp : type '(' exp ')' %prec UNARY
391 /* Allow automatic dereference of classes. */
392 if ((TYPE_CODE (current_type) == TYPE_CODE_PTR)
393 && (TYPE_CODE (TYPE_TARGET_TYPE (current_type)) == TYPE_CODE_CLASS)
394 && (TYPE_CODE ($1) == TYPE_CODE_CLASS))
395 write_exp_elt_opcode (UNOP_IND);
397 write_exp_elt_opcode (UNOP_CAST);
398 write_exp_elt_type ($1);
399 write_exp_elt_opcode (UNOP_CAST);
407 /* Binary operators in order of decreasing precedence. */
410 { write_exp_elt_opcode (BINOP_MUL); }
414 if (current_type && is_integral_type (current_type))
415 leftdiv_is_integer = 1;
419 if (leftdiv_is_integer && current_type
420 && is_integral_type (current_type))
422 write_exp_elt_opcode (UNOP_CAST);
423 write_exp_elt_type (parse_type->builtin_long_double);
424 current_type = parse_type->builtin_long_double;
425 write_exp_elt_opcode (UNOP_CAST);
426 leftdiv_is_integer = 0;
429 write_exp_elt_opcode (BINOP_DIV);
434 { write_exp_elt_opcode (BINOP_INTDIV); }
438 { write_exp_elt_opcode (BINOP_REM); }
442 { write_exp_elt_opcode (BINOP_ADD); }
446 { write_exp_elt_opcode (BINOP_SUB); }
450 { write_exp_elt_opcode (BINOP_LSH); }
454 { write_exp_elt_opcode (BINOP_RSH); }
458 { write_exp_elt_opcode (BINOP_EQUAL);
459 current_type = parse_type->builtin_bool;
463 exp : exp NOTEQUAL exp
464 { write_exp_elt_opcode (BINOP_NOTEQUAL);
465 current_type = parse_type->builtin_bool;
470 { write_exp_elt_opcode (BINOP_LEQ);
471 current_type = parse_type->builtin_bool;
476 { write_exp_elt_opcode (BINOP_GEQ);
477 current_type = parse_type->builtin_bool;
482 { write_exp_elt_opcode (BINOP_LESS);
483 current_type = parse_type->builtin_bool;
488 { write_exp_elt_opcode (BINOP_GTR);
489 current_type = parse_type->builtin_bool;
494 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
498 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
502 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
506 { write_exp_elt_opcode (BINOP_ASSIGN); }
510 { write_exp_elt_opcode (OP_BOOL);
511 write_exp_elt_longcst ((LONGEST) $1);
512 current_type = parse_type->builtin_bool;
513 write_exp_elt_opcode (OP_BOOL); }
517 { write_exp_elt_opcode (OP_BOOL);
518 write_exp_elt_longcst ((LONGEST) $1);
519 current_type = parse_type->builtin_bool;
520 write_exp_elt_opcode (OP_BOOL); }
524 { write_exp_elt_opcode (OP_LONG);
525 write_exp_elt_type ($1.type);
526 current_type = $1.type;
527 write_exp_elt_longcst ((LONGEST)($1.val));
528 write_exp_elt_opcode (OP_LONG); }
533 parse_number ($1.stoken.ptr,
534 $1.stoken.length, 0, &val);
535 write_exp_elt_opcode (OP_LONG);
536 write_exp_elt_type (val.typed_val_int.type);
537 current_type = val.typed_val_int.type;
538 write_exp_elt_longcst ((LONGEST)
539 val.typed_val_int.val);
540 write_exp_elt_opcode (OP_LONG);
546 { write_exp_elt_opcode (OP_DOUBLE);
547 write_exp_elt_type ($1.type);
548 current_type = $1.type;
549 write_exp_elt_dblcst ($1.dval);
550 write_exp_elt_opcode (OP_DOUBLE); }
557 /* Already written by write_dollar_variable.
558 Handle current_type. */
560 struct value * val, * mark;
562 mark = value_mark ();
563 val = value_of_internalvar (parse_gdbarch,
565 current_type = value_type (val);
566 value_release_to_mark (mark);
571 exp : SIZEOF '(' type ')' %prec UNARY
572 { write_exp_elt_opcode (OP_LONG);
573 write_exp_elt_type (parse_type->builtin_int);
575 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
576 write_exp_elt_opcode (OP_LONG); }
579 exp : SIZEOF '(' exp ')' %prec UNARY
580 { write_exp_elt_opcode (UNOP_SIZEOF); }
583 { /* C strings are converted into array constants with
584 an explicit null byte added at the end. Thus
585 the array upper bound is the string length.
586 There is no such thing in C as a completely empty
588 char *sp = $1.ptr; int count = $1.length;
591 write_exp_elt_opcode (OP_LONG);
592 write_exp_elt_type (parse_type->builtin_char);
593 write_exp_elt_longcst ((LONGEST)(*sp++));
594 write_exp_elt_opcode (OP_LONG);
596 write_exp_elt_opcode (OP_LONG);
597 write_exp_elt_type (parse_type->builtin_char);
598 write_exp_elt_longcst ((LONGEST)'\0');
599 write_exp_elt_opcode (OP_LONG);
600 write_exp_elt_opcode (OP_ARRAY);
601 write_exp_elt_longcst ((LONGEST) 0);
602 write_exp_elt_longcst ((LONGEST) ($1.length));
603 write_exp_elt_opcode (OP_ARRAY); }
609 struct value * this_val;
610 struct type * this_type;
611 write_exp_elt_opcode (OP_THIS);
612 write_exp_elt_opcode (OP_THIS);
613 /* We need type of this. */
614 this_val = value_of_this_silent (parse_language);
616 this_type = value_type (this_val);
621 if (TYPE_CODE (this_type) == TYPE_CODE_PTR)
623 this_type = TYPE_TARGET_TYPE (this_type);
624 write_exp_elt_opcode (UNOP_IND);
628 current_type = this_type;
632 /* end of object pascal. */
637 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
641 lookup_symtab (copy_name ($1.stoken));
643 $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem),
646 error (_("No file or function \"%s\"."),
647 copy_name ($1.stoken));
652 block : block COLONCOLON name
654 = lookup_symbol (copy_name ($3), $1,
655 VAR_DOMAIN, (int *) NULL);
656 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
657 error (_("No function \"%s\" in specified context."),
659 $$ = SYMBOL_BLOCK_VALUE (tem); }
662 variable: block COLONCOLON name
663 { struct symbol *sym;
664 sym = lookup_symbol (copy_name ($3), $1,
665 VAR_DOMAIN, (int *) NULL);
667 error (_("No symbol \"%s\" in specified context."),
670 write_exp_elt_opcode (OP_VAR_VALUE);
671 /* block_found is set by lookup_symbol. */
672 write_exp_elt_block (block_found);
673 write_exp_elt_sym (sym);
674 write_exp_elt_opcode (OP_VAR_VALUE); }
677 qualified_name: typebase COLONCOLON name
679 struct type *type = $1;
680 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
681 && TYPE_CODE (type) != TYPE_CODE_UNION)
682 error (_("`%s' is not defined as an aggregate type."),
685 write_exp_elt_opcode (OP_SCOPE);
686 write_exp_elt_type (type);
687 write_exp_string ($3);
688 write_exp_elt_opcode (OP_SCOPE);
692 variable: qualified_name
695 char *name = copy_name ($2);
697 struct minimal_symbol *msymbol;
700 lookup_symbol (name, (const struct block *) NULL,
701 VAR_DOMAIN, (int *) NULL);
704 write_exp_elt_opcode (OP_VAR_VALUE);
705 write_exp_elt_block (NULL);
706 write_exp_elt_sym (sym);
707 write_exp_elt_opcode (OP_VAR_VALUE);
711 msymbol = lookup_minimal_symbol (name, NULL, NULL);
713 write_exp_msymbol (msymbol);
714 else if (!have_full_symbols ()
715 && !have_partial_symbols ())
716 error (_("No symbol table is loaded. "
717 "Use the \"file\" command."));
719 error (_("No symbol \"%s\" in current context."),
724 variable: name_not_typename
725 { struct symbol *sym = $1.sym;
729 if (symbol_read_needs_frame (sym))
731 if (innermost_block == 0
732 || contained_in (block_found,
734 innermost_block = block_found;
737 write_exp_elt_opcode (OP_VAR_VALUE);
738 /* We want to use the selected frame, not
739 another more inner frame which happens to
740 be in the same block. */
741 write_exp_elt_block (NULL);
742 write_exp_elt_sym (sym);
743 write_exp_elt_opcode (OP_VAR_VALUE);
744 current_type = sym->type; }
745 else if ($1.is_a_field_of_this)
747 struct value * this_val;
748 struct type * this_type;
749 /* Object pascal: it hangs off of `this'. Must
750 not inadvertently convert from a method call
752 if (innermost_block == 0
753 || contained_in (block_found,
755 innermost_block = block_found;
756 write_exp_elt_opcode (OP_THIS);
757 write_exp_elt_opcode (OP_THIS);
758 write_exp_elt_opcode (STRUCTOP_PTR);
759 write_exp_string ($1.stoken);
760 write_exp_elt_opcode (STRUCTOP_PTR);
761 /* We need type of this. */
762 this_val = value_of_this_silent (parse_language);
764 this_type = value_type (this_val);
768 current_type = lookup_struct_elt_type (
770 copy_name ($1.stoken), 0);
776 struct minimal_symbol *msymbol;
777 char *arg = copy_name ($1.stoken);
780 lookup_minimal_symbol (arg, NULL, NULL);
782 write_exp_msymbol (msymbol);
783 else if (!have_full_symbols ()
784 && !have_partial_symbols ())
785 error (_("No symbol table is loaded. "
786 "Use the \"file\" command."));
788 error (_("No symbol \"%s\" in current context."),
789 copy_name ($1.stoken));
798 /* We used to try to recognize more pointer to member types here, but
799 that didn't work (shift/reduce conflicts meant that these rules never
800 got executed). The problem is that
801 int (foo::bar::baz::bizzle)
802 is a function type but
803 int (foo::bar::baz::bizzle::*)
804 is a pointer to member type. Stroustrup loses again! */
809 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
811 { $$ = lookup_pointer_type ($2); }
815 { $$ = lookup_struct (copy_name ($2),
816 expression_context_block); }
818 { $$ = lookup_struct (copy_name ($2),
819 expression_context_block); }
820 /* "const" and "volatile" are curently ignored. A type qualifier
821 after the type is handled in the ptype rule. I think these could
825 name : NAME { $$ = $1.stoken; }
826 | BLOCKNAME { $$ = $1.stoken; }
827 | TYPENAME { $$ = $1.stoken; }
828 | NAME_OR_INT { $$ = $1.stoken; }
831 name_not_typename : NAME
833 /* These would be useful if name_not_typename was useful, but it is just
834 a fake for "variable", so these cause reduce/reduce conflicts because
835 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
836 =exp) or just an exp. If name_not_typename was ever used in an lvalue
837 context where only a name could occur, this might be useful.
844 /* Take care of parsing a number (anything that starts with a digit).
845 Set yylval and return the token type; update lexptr.
846 LEN is the number of characters in it. */
848 /*** Needs some error checking for the float case ***/
851 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
853 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
854 here, and we do kind of silly things like cast to unsigned. */
861 int base = input_radix;
864 /* Number of "L" suffixes encountered. */
867 /* We have found a "L" or "U" suffix. */
868 int found_suffix = 0;
871 struct type *signed_type;
872 struct type *unsigned_type;
876 if (! parse_c_float (parse_gdbarch, p, len,
877 &putithere->typed_val_float.dval,
878 &putithere->typed_val_float.type))
883 /* Handle base-switching prefixes 0x, 0t, 0d, 0. */
917 if (c >= 'A' && c <= 'Z')
919 if (c != 'l' && c != 'u')
921 if (c >= '0' && c <= '9')
929 if (base > 10 && c >= 'a' && c <= 'f')
933 n += i = c - 'a' + 10;
946 return ERROR; /* Char not a digit */
949 return ERROR; /* Invalid digit in this base. */
951 /* Portably test for overflow (only works for nonzero values, so make
952 a second check for zero). FIXME: Can't we just make n and prevn
953 unsigned and avoid this? */
954 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
955 unsigned_p = 1; /* Try something unsigned. */
957 /* Portably test for unsigned overflow.
958 FIXME: This check is wrong; for example it doesn't find overflow
959 on 0x123456789 when LONGEST is 32 bits. */
960 if (c != 'l' && c != 'u' && n != 0)
962 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
963 error (_("Numeric constant too large."));
968 /* An integer constant is an int, a long, or a long long. An L
969 suffix forces it to be long; an LL suffix forces it to be long
970 long. If not forced to a larger size, it gets the first type of
971 the above that it fits in. To figure out whether it fits, we
972 shift it right and see whether anything remains. Note that we
973 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
974 operation, because many compilers will warn about such a shift
975 (which always produces a zero result). Sometimes gdbarch_int_bit
976 or gdbarch_long_bit will be that big, sometimes not. To deal with
977 the case where it is we just always shift the value more than
978 once, with fewer bits each time. */
980 un = (ULONGEST)n >> 2;
982 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
984 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
986 /* A large decimal (not hex or octal) constant (between INT_MAX
987 and UINT_MAX) is a long or unsigned long, according to ANSI,
988 never an unsigned int, but this code treats it as unsigned
989 int. This probably should be fixed. GCC gives a warning on
992 unsigned_type = parse_type->builtin_unsigned_int;
993 signed_type = parse_type->builtin_int;
996 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
998 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
999 unsigned_type = parse_type->builtin_unsigned_long;
1000 signed_type = parse_type->builtin_long;
1005 if (sizeof (ULONGEST) * HOST_CHAR_BIT
1006 < gdbarch_long_long_bit (parse_gdbarch))
1007 /* A long long does not fit in a LONGEST. */
1008 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1010 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
1011 high_bit = (ULONGEST) 1 << shift;
1012 unsigned_type = parse_type->builtin_unsigned_long_long;
1013 signed_type = parse_type->builtin_long_long;
1016 putithere->typed_val_int.val = n;
1018 /* If the high bit of the worked out type is set then this number
1019 has to be unsigned. */
1021 if (unsigned_p || (n & high_bit))
1023 putithere->typed_val_int.type = unsigned_type;
1027 putithere->typed_val_int.type = signed_type;
1036 struct type *stored;
1037 struct type_push *next;
1040 static struct type_push *tp_top = NULL;
1043 push_current_type (void)
1045 struct type_push *tpnew;
1046 tpnew = (struct type_push *) malloc (sizeof (struct type_push));
1047 tpnew->next = tp_top;
1048 tpnew->stored = current_type;
1049 current_type = NULL;
1054 pop_current_type (void)
1056 struct type_push *tp = tp_top;
1059 current_type = tp->stored;
1069 enum exp_opcode opcode;
1072 static const struct token tokentab3[] =
1074 {"shr", RSH, BINOP_END},
1075 {"shl", LSH, BINOP_END},
1076 {"and", ANDAND, BINOP_END},
1077 {"div", DIV, BINOP_END},
1078 {"not", NOT, BINOP_END},
1079 {"mod", MOD, BINOP_END},
1080 {"inc", INCREMENT, BINOP_END},
1081 {"dec", DECREMENT, BINOP_END},
1082 {"xor", XOR, BINOP_END}
1085 static const struct token tokentab2[] =
1087 {"or", OR, BINOP_END},
1088 {"<>", NOTEQUAL, BINOP_END},
1089 {"<=", LEQ, BINOP_END},
1090 {">=", GEQ, BINOP_END},
1091 {":=", ASSIGN, BINOP_END},
1092 {"::", COLONCOLON, BINOP_END} };
1094 /* Allocate uppercased var: */
1095 /* make an uppercased copy of tokstart. */
1097 uptok (char *tokstart, int namelen)
1100 char *uptokstart = (char *)malloc(namelen+1);
1101 for (i = 0;i <= namelen;i++)
1103 if ((tokstart[i]>='a' && tokstart[i]<='z'))
1104 uptokstart[i] = tokstart[i]-('a'-'A');
1106 uptokstart[i] = tokstart[i];
1108 uptokstart[namelen]='\0';
1112 /* This is set if the previously-returned token was a structure
1113 operator '.'. This is used only when parsing to
1114 do field name completion. */
1115 static int last_was_structop;
1117 /* Read one token, getting characters through lexptr. */
1128 int explen, tempbufindex;
1129 static char *tempbuf;
1130 static int tempbufsize;
1131 int saw_structop = last_was_structop;
1133 last_was_structop = 0;
1136 prev_lexptr = lexptr;
1139 explen = strlen (lexptr);
1140 /* See if it is a special token of length 3. */
1142 for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
1143 if (strncasecmp (tokstart, tokentab3[i].operator, 3) == 0
1144 && (!isalpha (tokentab3[i].operator[0]) || explen == 3
1145 || (!isalpha (tokstart[3])
1146 && !isdigit (tokstart[3]) && tokstart[3] != '_')))
1149 yylval.opcode = tokentab3[i].opcode;
1150 return tokentab3[i].token;
1153 /* See if it is a special token of length 2. */
1155 for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
1156 if (strncasecmp (tokstart, tokentab2[i].operator, 2) == 0
1157 && (!isalpha (tokentab2[i].operator[0]) || explen == 2
1158 || (!isalpha (tokstart[2])
1159 && !isdigit (tokstart[2]) && tokstart[2] != '_')))
1162 yylval.opcode = tokentab2[i].opcode;
1163 return tokentab2[i].token;
1166 switch (c = *tokstart)
1169 if (saw_structop && search_field)
1181 /* We either have a character constant ('0' or '\177' for example)
1182 or we have a quoted symbol reference ('foo(int,int)' in object pascal
1187 c = parse_escape (parse_gdbarch, &lexptr);
1189 error (_("Empty character constant."));
1191 yylval.typed_val_int.val = c;
1192 yylval.typed_val_int.type = parse_type->builtin_char;
1197 namelen = skip_quoted (tokstart) - tokstart;
1200 lexptr = tokstart + namelen;
1201 if (lexptr[-1] != '\'')
1202 error (_("Unmatched single quote."));
1205 uptokstart = uptok(tokstart,namelen);
1208 error (_("Invalid character constant."));
1218 if (paren_depth == 0)
1225 if (comma_terminates && paren_depth == 0)
1231 /* Might be a floating point number. */
1232 if (lexptr[1] < '0' || lexptr[1] > '9')
1235 last_was_structop = 1;
1236 goto symbol; /* Nope, must be a symbol. */
1239 /* FALL THRU into number case. */
1252 /* It's a number. */
1253 int got_dot = 0, got_e = 0, toktype;
1255 int hex = input_radix > 10;
1257 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1262 else if (c == '0' && (p[1]=='t' || p[1]=='T'
1263 || p[1]=='d' || p[1]=='D'))
1271 /* This test includes !hex because 'e' is a valid hex digit
1272 and thus does not indicate a floating point number when
1273 the radix is hex. */
1274 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1275 got_dot = got_e = 1;
1276 /* This test does not include !hex, because a '.' always indicates
1277 a decimal floating point number regardless of the radix. */
1278 else if (!got_dot && *p == '.')
1280 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1281 && (*p == '-' || *p == '+'))
1282 /* This is the sign of the exponent, not the end of the
1285 /* We will take any letters or digits. parse_number will
1286 complain if past the radix, or if L or U are not final. */
1287 else if ((*p < '0' || *p > '9')
1288 && ((*p < 'a' || *p > 'z')
1289 && (*p < 'A' || *p > 'Z')))
1292 toktype = parse_number (tokstart,
1293 p - tokstart, got_dot | got_e, &yylval);
1294 if (toktype == ERROR)
1296 char *err_copy = (char *) alloca (p - tokstart + 1);
1298 memcpy (err_copy, tokstart, p - tokstart);
1299 err_copy[p - tokstart] = 0;
1300 error (_("Invalid number \"%s\"."), err_copy);
1331 /* Build the gdb internal form of the input string in tempbuf,
1332 translating any standard C escape forms seen. Note that the
1333 buffer is null byte terminated *only* for the convenience of
1334 debugging gdb itself and printing the buffer contents when
1335 the buffer contains no embedded nulls. Gdb does not depend
1336 upon the buffer being null byte terminated, it uses the length
1337 string instead. This allows gdb to handle C strings (as well
1338 as strings in other languages) with embedded null bytes. */
1340 tokptr = ++tokstart;
1344 /* Grow the static temp buffer if necessary, including allocating
1345 the first one on demand. */
1346 if (tempbufindex + 1 >= tempbufsize)
1348 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1355 /* Do nothing, loop will terminate. */
1359 c = parse_escape (parse_gdbarch, &tokptr);
1364 tempbuf[tempbufindex++] = c;
1367 tempbuf[tempbufindex++] = *tokptr++;
1370 } while ((*tokptr != '"') && (*tokptr != '\0'));
1371 if (*tokptr++ != '"')
1373 error (_("Unterminated string in expression."));
1375 tempbuf[tempbufindex] = '\0'; /* See note above. */
1376 yylval.sval.ptr = tempbuf;
1377 yylval.sval.length = tempbufindex;
1382 if (!(c == '_' || c == '$'
1383 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1384 /* We must have come across a bad character (e.g. ';'). */
1385 error (_("Invalid character '%c' in expression."), c);
1387 /* It's a name. See how long it is. */
1389 for (c = tokstart[namelen];
1390 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1391 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1393 /* Template parameter lists are part of the name.
1394 FIXME: This mishandles `print $a<4&&$a>3'. */
1398 int nesting_level = 1;
1399 while (tokstart[++i])
1401 if (tokstart[i] == '<')
1403 else if (tokstart[i] == '>')
1405 if (--nesting_level == 0)
1409 if (tokstart[i] == '>')
1415 /* do NOT uppercase internals because of registers !!! */
1416 c = tokstart[++namelen];
1419 uptokstart = uptok(tokstart,namelen);
1421 /* The token "if" terminates the expression and is NOT
1422 removed from the input stream. */
1423 if (namelen == 2 && uptokstart[0] == 'I' && uptokstart[1] == 'F')
1433 /* Catch specific keywords. Should be done with a data structure. */
1437 if (strcmp (uptokstart, "OBJECT") == 0)
1442 if (strcmp (uptokstart, "RECORD") == 0)
1447 if (strcmp (uptokstart, "SIZEOF") == 0)
1454 if (strcmp (uptokstart, "CLASS") == 0)
1459 if (strcmp (uptokstart, "FALSE") == 0)
1463 return FALSEKEYWORD;
1467 if (strcmp (uptokstart, "TRUE") == 0)
1473 if (strcmp (uptokstart, "SELF") == 0)
1475 /* Here we search for 'this' like
1476 inserted in FPC stabs debug info. */
1477 static const char this_name[] = "this";
1479 if (lookup_symbol (this_name, expression_context_block,
1480 VAR_DOMAIN, (int *) NULL))
1491 yylval.sval.ptr = tokstart;
1492 yylval.sval.length = namelen;
1494 if (*tokstart == '$')
1497 /* $ is the normal prefix for pascal hexadecimal values
1498 but this conflicts with the GDB use for debugger variables
1499 so in expression to enter hexadecimal values
1500 we still need to use C syntax with 0xff */
1501 write_dollar_variable (yylval.sval);
1502 c = tokstart[namelen];
1503 tokstart[namelen] = 0;
1504 intvar = lookup_only_internalvar (++tokstart);
1506 tokstart[namelen] = c;
1511 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1512 functions or symtabs. If this is not so, then ...
1513 Use token-type TYPENAME for symbols that happen to be defined
1514 currently as names of types; NAME for other symbols.
1515 The caller is not constrained to care about the distinction. */
1517 char *tmp = copy_name (yylval.sval);
1519 int is_a_field_of_this = 0;
1524 if (search_field && current_type)
1525 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1526 if (is_a_field || in_parse_field)
1529 sym = lookup_symbol (tmp, expression_context_block,
1530 VAR_DOMAIN, &is_a_field_of_this);
1531 /* second chance uppercased (as Free Pascal does). */
1532 if (!sym && !is_a_field_of_this && !is_a_field)
1534 for (i = 0; i <= namelen; i++)
1536 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1537 tmp[i] -= ('a'-'A');
1539 if (search_field && current_type)
1540 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1541 if (is_a_field || in_parse_field)
1544 sym = lookup_symbol (tmp, expression_context_block,
1545 VAR_DOMAIN, &is_a_field_of_this);
1546 if (sym || is_a_field_of_this || is_a_field)
1547 for (i = 0; i <= namelen; i++)
1549 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
1550 tokstart[i] -= ('a'-'A');
1553 /* Third chance Capitalized (as GPC does). */
1554 if (!sym && !is_a_field_of_this && !is_a_field)
1556 for (i = 0; i <= namelen; i++)
1560 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1561 tmp[i] -= ('a'-'A');
1564 if ((tmp[i] >= 'A' && tmp[i] <= 'Z'))
1565 tmp[i] -= ('A'-'a');
1567 if (search_field && current_type)
1568 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1569 if (is_a_field || in_parse_field)
1572 sym = lookup_symbol (tmp, expression_context_block,
1573 VAR_DOMAIN, &is_a_field_of_this);
1574 if (sym || is_a_field_of_this || is_a_field)
1575 for (i = 0; i <= namelen; i++)
1579 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
1580 tokstart[i] -= ('a'-'A');
1583 if ((tokstart[i] >= 'A' && tokstart[i] <= 'Z'))
1584 tokstart[i] -= ('A'-'a');
1590 tempbuf = (char *) realloc (tempbuf, namelen + 1);
1591 strncpy (tempbuf, tokstart, namelen); tempbuf [namelen] = 0;
1592 yylval.sval.ptr = tempbuf;
1593 yylval.sval.length = namelen;
1597 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1598 no psymtabs (coff, xcoff, or some future change to blow away the
1599 psymtabs once once symbols are read). */
1600 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1601 || lookup_symtab (tmp))
1603 yylval.ssym.sym = sym;
1604 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1608 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1611 /* Despite the following flaw, we need to keep this code enabled.
1612 Because we can get called from check_stub_method, if we don't
1613 handle nested types then it screws many operations in any
1614 program which uses nested types. */
1615 /* In "A::x", if x is a member function of A and there happens
1616 to be a type (nested or not, since the stabs don't make that
1617 distinction) named x, then this code incorrectly thinks we
1618 are dealing with nested types rather than a member function. */
1622 struct symbol *best_sym;
1624 /* Look ahead to detect nested types. This probably should be
1625 done in the grammar, but trying seemed to introduce a lot
1626 of shift/reduce and reduce/reduce conflicts. It's possible
1627 that it could be done, though. Or perhaps a non-grammar, but
1628 less ad hoc, approach would work well. */
1630 /* Since we do not currently have any way of distinguishing
1631 a nested type from a non-nested one (the stabs don't tell
1632 us whether a type is nested), we just ignore the
1639 /* Skip whitespace. */
1640 while (*p == ' ' || *p == '\t' || *p == '\n')
1642 if (*p == ':' && p[1] == ':')
1644 /* Skip the `::'. */
1646 /* Skip whitespace. */
1647 while (*p == ' ' || *p == '\t' || *p == '\n')
1650 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1651 || (*p >= 'a' && *p <= 'z')
1652 || (*p >= 'A' && *p <= 'Z'))
1656 struct symbol *cur_sym;
1657 /* As big as the whole rest of the expression, which is
1658 at least big enough. */
1659 char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
1663 memcpy (tmp1, tmp, strlen (tmp));
1664 tmp1 += strlen (tmp);
1665 memcpy (tmp1, "::", 2);
1667 memcpy (tmp1, namestart, p - namestart);
1668 tmp1[p - namestart] = '\0';
1669 cur_sym = lookup_symbol (ncopy, expression_context_block,
1670 VAR_DOMAIN, (int *) NULL);
1673 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1691 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1693 yylval.tsym.type = SYMBOL_TYPE (sym);
1699 = language_lookup_primitive_type_by_name (parse_language,
1700 parse_gdbarch, tmp);
1701 if (yylval.tsym.type != NULL)
1707 /* Input names that aren't symbols but ARE valid hex numbers,
1708 when the input radix permits them, can be names or numbers
1709 depending on the parse. Note we support radixes > 16 here. */
1711 && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1712 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1714 YYSTYPE newlval; /* Its value is ignored. */
1715 hextype = parse_number (tokstart, namelen, 0, &newlval);
1718 yylval.ssym.sym = sym;
1719 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1726 /* Any other kind of symbol. */
1727 yylval.ssym.sym = sym;
1728 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1737 lexptr = prev_lexptr;
1739 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);