1 /* YACC parser for D expressions, for GDB.
3 Copyright (C) 2014-2015 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 3 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, see <http://www.gnu.org/licenses/>. */
20 /* This file is derived from c-exp.y, jv-exp.y. */
22 /* Parse a D expression from text in a string,
23 and return the result as a struct expression pointer.
24 That structure contains arithmetic operations in reverse polish,
25 with constants represented by operations that are followed by special data.
26 See expression.h for the details of the format.
27 What is important here is that it can be built up sequentially
28 during the process of parsing; the lower levels of the tree always
29 come first in the result.
31 Note that malloc's and realloc's in this file are transformed to
32 xmalloc and xrealloc respectively by the same sed command in the
33 makefile that remaps any other malloc/realloc inserted by the parser
34 generator. Doing this with #defines and trying to control the interaction
35 with include files (<malloc.h> and <stdlib.h> for example) just became
36 too messy, particularly when such includes can be inserted at random
37 times by the parser generator. */
43 #include "expression.h"
45 #include "parser-defs.h"
49 #include "bfd.h" /* Required by objfiles.h. */
50 #include "symfile.h" /* Required by objfiles.h. */
51 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
55 #define parse_type(ps) builtin_type (parse_gdbarch (ps))
56 #define parse_d_type(ps) builtin_d_type (parse_gdbarch (ps))
58 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
59 as well as gratuitiously global symbol names, so we can have multiple
60 yacc generated parsers in gdb. Note that these are only the variables
61 produced by yacc. If other parser generators (bison, byacc, etc) produce
62 additional global names that conflict at link time, then those parser
63 generators need to be fixed instead of adding those names to this list. */
65 #define yymaxdepth d_maxdepth
66 #define yyparse d_parse_internal
68 #define yyerror d_error
71 #define yydebug d_debug
80 #define yyerrflag d_errflag
81 #define yynerrs d_nerrs
86 #define yystate d_state
92 #define yyreds d_reds /* With YYDEBUG defined */
93 #define yytoks d_toks /* With YYDEBUG defined */
94 #define yyname d_name /* With YYDEBUG defined */
95 #define yyrule d_rule /* With YYDEBUG defined */
98 #define yydefre d_yydefred
99 #define yydgoto d_yydgoto
100 #define yysindex d_yysindex
101 #define yyrindex d_yyrindex
102 #define yygindex d_yygindex
103 #define yytable d_yytable
104 #define yycheck d_yycheck
106 #define yysslim d_yysslim
107 #define yyssp d_yyssp
108 #define yystacksize d_yystacksize
110 #define yyvsp d_yyvsp
113 #define YYDEBUG 1 /* Default to yydebug support */
116 #define YYFPRINTF parser_fprintf
118 /* The state of the parser, used internally when we are parsing the
121 static struct parser_state *pstate = NULL;
125 static int yylex (void);
127 void yyerror (char *);
131 /* Although the yacc "value" of an expression is not used,
132 since the result is stored in the structure being created,
133 other node types do have values. */
147 struct typed_stoken tsval;
150 struct symtoken ssym;
154 enum exp_opcode opcode;
155 struct stoken_vector svec;
159 /* YYSTYPE gets defined by %union */
160 static int parse_number (struct parser_state *, const char *,
161 int, int, YYSTYPE *);
164 %token <sval> IDENTIFIER UNKNOWN_NAME
165 %token <tsym> TYPENAME
166 %token <voidval> COMPLETE
168 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
169 but which would parse as a valid number in the current input radix.
170 E.g. "c" when input_radix==16. Depending on the parse, it will be
171 turned into a name or into a number. */
173 %token <sval> NAME_OR_INT
175 %token <typed_val_int> INTEGER_LITERAL
176 %token <typed_val_float> FLOAT_LITERAL
177 %token <tsval> CHARACTER_LITERAL
178 %token <tsval> STRING_LITERAL
180 %type <svec> StringExp
181 %type <tval> BasicType TypeExp
182 %type <sval> IdentifierExp
183 %type <ival> ArrayLiteral
188 /* Keywords that have a constant value. */
189 %token TRUE_KEYWORD FALSE_KEYWORD NULL_KEYWORD
190 /* Class 'super' accessor. */
193 %token CAST_KEYWORD SIZEOF_KEYWORD
194 %token TYPEOF_KEYWORD TYPEID_KEYWORD
196 /* Comparison keywords. */
197 /* Type storage classes. */
198 %token IMMUTABLE_KEYWORD CONST_KEYWORD SHARED_KEYWORD
199 /* Non-scalar type keywords. */
200 %token STRUCT_KEYWORD UNION_KEYWORD
201 %token CLASS_KEYWORD INTERFACE_KEYWORD
202 %token ENUM_KEYWORD TEMPLATE_KEYWORD
203 %token DELEGATE_KEYWORD FUNCTION_KEYWORD
205 %token <sval> DOLLAR_VARIABLE
207 %token <opcode> ASSIGN_MODIFY
210 %right '=' ASSIGN_MODIFY
217 %left EQUAL NOTEQUAL '<' '>' LEQ GEQ
222 %left IDENTITY NOTIDENTITY
223 %right INCREMENT DECREMENT
235 /* Expressions, including the comma operator. */
243 | AssignExpression ',' CommaExpression
244 { write_exp_elt_opcode (pstate, BINOP_COMMA); }
248 ConditionalExpression
249 | ConditionalExpression '=' AssignExpression
250 { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
251 | ConditionalExpression ASSIGN_MODIFY AssignExpression
252 { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
253 write_exp_elt_opcode (pstate, $2);
254 write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY); }
257 ConditionalExpression:
259 | OrOrExpression '?' Expression ':' ConditionalExpression
260 { write_exp_elt_opcode (pstate, TERNOP_COND); }
265 | OrOrExpression OROR AndAndExpression
266 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
271 | AndAndExpression ANDAND OrExpression
272 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
277 | OrExpression '|' XorExpression
278 { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
283 | XorExpression '^' AndExpression
284 { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
289 | AndExpression '&' CmpExpression
290 { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
301 ShiftExpression EQUAL ShiftExpression
302 { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
303 | ShiftExpression NOTEQUAL ShiftExpression
304 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
308 ShiftExpression IDENTITY ShiftExpression
309 { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
310 | ShiftExpression NOTIDENTITY ShiftExpression
311 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
315 ShiftExpression '<' ShiftExpression
316 { write_exp_elt_opcode (pstate, BINOP_LESS); }
317 | ShiftExpression LEQ ShiftExpression
318 { write_exp_elt_opcode (pstate, BINOP_LEQ); }
319 | ShiftExpression '>' ShiftExpression
320 { write_exp_elt_opcode (pstate, BINOP_GTR); }
321 | ShiftExpression GEQ ShiftExpression
322 { write_exp_elt_opcode (pstate, BINOP_GEQ); }
327 | ShiftExpression LSH AddExpression
328 { write_exp_elt_opcode (pstate, BINOP_LSH); }
329 | ShiftExpression RSH AddExpression
330 { write_exp_elt_opcode (pstate, BINOP_RSH); }
335 | AddExpression '+' MulExpression
336 { write_exp_elt_opcode (pstate, BINOP_ADD); }
337 | AddExpression '-' MulExpression
338 { write_exp_elt_opcode (pstate, BINOP_SUB); }
339 | AddExpression '~' MulExpression
340 { write_exp_elt_opcode (pstate, BINOP_CONCAT); }
345 | MulExpression '*' UnaryExpression
346 { write_exp_elt_opcode (pstate, BINOP_MUL); }
347 | MulExpression '/' UnaryExpression
348 { write_exp_elt_opcode (pstate, BINOP_DIV); }
349 | MulExpression '%' UnaryExpression
350 { write_exp_elt_opcode (pstate, BINOP_REM); }
354 { write_exp_elt_opcode (pstate, UNOP_ADDR); }
355 | INCREMENT UnaryExpression
356 { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
357 | DECREMENT UnaryExpression
358 { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); }
359 | '*' UnaryExpression
360 { write_exp_elt_opcode (pstate, UNOP_IND); }
361 | '-' UnaryExpression
362 { write_exp_elt_opcode (pstate, UNOP_NEG); }
363 | '+' UnaryExpression
364 { write_exp_elt_opcode (pstate, UNOP_PLUS); }
365 | '!' UnaryExpression
366 { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
367 | '~' UnaryExpression
368 { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); }
374 CAST_KEYWORD '(' TypeExp ')' UnaryExpression
375 { write_exp_elt_opcode (pstate, UNOP_CAST);
376 write_exp_elt_type (pstate, $3);
377 write_exp_elt_opcode (pstate, UNOP_CAST); }
378 /* C style cast is illegal D, but is still recognised in
379 the grammar, so we keep this around for convenience. */
380 | '(' TypeExp ')' UnaryExpression
381 { write_exp_elt_opcode (pstate, UNOP_CAST);
382 write_exp_elt_type (pstate, $2);
383 write_exp_elt_opcode (pstate, UNOP_CAST); }
388 | PostfixExpression HATHAT UnaryExpression
389 { write_exp_elt_opcode (pstate, BINOP_EXP); }
394 | PostfixExpression '.' COMPLETE
396 mark_struct_expression (pstate);
397 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
400 write_exp_string (pstate, s);
401 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
402 | PostfixExpression '.' IDENTIFIER
403 { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
404 write_exp_string (pstate, $3);
405 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
406 | PostfixExpression '.' IDENTIFIER COMPLETE
407 { mark_struct_expression (pstate);
408 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
409 write_exp_string (pstate, $3);
410 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
411 | PostfixExpression INCREMENT
412 { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); }
413 | PostfixExpression DECREMENT
414 { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); }
423 | ArgumentList ',' AssignExpression
434 PostfixExpression '('
435 { start_arglist (); }
437 { write_exp_elt_opcode (pstate, OP_FUNCALL);
438 write_exp_elt_longcst (pstate, (LONGEST) end_arglist ());
439 write_exp_elt_opcode (pstate, OP_FUNCALL); }
443 PostfixExpression '[' ArgumentList ']'
444 { if (arglist_len > 0)
446 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
447 write_exp_elt_longcst (pstate, (LONGEST) arglist_len);
448 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
451 write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT);
456 PostfixExpression '[' ']'
457 { /* Do nothing. */ }
458 | PostfixExpression '[' AssignExpression DOTDOT AssignExpression ']'
459 { write_exp_elt_opcode (pstate, TERNOP_SLICE); }
464 { /* Do nothing. */ }
466 { struct bound_minimal_symbol msymbol;
467 char *copy = copy_name ($1);
468 struct field_of_this_result is_a_field_of_this;
469 struct block_symbol sym;
471 /* Handle VAR, which could be local or global. */
472 sym = lookup_symbol (copy, expression_context_block, VAR_DOMAIN,
473 &is_a_field_of_this);
474 if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
476 if (symbol_read_needs_frame (sym.symbol))
478 if (innermost_block == 0
479 || contained_in (sym.block, innermost_block))
480 innermost_block = sym.block;
483 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
484 /* We want to use the selected frame, not another more inner frame
485 which happens to be in the same block. */
486 write_exp_elt_block (pstate, NULL);
487 write_exp_elt_sym (pstate, sym.symbol);
488 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
490 else if (is_a_field_of_this.type != NULL)
492 /* It hangs off of `this'. Must not inadvertently convert from a
493 method call to data ref. */
494 if (innermost_block == 0
495 || contained_in (sym.block, innermost_block))
496 innermost_block = sym.block;
497 write_exp_elt_opcode (pstate, OP_THIS);
498 write_exp_elt_opcode (pstate, OP_THIS);
499 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
500 write_exp_string (pstate, $1);
501 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
505 /* Lookup foreign name in global static symbols. */
506 msymbol = lookup_bound_minimal_symbol (copy);
507 if (msymbol.minsym != NULL)
508 write_exp_msymbol (pstate, msymbol);
509 else if (!have_full_symbols () && !have_partial_symbols ())
510 error (_("No symbol table is loaded. Use the \"file\" command"));
512 error (_("No symbol \"%s\" in current context."), copy);
515 | TypeExp '.' IdentifierExp
516 { struct type *type = check_typedef ($1);
518 /* Check if the qualified name is in the global
519 context. However if the symbol has not already
520 been resolved, it's not likely to be found. */
521 if (TYPE_CODE (type) == TYPE_CODE_MODULE)
523 struct bound_minimal_symbol msymbol;
524 struct block_symbol sym;
525 const char *typename = TYPE_SAFE_NAME (type);
526 int typename_len = strlen (typename);
529 name = xstrprintf ("%.*s.%.*s",
530 typename_len, typename,
532 make_cleanup (xfree, name);
535 lookup_symbol (name, (const struct block *) NULL,
539 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
540 write_exp_elt_block (pstate, sym.block);
541 write_exp_elt_sym (pstate, sym.symbol);
542 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
546 msymbol = lookup_bound_minimal_symbol (name);
547 if (msymbol.minsym != NULL)
548 write_exp_msymbol (pstate, msymbol);
549 else if (!have_full_symbols () && !have_partial_symbols ())
550 error (_("No symbol table is loaded. Use the \"file\" command."));
552 error (_("No symbol \"%s\" in current context."), name);
555 /* Check if the qualified name resolves as a member
556 of an aggregate or an enum type. */
557 if (!(TYPE_CODE (type) == TYPE_CODE_STRUCT
558 || TYPE_CODE (type) == TYPE_CODE_UNION
559 || TYPE_CODE (type) == TYPE_CODE_ENUM))
560 error (_("`%s' is not defined as an aggregate type."),
561 TYPE_SAFE_NAME (type));
563 write_exp_elt_opcode (pstate, OP_SCOPE);
564 write_exp_elt_type (pstate, type);
565 write_exp_string (pstate, $3);
566 write_exp_elt_opcode (pstate, OP_SCOPE);
569 { write_dollar_variable (pstate, $1); }
572 parse_number (pstate, $1.ptr, $1.length, 0, &val);
573 write_exp_elt_opcode (pstate, OP_LONG);
574 write_exp_elt_type (pstate, val.typed_val_int.type);
575 write_exp_elt_longcst (pstate,
576 (LONGEST) val.typed_val_int.val);
577 write_exp_elt_opcode (pstate, OP_LONG); }
579 { struct type *type = parse_d_type (pstate)->builtin_void;
580 type = lookup_pointer_type (type);
581 write_exp_elt_opcode (pstate, OP_LONG);
582 write_exp_elt_type (pstate, type);
583 write_exp_elt_longcst (pstate, (LONGEST) 0);
584 write_exp_elt_opcode (pstate, OP_LONG); }
586 { write_exp_elt_opcode (pstate, OP_BOOL);
587 write_exp_elt_longcst (pstate, (LONGEST) 1);
588 write_exp_elt_opcode (pstate, OP_BOOL); }
590 { write_exp_elt_opcode (pstate, OP_BOOL);
591 write_exp_elt_longcst (pstate, (LONGEST) 0);
592 write_exp_elt_opcode (pstate, OP_BOOL); }
594 { write_exp_elt_opcode (pstate, OP_LONG);
595 write_exp_elt_type (pstate, $1.type);
596 write_exp_elt_longcst (pstate, (LONGEST)($1.val));
597 write_exp_elt_opcode (pstate, OP_LONG); }
599 { write_exp_elt_opcode (pstate, OP_DOUBLE);
600 write_exp_elt_type (pstate, $1.type);
601 write_exp_elt_dblcst (pstate, $1.dval);
602 write_exp_elt_opcode (pstate, OP_DOUBLE); }
604 { struct stoken_vector vec;
607 write_exp_string_vector (pstate, $1.type, &vec); }
610 write_exp_string_vector (pstate, 0, &$1);
611 for (i = 0; i < $1.len; ++i)
612 free ($1.tokens[i].ptr);
615 { write_exp_elt_opcode (pstate, OP_ARRAY);
616 write_exp_elt_longcst (pstate, (LONGEST) 0);
617 write_exp_elt_longcst (pstate, (LONGEST) $1 - 1);
618 write_exp_elt_opcode (pstate, OP_ARRAY); }
622 '[' ArgumentList_opt ']'
623 { $$ = arglist_len; }
632 { /* We copy the string here, and not in the
633 lexer, to guarantee that we do not leak a
634 string. Note that we follow the
635 NUL-termination convention of the
637 struct typed_stoken *vec = XNEW (struct typed_stoken);
642 vec->length = $1.length;
643 vec->ptr = malloc ($1.length + 1);
644 memcpy (vec->ptr, $1.ptr, $1.length + 1);
646 | StringExp STRING_LITERAL
647 { /* Note that we NUL-terminate here, but just
651 $$.tokens = realloc ($$.tokens,
652 $$.len * sizeof (struct typed_stoken));
654 p = malloc ($2.length + 1);
655 memcpy (p, $2.ptr, $2.length + 1);
657 $$.tokens[$$.len - 1].type = $2.type;
658 $$.tokens[$$.len - 1].length = $2.length;
659 $$.tokens[$$.len - 1].ptr = p;
665 { /* Do nothing. */ }
667 { write_exp_elt_opcode (pstate, OP_TYPE);
668 write_exp_elt_type (pstate, $1);
669 write_exp_elt_opcode (pstate, OP_TYPE); }
670 | BasicType BasicType2
671 { $$ = follow_types ($1);
672 write_exp_elt_opcode (pstate, OP_TYPE);
673 write_exp_elt_type (pstate, $$);
674 write_exp_elt_opcode (pstate, OP_TYPE);
680 { push_type (tp_pointer); }
682 { push_type (tp_pointer); }
683 | '[' INTEGER_LITERAL ']'
684 { push_type_int ($2.val);
685 push_type (tp_array); }
686 | '[' INTEGER_LITERAL ']' BasicType2
687 { push_type_int ($2.val);
688 push_type (tp_array); }
698 /* Take care of parsing a number (anything that starts with a digit).
699 Set yylval and return the token type; update lexptr.
700 LEN is the number of characters in it. */
702 /*** Needs some error checking for the float case ***/
705 parse_number (struct parser_state *ps, const char *p,
706 int len, int parsed_float, YYSTYPE *putithere)
714 int base = input_radix;
718 /* We have found a "L" or "U" suffix. */
719 int found_suffix = 0;
722 struct type *signed_type;
723 struct type *unsigned_type;
727 const struct builtin_d_type *builtin_d_types;
732 /* Strip out all embedded '_' before passing to parse_float. */
733 s = (char *) alloca (len + 1);
744 if (! parse_float (s, len, &putithere->typed_val_float.dval, &suffix))
747 suffix_len = s + len - suffix;
751 putithere->typed_val_float.type
752 = parse_d_type (ps)->builtin_double;
754 else if (suffix_len == 1)
756 /* Check suffix for `f', `l', or `i' (float, real, or idouble). */
757 if (tolower (*suffix) == 'f')
759 putithere->typed_val_float.type
760 = parse_d_type (ps)->builtin_float;
762 else if (tolower (*suffix) == 'l')
764 putithere->typed_val_float.type
765 = parse_d_type (ps)->builtin_real;
767 else if (tolower (*suffix) == 'i')
769 putithere->typed_val_float.type
770 = parse_d_type (ps)->builtin_idouble;
775 else if (suffix_len == 2)
777 /* Check suffix for `fi' or `li' (ifloat or ireal). */
778 if (tolower (suffix[0]) == 'f' && tolower (suffix[1] == 'i'))
780 putithere->typed_val_float.type
781 = parse_d_type (ps)->builtin_ifloat;
783 else if (tolower (suffix[0]) == 'l' && tolower (suffix[1] == 'i'))
785 putithere->typed_val_float.type
786 = parse_d_type (ps)->builtin_ireal;
794 return FLOAT_LITERAL;
797 /* Handle base-switching prefixes 0x, 0b, 0 */
830 continue; /* Ignore embedded '_'. */
831 if (c >= 'A' && c <= 'Z')
833 if (c != 'l' && c != 'u')
835 if (c >= '0' && c <= '9')
843 if (base > 10 && c >= 'a' && c <= 'f')
847 n += i = c - 'a' + 10;
849 else if (c == 'l' && long_p == 0)
854 else if (c == 'u' && unsigned_p == 0)
860 return ERROR; /* Char not a digit */
863 return ERROR; /* Invalid digit in this base. */
864 /* Portably test for integer overflow. */
865 if (c != 'l' && c != 'u')
867 ULONGEST n2 = prevn * base;
868 if ((n2 / base != prevn) || (n2 + i < prevn))
869 error (_("Numeric constant too large."));
874 /* An integer constant is an int or a long. An L suffix forces it to
875 be long, and a U suffix forces it to be unsigned. To figure out
876 whether it fits, we shift it right and see whether anything remains.
877 Note that we can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or
878 more in one operation, because many compilers will warn about such a
879 shift (which always produces a zero result). To deal with the case
880 where it is we just always shift the value more than once, with fewer
882 un = (ULONGEST) n >> 2;
883 if (long_p == 0 && (un >> 30) == 0)
885 high_bit = ((ULONGEST) 1) << 31;
886 signed_type = parse_d_type (ps)->builtin_int;
887 /* For decimal notation, keep the sign of the worked out type. */
888 if (base == 10 && !unsigned_p)
889 unsigned_type = parse_d_type (ps)->builtin_long;
891 unsigned_type = parse_d_type (ps)->builtin_uint;
896 if (sizeof (ULONGEST) * HOST_CHAR_BIT < 64)
897 /* A long long does not fit in a LONGEST. */
898 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
901 high_bit = (ULONGEST) 1 << shift;
902 signed_type = parse_d_type (ps)->builtin_long;
903 unsigned_type = parse_d_type (ps)->builtin_ulong;
906 putithere->typed_val_int.val = n;
908 /* If the high bit of the worked out type is set then this number
909 has to be unsigned_type. */
910 if (unsigned_p || (n & high_bit))
911 putithere->typed_val_int.type = unsigned_type;
913 putithere->typed_val_int.type = signed_type;
915 return INTEGER_LITERAL;
918 /* Temporary obstack used for holding strings. */
919 static struct obstack tempbuf;
920 static int tempbuf_init;
922 /* Parse a string or character literal from TOKPTR. The string or
923 character may be wide or unicode. *OUTPTR is set to just after the
924 end of the literal in the input string. The resulting token is
925 stored in VALUE. This returns a token value, either STRING or
926 CHAR, depending on what was parsed. *HOST_CHARS is set to the
927 number of host characters in the literal. */
930 parse_string_or_char (const char *tokptr, const char **outptr,
931 struct typed_stoken *value, int *host_chars)
935 /* Build the gdb internal form of the input string in tempbuf. Note
936 that the buffer is null byte terminated *only* for the
937 convenience of debugging gdb itself and printing the buffer
938 contents when the buffer contains no embedded nulls. Gdb does
939 not depend upon the buffer being null byte terminated, it uses
940 the length string instead. This allows gdb to handle C strings
941 (as well as strings in other languages) with embedded null
947 obstack_free (&tempbuf, NULL);
948 obstack_init (&tempbuf);
950 /* Skip the quote. */
962 *host_chars += c_parse_escape (&tokptr, &tempbuf);
968 obstack_1grow (&tempbuf, c);
970 /* FIXME: this does the wrong thing with multi-byte host
971 characters. We could use mbrlen here, but that would
972 make "set host-charset" a bit less useful. */
977 if (*tokptr != quote)
979 if (quote == '"' || quote == '`')
980 error (_("Unterminated string in expression."));
982 error (_("Unmatched single quote."));
986 /* FIXME: should instead use own language string_type enum
987 and handle D-specific string suffixes here. */
989 value->type = C_CHAR;
991 value->type = C_STRING;
993 value->ptr = obstack_base (&tempbuf);
994 value->length = obstack_object_size (&tempbuf);
998 return quote == '\'' ? CHARACTER_LITERAL : STRING_LITERAL;
1005 enum exp_opcode opcode;
1008 static const struct token tokentab3[] =
1010 {"^^=", ASSIGN_MODIFY, BINOP_EXP},
1011 {"<<=", ASSIGN_MODIFY, BINOP_LSH},
1012 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1015 static const struct token tokentab2[] =
1017 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1018 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1019 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1020 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1021 {"%=", ASSIGN_MODIFY, BINOP_REM},
1022 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1023 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1024 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1025 {"++", INCREMENT, BINOP_END},
1026 {"--", DECREMENT, BINOP_END},
1027 {"&&", ANDAND, BINOP_END},
1028 {"||", OROR, BINOP_END},
1029 {"^^", HATHAT, BINOP_END},
1030 {"<<", LSH, BINOP_END},
1031 {">>", RSH, BINOP_END},
1032 {"==", EQUAL, BINOP_END},
1033 {"!=", NOTEQUAL, BINOP_END},
1034 {"<=", LEQ, BINOP_END},
1035 {">=", GEQ, BINOP_END},
1036 {"..", DOTDOT, BINOP_END},
1039 /* Identifier-like tokens. */
1040 static const struct token ident_tokens[] =
1042 {"is", IDENTITY, BINOP_END},
1043 {"!is", NOTIDENTITY, BINOP_END},
1045 {"cast", CAST_KEYWORD, OP_NULL},
1046 {"const", CONST_KEYWORD, OP_NULL},
1047 {"immutable", IMMUTABLE_KEYWORD, OP_NULL},
1048 {"shared", SHARED_KEYWORD, OP_NULL},
1049 {"super", SUPER_KEYWORD, OP_NULL},
1051 {"null", NULL_KEYWORD, OP_NULL},
1052 {"true", TRUE_KEYWORD, OP_NULL},
1053 {"false", FALSE_KEYWORD, OP_NULL},
1055 {"init", INIT_KEYWORD, OP_NULL},
1056 {"sizeof", SIZEOF_KEYWORD, OP_NULL},
1057 {"typeof", TYPEOF_KEYWORD, OP_NULL},
1058 {"typeid", TYPEID_KEYWORD, OP_NULL},
1060 {"delegate", DELEGATE_KEYWORD, OP_NULL},
1061 {"function", FUNCTION_KEYWORD, OP_NULL},
1062 {"struct", STRUCT_KEYWORD, OP_NULL},
1063 {"union", UNION_KEYWORD, OP_NULL},
1064 {"class", CLASS_KEYWORD, OP_NULL},
1065 {"interface", INTERFACE_KEYWORD, OP_NULL},
1066 {"enum", ENUM_KEYWORD, OP_NULL},
1067 {"template", TEMPLATE_KEYWORD, OP_NULL},
1070 /* This is set if a NAME token appeared at the very end of the input
1071 string, with no whitespace separating the name from the EOF. This
1072 is used only when parsing to do field name completion. */
1073 static int saw_name_at_eof;
1075 /* This is set if the previously-returned token was a structure operator.
1076 This is used only when parsing to do field name completion. */
1077 static int last_was_structop;
1079 /* Read one token, getting characters through lexptr. */
1082 lex_one_token (struct parser_state *par_state)
1087 const char *tokstart;
1088 int saw_structop = last_was_structop;
1091 last_was_structop = 0;
1095 prev_lexptr = lexptr;
1098 /* See if it is a special token of length 3. */
1099 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1100 if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
1103 yylval.opcode = tokentab3[i].opcode;
1104 return tokentab3[i].token;
1107 /* See if it is a special token of length 2. */
1108 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1109 if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
1112 yylval.opcode = tokentab2[i].opcode;
1113 return tokentab2[i].token;
1116 switch (c = *tokstart)
1119 /* If we're parsing for field name completion, and the previous
1120 token allows such completion, return a COMPLETE token.
1121 Otherwise, we were already scanning the original text, and
1122 we're really done. */
1123 if (saw_name_at_eof)
1125 saw_name_at_eof = 0;
1128 else if (saw_structop)
1147 if (paren_depth == 0)
1154 if (comma_terminates && paren_depth == 0)
1160 /* Might be a floating point number. */
1161 if (lexptr[1] < '0' || lexptr[1] > '9')
1163 if (parse_completion)
1164 last_was_structop = 1;
1165 goto symbol; /* Nope, must be a symbol. */
1167 /* FALL THRU into number case. */
1180 /* It's a number. */
1181 int got_dot = 0, got_e = 0, toktype;
1182 const char *p = tokstart;
1183 int hex = input_radix > 10;
1185 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1193 /* Hex exponents start with 'p', because 'e' is a valid hex
1194 digit and thus does not indicate a floating point number
1195 when the radix is hex. */
1196 if ((!hex && !got_e && tolower (p[0]) == 'e')
1197 || (hex && !got_e && tolower (p[0] == 'p')))
1198 got_dot = got_e = 1;
1199 /* A '.' always indicates a decimal floating point number
1200 regardless of the radix. If we have a '..' then its the
1201 end of the number and the beginning of a slice. */
1202 else if (!got_dot && (p[0] == '.' && p[1] != '.'))
1204 /* This is the sign of the exponent, not the end of the number. */
1205 else if (got_e && (tolower (p[-1]) == 'e' || tolower (p[-1]) == 'p')
1206 && (*p == '-' || *p == '+'))
1208 /* We will take any letters or digits, ignoring any embedded '_'.
1209 parse_number will complain if past the radix, or if L or U are
1211 else if ((*p < '0' || *p > '9') && (*p != '_')
1212 && ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z')))
1216 toktype = parse_number (par_state, tokstart, p - tokstart,
1217 got_dot|got_e, &yylval);
1218 if (toktype == ERROR)
1220 char *err_copy = (char *) alloca (p - tokstart + 1);
1222 memcpy (err_copy, tokstart, p - tokstart);
1223 err_copy[p - tokstart] = 0;
1224 error (_("Invalid number \"%s\"."), err_copy);
1232 const char *p = &tokstart[1];
1233 size_t len = strlen ("entry");
1235 while (isspace (*p))
1237 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1271 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
1273 if (result == CHARACTER_LITERAL)
1276 error (_("Empty character constant."));
1277 else if (host_len > 2 && c == '\'')
1280 namelen = lexptr - tokstart - 1;
1283 else if (host_len > 1)
1284 error (_("Invalid character constant."));
1290 if (!(c == '_' || c == '$'
1291 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1292 /* We must have come across a bad character (e.g. ';'). */
1293 error (_("Invalid character '%c' in expression"), c);
1295 /* It's a name. See how long it is. */
1297 for (c = tokstart[namelen];
1298 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1299 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1300 c = tokstart[++namelen];
1302 /* The token "if" terminates the expression and is NOT
1303 removed from the input stream. */
1304 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1307 /* For the same reason (breakpoint conditions), "thread N"
1308 terminates the expression. "thread" could be an identifier, but
1309 an identifier is never followed by a number without intervening
1310 punctuation. "task" is similar. Handle abbreviations of these,
1311 similarly to breakpoint.c:find_condition_and_thread. */
1313 && (strncmp (tokstart, "thread", namelen) == 0
1314 || strncmp (tokstart, "task", namelen) == 0)
1315 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1317 const char *p = tokstart + namelen + 1;
1319 while (*p == ' ' || *p == '\t')
1321 if (*p >= '0' && *p <= '9')
1329 yylval.sval.ptr = tokstart;
1330 yylval.sval.length = namelen;
1332 /* Catch specific keywords. */
1333 copy = copy_name (yylval.sval);
1334 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
1335 if (strcmp (copy, ident_tokens[i].oper) == 0)
1337 /* It is ok to always set this, even though we don't always
1338 strictly need to. */
1339 yylval.opcode = ident_tokens[i].opcode;
1340 return ident_tokens[i].token;
1343 if (*tokstart == '$')
1344 return DOLLAR_VARIABLE;
1347 = language_lookup_primitive_type (parse_language (par_state),
1348 parse_gdbarch (par_state), copy);
1349 if (yylval.tsym.type != NULL)
1352 /* Input names that aren't symbols but ARE valid hex numbers,
1353 when the input radix permits them, can be names or numbers
1354 depending on the parse. Note we support radixes > 16 here. */
1355 if ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1356 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))
1358 YYSTYPE newlval; /* Its value is ignored. */
1359 int hextype = parse_number (par_state, tokstart, namelen, 0, &newlval);
1360 if (hextype == INTEGER_LITERAL)
1364 if (parse_completion && *lexptr == '\0')
1365 saw_name_at_eof = 1;
1370 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
1377 DEF_VEC_O (token_and_value);
1379 /* A FIFO of tokens that have been read but not yet returned to the
1381 static VEC (token_and_value) *token_fifo;
1383 /* Non-zero if the lexer should return tokens from the FIFO. */
1386 /* Temporary storage for yylex; this holds symbol names as they are
1388 static struct obstack name_obstack;
1390 /* Classify an IDENTIFIER token. The contents of the token are in `yylval'.
1391 Updates yylval and returns the new token type. BLOCK is the block
1392 in which lookups start; this can be NULL to mean the global scope. */
1395 classify_name (struct parser_state *par_state, const struct block *block)
1397 struct block_symbol sym;
1399 struct field_of_this_result is_a_field_of_this;
1401 copy = copy_name (yylval.sval);
1403 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
1404 if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)
1406 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1409 else if (sym.symbol == NULL)
1411 /* Look-up first for a module name, then a type. */
1412 sym = lookup_symbol (copy, block, MODULE_DOMAIN, NULL);
1413 if (sym.symbol == NULL)
1414 sym = lookup_symbol (copy, block, STRUCT_DOMAIN, NULL);
1416 if (sym.symbol != NULL)
1418 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1422 return UNKNOWN_NAME;
1428 /* Like classify_name, but used by the inner loop of the lexer, when a
1429 name might have already been seen. CONTEXT is the context type, or
1430 NULL if this is the first component of a name. */
1433 classify_inner_name (struct parser_state *par_state,
1434 const struct block *block, struct type *context)
1439 if (context == NULL)
1440 return classify_name (par_state, block);
1442 type = check_typedef (context);
1444 copy = copy_name (yylval.ssym.stoken);
1445 yylval.ssym.sym = d_lookup_nested_symbol (type, copy, block);
1447 if (yylval.ssym.sym.symbol == NULL)
1450 if (SYMBOL_CLASS (yylval.ssym.sym.symbol) == LOC_TYPEDEF)
1452 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
1459 /* The outer level of a two-level lexer. This calls the inner lexer
1460 to return tokens. It then either returns these tokens, or
1461 aggregates them into a larger token. This lets us work around a
1462 problem in our parsing approach, where the parser could not
1463 distinguish between qualified names and qualified types at the
1469 token_and_value current;
1471 struct type *context_type = NULL;
1472 int last_to_examine, next_to_examine, checkpoint;
1473 const struct block *search_block;
1475 if (popping && !VEC_empty (token_and_value, token_fifo))
1479 /* Read the first token and decide what to do. */
1480 current.token = lex_one_token (pstate);
1481 if (current.token != IDENTIFIER && current.token != '.')
1482 return current.token;
1484 /* Read any sequence of alternating "." and identifier tokens into
1486 current.value = yylval;
1487 VEC_safe_push (token_and_value, token_fifo, ¤t);
1488 last_was_dot = current.token == '.';
1492 current.token = lex_one_token (pstate);
1493 current.value = yylval;
1494 VEC_safe_push (token_and_value, token_fifo, ¤t);
1496 if ((last_was_dot && current.token != IDENTIFIER)
1497 || (!last_was_dot && current.token != '.'))
1500 last_was_dot = !last_was_dot;
1504 /* We always read one extra token, so compute the number of tokens
1505 to examine accordingly. */
1506 last_to_examine = VEC_length (token_and_value, token_fifo) - 2;
1507 next_to_examine = 0;
1509 current = *VEC_index (token_and_value, token_fifo, next_to_examine);
1512 /* If we are not dealing with a typename, now is the time to find out. */
1513 if (current.token == IDENTIFIER)
1515 yylval = current.value;
1516 current.token = classify_name (pstate, expression_context_block);
1517 current.value = yylval;
1520 /* If the IDENTIFIER is not known, it could be a package symbol,
1521 first try building up a name until we find the qualified module. */
1522 if (current.token == UNKNOWN_NAME)
1524 obstack_free (&name_obstack, obstack_base (&name_obstack));
1525 obstack_grow (&name_obstack, current.value.sval.ptr,
1526 current.value.sval.length);
1530 while (next_to_examine <= last_to_examine)
1532 token_and_value *next;
1534 next = VEC_index (token_and_value, token_fifo, next_to_examine);
1537 if (next->token == IDENTIFIER && last_was_dot)
1539 /* Update the partial name we are constructing. */
1540 obstack_grow_str (&name_obstack, ".");
1541 obstack_grow (&name_obstack, next->value.sval.ptr,
1542 next->value.sval.length);
1544 yylval.sval.ptr = obstack_base (&name_obstack);
1545 yylval.sval.length = obstack_object_size (&name_obstack);
1547 current.token = classify_name (pstate, expression_context_block);
1548 current.value = yylval;
1550 /* We keep going until we find a TYPENAME. */
1551 if (current.token == TYPENAME)
1553 /* Install it as the first token in the FIFO. */
1554 VEC_replace (token_and_value, token_fifo, 0, ¤t);
1555 VEC_block_remove (token_and_value, token_fifo, 1,
1556 next_to_examine - 1);
1560 else if (next->token == '.' && !last_was_dot)
1564 /* We've reached the end of the name. */
1569 /* Reset our current token back to the start, if we found nothing
1570 this means that we will just jump to do pop. */
1571 current = *VEC_index (token_and_value, token_fifo, 0);
1572 next_to_examine = 1;
1574 if (current.token != TYPENAME && current.token != '.')
1577 obstack_free (&name_obstack, obstack_base (&name_obstack));
1579 if (current.token == '.')
1580 search_block = NULL;
1583 gdb_assert (current.token == TYPENAME);
1584 search_block = expression_context_block;
1585 obstack_grow (&name_obstack, current.value.sval.ptr,
1586 current.value.sval.length);
1587 context_type = current.value.tsym.type;
1591 last_was_dot = current.token == '.';
1593 while (next_to_examine <= last_to_examine)
1595 token_and_value *next;
1597 next = VEC_index (token_and_value, token_fifo, next_to_examine);
1600 if (next->token == IDENTIFIER && last_was_dot)
1604 yylval = next->value;
1605 classification = classify_inner_name (pstate, search_block,
1607 /* We keep going until we either run out of names, or until
1608 we have a qualified name which is not a type. */
1609 if (classification != TYPENAME && classification != IDENTIFIER)
1612 /* Accept up to this token. */
1613 checkpoint = next_to_examine;
1615 /* Update the partial name we are constructing. */
1616 if (context_type != NULL)
1618 /* We don't want to put a leading "." into the name. */
1619 obstack_grow_str (&name_obstack, ".");
1621 obstack_grow (&name_obstack, next->value.sval.ptr,
1622 next->value.sval.length);
1624 yylval.sval.ptr = obstack_base (&name_obstack);
1625 yylval.sval.length = obstack_object_size (&name_obstack);
1626 current.value = yylval;
1627 current.token = classification;
1631 if (classification == IDENTIFIER)
1634 context_type = yylval.tsym.type;
1636 else if (next->token == '.' && !last_was_dot)
1640 /* We've reached the end of the name. */
1645 /* If we have a replacement token, install it as the first token in
1646 the FIFO, and delete the other constituent tokens. */
1649 VEC_replace (token_and_value, token_fifo, 0, ¤t);
1651 VEC_block_remove (token_and_value, token_fifo, 1, checkpoint - 1);
1655 current = *VEC_index (token_and_value, token_fifo, 0);
1656 VEC_ordered_remove (token_and_value, token_fifo, 0);
1657 yylval = current.value;
1658 return current.token;
1662 d_parse (struct parser_state *par_state)
1665 struct cleanup *back_to;
1667 /* Setting up the parser state. */
1668 gdb_assert (par_state != NULL);
1671 back_to = make_cleanup (null_cleanup, NULL);
1673 make_cleanup_restore_integer (&yydebug);
1674 make_cleanup_clear_parser_state (&pstate);
1675 yydebug = parser_debug;
1677 /* Initialize some state used by the lexer. */
1678 last_was_structop = 0;
1679 saw_name_at_eof = 0;
1681 VEC_free (token_and_value, token_fifo);
1683 obstack_init (&name_obstack);
1684 make_cleanup_obstack_free (&name_obstack);
1686 result = yyparse ();
1687 do_cleanups (back_to);
1695 lexptr = prev_lexptr;
1697 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);