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);
527 char *name = malloc (typename_len + $3.length + 1);
529 make_cleanup (free, name);
530 sprintf (name, "%.*s.%.*s",
531 typename_len, typename, $3.length, $3.ptr);
534 lookup_symbol (name, (const struct block *) NULL,
538 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
539 write_exp_elt_block (pstate, sym.block);
540 write_exp_elt_sym (pstate, sym.symbol);
541 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
545 msymbol = lookup_bound_minimal_symbol (name);
546 if (msymbol.minsym != NULL)
547 write_exp_msymbol (pstate, msymbol);
548 else if (!have_full_symbols () && !have_partial_symbols ())
549 error (_("No symbol table is loaded. Use the \"file\" command."));
551 error (_("No symbol \"%s\" in current context."), name);
554 /* Check if the qualified name resolves as a member
555 of an aggregate or an enum type. */
556 if (!(TYPE_CODE (type) == TYPE_CODE_STRUCT
557 || TYPE_CODE (type) == TYPE_CODE_UNION
558 || TYPE_CODE (type) == TYPE_CODE_ENUM))
559 error (_("`%s' is not defined as an aggregate type."),
560 TYPE_SAFE_NAME (type));
562 write_exp_elt_opcode (pstate, OP_SCOPE);
563 write_exp_elt_type (pstate, type);
564 write_exp_string (pstate, $3);
565 write_exp_elt_opcode (pstate, OP_SCOPE);
568 { write_dollar_variable (pstate, $1); }
571 parse_number (pstate, $1.ptr, $1.length, 0, &val);
572 write_exp_elt_opcode (pstate, OP_LONG);
573 write_exp_elt_type (pstate, val.typed_val_int.type);
574 write_exp_elt_longcst (pstate,
575 (LONGEST) val.typed_val_int.val);
576 write_exp_elt_opcode (pstate, OP_LONG); }
578 { struct type *type = parse_d_type (pstate)->builtin_void;
579 type = lookup_pointer_type (type);
580 write_exp_elt_opcode (pstate, OP_LONG);
581 write_exp_elt_type (pstate, type);
582 write_exp_elt_longcst (pstate, (LONGEST) 0);
583 write_exp_elt_opcode (pstate, OP_LONG); }
585 { write_exp_elt_opcode (pstate, OP_BOOL);
586 write_exp_elt_longcst (pstate, (LONGEST) 1);
587 write_exp_elt_opcode (pstate, OP_BOOL); }
589 { write_exp_elt_opcode (pstate, OP_BOOL);
590 write_exp_elt_longcst (pstate, (LONGEST) 0);
591 write_exp_elt_opcode (pstate, OP_BOOL); }
593 { write_exp_elt_opcode (pstate, OP_LONG);
594 write_exp_elt_type (pstate, $1.type);
595 write_exp_elt_longcst (pstate, (LONGEST)($1.val));
596 write_exp_elt_opcode (pstate, OP_LONG); }
598 { write_exp_elt_opcode (pstate, OP_DOUBLE);
599 write_exp_elt_type (pstate, $1.type);
600 write_exp_elt_dblcst (pstate, $1.dval);
601 write_exp_elt_opcode (pstate, OP_DOUBLE); }
603 { struct stoken_vector vec;
606 write_exp_string_vector (pstate, $1.type, &vec); }
609 write_exp_string_vector (pstate, 0, &$1);
610 for (i = 0; i < $1.len; ++i)
611 free ($1.tokens[i].ptr);
614 { write_exp_elt_opcode (pstate, OP_ARRAY);
615 write_exp_elt_longcst (pstate, (LONGEST) 0);
616 write_exp_elt_longcst (pstate, (LONGEST) $1 - 1);
617 write_exp_elt_opcode (pstate, OP_ARRAY); }
621 '[' ArgumentList_opt ']'
622 { $$ = arglist_len; }
631 { /* We copy the string here, and not in the
632 lexer, to guarantee that we do not leak a
633 string. Note that we follow the
634 NUL-termination convention of the
636 struct typed_stoken *vec = XNEW (struct typed_stoken);
641 vec->length = $1.length;
642 vec->ptr = malloc ($1.length + 1);
643 memcpy (vec->ptr, $1.ptr, $1.length + 1);
645 | StringExp STRING_LITERAL
646 { /* Note that we NUL-terminate here, but just
650 $$.tokens = realloc ($$.tokens,
651 $$.len * sizeof (struct typed_stoken));
653 p = malloc ($2.length + 1);
654 memcpy (p, $2.ptr, $2.length + 1);
656 $$.tokens[$$.len - 1].type = $2.type;
657 $$.tokens[$$.len - 1].length = $2.length;
658 $$.tokens[$$.len - 1].ptr = p;
664 { /* Do nothing. */ }
666 { write_exp_elt_opcode (pstate, OP_TYPE);
667 write_exp_elt_type (pstate, $1);
668 write_exp_elt_opcode (pstate, OP_TYPE); }
669 | BasicType BasicType2
670 { $$ = follow_types ($1);
671 write_exp_elt_opcode (pstate, OP_TYPE);
672 write_exp_elt_type (pstate, $$);
673 write_exp_elt_opcode (pstate, OP_TYPE);
679 { push_type (tp_pointer); }
681 { push_type (tp_pointer); }
682 | '[' INTEGER_LITERAL ']'
683 { push_type_int ($2.val);
684 push_type (tp_array); }
685 | '[' INTEGER_LITERAL ']' BasicType2
686 { push_type_int ($2.val);
687 push_type (tp_array); }
697 /* Take care of parsing a number (anything that starts with a digit).
698 Set yylval and return the token type; update lexptr.
699 LEN is the number of characters in it. */
701 /*** Needs some error checking for the float case ***/
704 parse_number (struct parser_state *ps, const char *p,
705 int len, int parsed_float, YYSTYPE *putithere)
713 int base = input_radix;
717 /* We have found a "L" or "U" suffix. */
718 int found_suffix = 0;
721 struct type *signed_type;
722 struct type *unsigned_type;
726 const struct builtin_d_type *builtin_d_types;
731 /* Strip out all embedded '_' before passing to parse_float. */
732 s = (char *) alloca (len + 1);
743 if (! parse_float (s, len, &putithere->typed_val_float.dval, &suffix))
746 suffix_len = s + len - suffix;
750 putithere->typed_val_float.type
751 = parse_d_type (ps)->builtin_double;
753 else if (suffix_len == 1)
755 /* Check suffix for `f', `l', or `i' (float, real, or idouble). */
756 if (tolower (*suffix) == 'f')
758 putithere->typed_val_float.type
759 = parse_d_type (ps)->builtin_float;
761 else if (tolower (*suffix) == 'l')
763 putithere->typed_val_float.type
764 = parse_d_type (ps)->builtin_real;
766 else if (tolower (*suffix) == 'i')
768 putithere->typed_val_float.type
769 = parse_d_type (ps)->builtin_idouble;
774 else if (suffix_len == 2)
776 /* Check suffix for `fi' or `li' (ifloat or ireal). */
777 if (tolower (suffix[0]) == 'f' && tolower (suffix[1] == 'i'))
779 putithere->typed_val_float.type
780 = parse_d_type (ps)->builtin_ifloat;
782 else if (tolower (suffix[0]) == 'l' && tolower (suffix[1] == 'i'))
784 putithere->typed_val_float.type
785 = parse_d_type (ps)->builtin_ireal;
793 return FLOAT_LITERAL;
796 /* Handle base-switching prefixes 0x, 0b, 0 */
829 continue; /* Ignore embedded '_'. */
830 if (c >= 'A' && c <= 'Z')
832 if (c != 'l' && c != 'u')
834 if (c >= '0' && c <= '9')
842 if (base > 10 && c >= 'a' && c <= 'f')
846 n += i = c - 'a' + 10;
848 else if (c == 'l' && long_p == 0)
853 else if (c == 'u' && unsigned_p == 0)
859 return ERROR; /* Char not a digit */
862 return ERROR; /* Invalid digit in this base. */
863 /* Portably test for integer overflow. */
864 if (c != 'l' && c != 'u')
866 ULONGEST n2 = prevn * base;
867 if ((n2 / base != prevn) || (n2 + i < prevn))
868 error (_("Numeric constant too large."));
873 /* An integer constant is an int or a long. An L suffix forces it to
874 be long, and a U suffix forces it to be unsigned. To figure out
875 whether it fits, we shift it right and see whether anything remains.
876 Note that we can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or
877 more in one operation, because many compilers will warn about such a
878 shift (which always produces a zero result). To deal with the case
879 where it is we just always shift the value more than once, with fewer
881 un = (ULONGEST) n >> 2;
882 if (long_p == 0 && (un >> 30) == 0)
884 high_bit = ((ULONGEST) 1) << 31;
885 signed_type = parse_d_type (ps)->builtin_int;
886 /* For decimal notation, keep the sign of the worked out type. */
887 if (base == 10 && !unsigned_p)
888 unsigned_type = parse_d_type (ps)->builtin_long;
890 unsigned_type = parse_d_type (ps)->builtin_uint;
895 if (sizeof (ULONGEST) * HOST_CHAR_BIT < 64)
896 /* A long long does not fit in a LONGEST. */
897 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
900 high_bit = (ULONGEST) 1 << shift;
901 signed_type = parse_d_type (ps)->builtin_long;
902 unsigned_type = parse_d_type (ps)->builtin_ulong;
905 putithere->typed_val_int.val = n;
907 /* If the high bit of the worked out type is set then this number
908 has to be unsigned_type. */
909 if (unsigned_p || (n & high_bit))
910 putithere->typed_val_int.type = unsigned_type;
912 putithere->typed_val_int.type = signed_type;
914 return INTEGER_LITERAL;
917 /* Temporary obstack used for holding strings. */
918 static struct obstack tempbuf;
919 static int tempbuf_init;
921 /* Parse a string or character literal from TOKPTR. The string or
922 character may be wide or unicode. *OUTPTR is set to just after the
923 end of the literal in the input string. The resulting token is
924 stored in VALUE. This returns a token value, either STRING or
925 CHAR, depending on what was parsed. *HOST_CHARS is set to the
926 number of host characters in the literal. */
929 parse_string_or_char (const char *tokptr, const char **outptr,
930 struct typed_stoken *value, int *host_chars)
934 /* Build the gdb internal form of the input string in tempbuf. Note
935 that the buffer is null byte terminated *only* for the
936 convenience of debugging gdb itself and printing the buffer
937 contents when the buffer contains no embedded nulls. Gdb does
938 not depend upon the buffer being null byte terminated, it uses
939 the length string instead. This allows gdb to handle C strings
940 (as well as strings in other languages) with embedded null
946 obstack_free (&tempbuf, NULL);
947 obstack_init (&tempbuf);
949 /* Skip the quote. */
961 *host_chars += c_parse_escape (&tokptr, &tempbuf);
967 obstack_1grow (&tempbuf, c);
969 /* FIXME: this does the wrong thing with multi-byte host
970 characters. We could use mbrlen here, but that would
971 make "set host-charset" a bit less useful. */
976 if (*tokptr != quote)
978 if (quote == '"' || quote == '`')
979 error (_("Unterminated string in expression."));
981 error (_("Unmatched single quote."));
985 /* FIXME: should instead use own language string_type enum
986 and handle D-specific string suffixes here. */
988 value->type = C_CHAR;
990 value->type = C_STRING;
992 value->ptr = obstack_base (&tempbuf);
993 value->length = obstack_object_size (&tempbuf);
997 return quote == '\'' ? CHARACTER_LITERAL : STRING_LITERAL;
1004 enum exp_opcode opcode;
1007 static const struct token tokentab3[] =
1009 {"^^=", ASSIGN_MODIFY, BINOP_EXP},
1010 {"<<=", ASSIGN_MODIFY, BINOP_LSH},
1011 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1014 static const struct token tokentab2[] =
1016 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1017 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1018 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1019 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1020 {"%=", ASSIGN_MODIFY, BINOP_REM},
1021 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1022 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1023 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1024 {"++", INCREMENT, BINOP_END},
1025 {"--", DECREMENT, BINOP_END},
1026 {"&&", ANDAND, BINOP_END},
1027 {"||", OROR, BINOP_END},
1028 {"^^", HATHAT, BINOP_END},
1029 {"<<", LSH, BINOP_END},
1030 {">>", RSH, BINOP_END},
1031 {"==", EQUAL, BINOP_END},
1032 {"!=", NOTEQUAL, BINOP_END},
1033 {"<=", LEQ, BINOP_END},
1034 {">=", GEQ, BINOP_END},
1035 {"..", DOTDOT, BINOP_END},
1038 /* Identifier-like tokens. */
1039 static const struct token ident_tokens[] =
1041 {"is", IDENTITY, BINOP_END},
1042 {"!is", NOTIDENTITY, BINOP_END},
1044 {"cast", CAST_KEYWORD, OP_NULL},
1045 {"const", CONST_KEYWORD, OP_NULL},
1046 {"immutable", IMMUTABLE_KEYWORD, OP_NULL},
1047 {"shared", SHARED_KEYWORD, OP_NULL},
1048 {"super", SUPER_KEYWORD, OP_NULL},
1050 {"null", NULL_KEYWORD, OP_NULL},
1051 {"true", TRUE_KEYWORD, OP_NULL},
1052 {"false", FALSE_KEYWORD, OP_NULL},
1054 {"init", INIT_KEYWORD, OP_NULL},
1055 {"sizeof", SIZEOF_KEYWORD, OP_NULL},
1056 {"typeof", TYPEOF_KEYWORD, OP_NULL},
1057 {"typeid", TYPEID_KEYWORD, OP_NULL},
1059 {"delegate", DELEGATE_KEYWORD, OP_NULL},
1060 {"function", FUNCTION_KEYWORD, OP_NULL},
1061 {"struct", STRUCT_KEYWORD, OP_NULL},
1062 {"union", UNION_KEYWORD, OP_NULL},
1063 {"class", CLASS_KEYWORD, OP_NULL},
1064 {"interface", INTERFACE_KEYWORD, OP_NULL},
1065 {"enum", ENUM_KEYWORD, OP_NULL},
1066 {"template", TEMPLATE_KEYWORD, OP_NULL},
1069 /* This is set if a NAME token appeared at the very end of the input
1070 string, with no whitespace separating the name from the EOF. This
1071 is used only when parsing to do field name completion. */
1072 static int saw_name_at_eof;
1074 /* This is set if the previously-returned token was a structure operator.
1075 This is used only when parsing to do field name completion. */
1076 static int last_was_structop;
1078 /* Read one token, getting characters through lexptr. */
1081 lex_one_token (struct parser_state *par_state)
1086 const char *tokstart;
1087 int saw_structop = last_was_structop;
1090 last_was_structop = 0;
1094 prev_lexptr = lexptr;
1097 /* See if it is a special token of length 3. */
1098 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1099 if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
1102 yylval.opcode = tokentab3[i].opcode;
1103 return tokentab3[i].token;
1106 /* See if it is a special token of length 2. */
1107 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1108 if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
1111 yylval.opcode = tokentab2[i].opcode;
1112 return tokentab2[i].token;
1115 switch (c = *tokstart)
1118 /* If we're parsing for field name completion, and the previous
1119 token allows such completion, return a COMPLETE token.
1120 Otherwise, we were already scanning the original text, and
1121 we're really done. */
1122 if (saw_name_at_eof)
1124 saw_name_at_eof = 0;
1127 else if (saw_structop)
1146 if (paren_depth == 0)
1153 if (comma_terminates && paren_depth == 0)
1159 /* Might be a floating point number. */
1160 if (lexptr[1] < '0' || lexptr[1] > '9')
1162 if (parse_completion)
1163 last_was_structop = 1;
1164 goto symbol; /* Nope, must be a symbol. */
1166 /* FALL THRU into number case. */
1179 /* It's a number. */
1180 int got_dot = 0, got_e = 0, toktype;
1181 const char *p = tokstart;
1182 int hex = input_radix > 10;
1184 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1192 /* Hex exponents start with 'p', because 'e' is a valid hex
1193 digit and thus does not indicate a floating point number
1194 when the radix is hex. */
1195 if ((!hex && !got_e && tolower (p[0]) == 'e')
1196 || (hex && !got_e && tolower (p[0] == 'p')))
1197 got_dot = got_e = 1;
1198 /* A '.' always indicates a decimal floating point number
1199 regardless of the radix. If we have a '..' then its the
1200 end of the number and the beginning of a slice. */
1201 else if (!got_dot && (p[0] == '.' && p[1] != '.'))
1203 /* This is the sign of the exponent, not the end of the number. */
1204 else if (got_e && (tolower (p[-1]) == 'e' || tolower (p[-1]) == 'p')
1205 && (*p == '-' || *p == '+'))
1207 /* We will take any letters or digits, ignoring any embedded '_'.
1208 parse_number will complain if past the radix, or if L or U are
1210 else if ((*p < '0' || *p > '9') && (*p != '_') &&
1211 ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z')))
1215 toktype = parse_number (par_state, tokstart, p - tokstart,
1216 got_dot|got_e, &yylval);
1217 if (toktype == ERROR)
1219 char *err_copy = (char *) alloca (p - tokstart + 1);
1221 memcpy (err_copy, tokstart, p - tokstart);
1222 err_copy[p - tokstart] = 0;
1223 error (_("Invalid number \"%s\"."), err_copy);
1231 const char *p = &tokstart[1];
1232 size_t len = strlen ("entry");
1234 while (isspace (*p))
1236 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1270 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
1272 if (result == CHARACTER_LITERAL)
1275 error (_("Empty character constant."));
1276 else if (host_len > 2 && c == '\'')
1279 namelen = lexptr - tokstart - 1;
1282 else if (host_len > 1)
1283 error (_("Invalid character constant."));
1289 if (!(c == '_' || c == '$'
1290 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1291 /* We must have come across a bad character (e.g. ';'). */
1292 error (_("Invalid character '%c' in expression"), c);
1294 /* It's a name. See how long it is. */
1296 for (c = tokstart[namelen];
1297 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1298 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1299 c = tokstart[++namelen];
1301 /* The token "if" terminates the expression and is NOT
1302 removed from the input stream. */
1303 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1306 /* For the same reason (breakpoint conditions), "thread N"
1307 terminates the expression. "thread" could be an identifier, but
1308 an identifier is never followed by a number without intervening
1309 punctuation. "task" is similar. Handle abbreviations of these,
1310 similarly to breakpoint.c:find_condition_and_thread. */
1312 && (strncmp (tokstart, "thread", namelen) == 0
1313 || strncmp (tokstart, "task", namelen) == 0)
1314 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1316 const char *p = tokstart + namelen + 1;
1318 while (*p == ' ' || *p == '\t')
1320 if (*p >= '0' && *p <= '9')
1328 yylval.sval.ptr = tokstart;
1329 yylval.sval.length = namelen;
1331 /* Catch specific keywords. */
1332 copy = copy_name (yylval.sval);
1333 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
1334 if (strcmp (copy, ident_tokens[i].oper) == 0)
1336 /* It is ok to always set this, even though we don't always
1337 strictly need to. */
1338 yylval.opcode = ident_tokens[i].opcode;
1339 return ident_tokens[i].token;
1342 if (*tokstart == '$')
1343 return DOLLAR_VARIABLE;
1346 = language_lookup_primitive_type (parse_language (par_state),
1347 parse_gdbarch (par_state), copy);
1348 if (yylval.tsym.type != NULL)
1351 /* Input names that aren't symbols but ARE valid hex numbers,
1352 when the input radix permits them, can be names or numbers
1353 depending on the parse. Note we support radixes > 16 here. */
1354 if ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1355 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))
1357 YYSTYPE newlval; /* Its value is ignored. */
1358 int hextype = parse_number (par_state, tokstart, namelen, 0, &newlval);
1359 if (hextype == INTEGER_LITERAL)
1363 if (parse_completion && *lexptr == '\0')
1364 saw_name_at_eof = 1;
1369 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
1376 DEF_VEC_O (token_and_value);
1378 /* A FIFO of tokens that have been read but not yet returned to the
1380 static VEC (token_and_value) *token_fifo;
1382 /* Non-zero if the lexer should return tokens from the FIFO. */
1385 /* Temporary storage for yylex; this holds symbol names as they are
1387 static struct obstack name_obstack;
1389 /* Classify an IDENTIFIER token. The contents of the token are in `yylval'.
1390 Updates yylval and returns the new token type. BLOCK is the block
1391 in which lookups start; this can be NULL to mean the global scope. */
1394 classify_name (struct parser_state *par_state, const struct block *block)
1396 struct block_symbol sym;
1398 struct field_of_this_result is_a_field_of_this;
1400 copy = copy_name (yylval.sval);
1402 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
1403 if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)
1405 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1408 else if (sym.symbol == NULL)
1410 /* Look-up first for a module name, then a type. */
1411 sym = lookup_symbol (copy, block, MODULE_DOMAIN, NULL);
1412 if (sym.symbol == NULL)
1413 sym = lookup_symbol (copy, block, STRUCT_DOMAIN, NULL);
1415 if (sym.symbol != NULL)
1417 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1421 return UNKNOWN_NAME;
1427 /* Like classify_name, but used by the inner loop of the lexer, when a
1428 name might have already been seen. CONTEXT is the context type, or
1429 NULL if this is the first component of a name. */
1432 classify_inner_name (struct parser_state *par_state,
1433 const struct block *block, struct type *context)
1438 if (context == NULL)
1439 return classify_name (par_state, block);
1441 type = check_typedef (context);
1443 copy = copy_name (yylval.ssym.stoken);
1444 yylval.ssym.sym = d_lookup_nested_symbol (type, copy, block);
1446 if (yylval.ssym.sym.symbol == NULL)
1449 if (SYMBOL_CLASS (yylval.ssym.sym.symbol) == LOC_TYPEDEF)
1451 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
1458 /* The outer level of a two-level lexer. This calls the inner lexer
1459 to return tokens. It then either returns these tokens, or
1460 aggregates them into a larger token. This lets us work around a
1461 problem in our parsing approach, where the parser could not
1462 distinguish between qualified names and qualified types at the
1468 token_and_value current;
1470 struct type *context_type = NULL;
1471 int last_to_examine, next_to_examine, checkpoint;
1472 const struct block *search_block;
1474 if (popping && !VEC_empty (token_and_value, token_fifo))
1478 /* Read the first token and decide what to do. */
1479 current.token = lex_one_token (pstate);
1480 if (current.token != IDENTIFIER && current.token != '.')
1481 return current.token;
1483 /* Read any sequence of alternating "." and identifier tokens into
1485 current.value = yylval;
1486 VEC_safe_push (token_and_value, token_fifo, ¤t);
1487 last_was_dot = current.token == '.';
1491 current.token = lex_one_token (pstate);
1492 current.value = yylval;
1493 VEC_safe_push (token_and_value, token_fifo, ¤t);
1495 if ((last_was_dot && current.token != IDENTIFIER)
1496 || (!last_was_dot && current.token != '.'))
1499 last_was_dot = !last_was_dot;
1503 /* We always read one extra token, so compute the number of tokens
1504 to examine accordingly. */
1505 last_to_examine = VEC_length (token_and_value, token_fifo) - 2;
1506 next_to_examine = 0;
1508 current = *VEC_index (token_and_value, token_fifo, next_to_examine);
1511 /* If we are not dealing with a typename, now is the time to find out. */
1512 if (current.token == IDENTIFIER)
1514 yylval = current.value;
1515 current.token = classify_name (pstate, expression_context_block);
1516 current.value = yylval;
1519 /* If the IDENTIFIER is not known, it could be a package symbol,
1520 first try building up a name until we find the qualified module. */
1521 if (current.token == UNKNOWN_NAME)
1523 obstack_free (&name_obstack, obstack_base (&name_obstack));
1524 obstack_grow (&name_obstack, current.value.sval.ptr,
1525 current.value.sval.length);
1529 while (next_to_examine <= last_to_examine)
1531 token_and_value *next;
1533 next = VEC_index (token_and_value, token_fifo, next_to_examine);
1536 if (next->token == IDENTIFIER && last_was_dot)
1538 /* Update the partial name we are constructing. */
1539 obstack_grow_str (&name_obstack, ".");
1540 obstack_grow (&name_obstack, next->value.sval.ptr,
1541 next->value.sval.length);
1543 yylval.sval.ptr = obstack_base (&name_obstack);
1544 yylval.sval.length = obstack_object_size (&name_obstack);
1546 current.token = classify_name (pstate, expression_context_block);
1547 current.value = yylval;
1549 /* We keep going until we find a TYPENAME. */
1550 if (current.token == TYPENAME)
1552 /* Install it as the first token in the FIFO. */
1553 VEC_replace (token_and_value, token_fifo, 0, ¤t);
1554 VEC_block_remove (token_and_value, token_fifo, 1,
1555 next_to_examine - 1);
1559 else if (next->token == '.' && !last_was_dot)
1563 /* We've reached the end of the name. */
1568 /* Reset our current token back to the start, if we found nothing
1569 this means that we will just jump to do pop. */
1570 current = *VEC_index (token_and_value, token_fifo, 0);
1571 next_to_examine = 1;
1573 if (current.token != TYPENAME && current.token != '.')
1576 obstack_free (&name_obstack, obstack_base (&name_obstack));
1578 if (current.token == '.')
1579 search_block = NULL;
1582 gdb_assert (current.token == TYPENAME);
1583 search_block = expression_context_block;
1584 obstack_grow (&name_obstack, current.value.sval.ptr,
1585 current.value.sval.length);
1586 context_type = current.value.tsym.type;
1590 last_was_dot = current.token == '.';
1592 while (next_to_examine <= last_to_examine)
1594 token_and_value *next;
1596 next = VEC_index (token_and_value, token_fifo, next_to_examine);
1599 if (next->token == IDENTIFIER && last_was_dot)
1603 yylval = next->value;
1604 classification = classify_inner_name (pstate, search_block,
1606 /* We keep going until we either run out of names, or until
1607 we have a qualified name which is not a type. */
1608 if (classification != TYPENAME && classification != IDENTIFIER)
1611 /* Accept up to this token. */
1612 checkpoint = next_to_examine;
1614 /* Update the partial name we are constructing. */
1615 if (context_type != NULL)
1617 /* We don't want to put a leading "." into the name. */
1618 obstack_grow_str (&name_obstack, ".");
1620 obstack_grow (&name_obstack, next->value.sval.ptr,
1621 next->value.sval.length);
1623 yylval.sval.ptr = obstack_base (&name_obstack);
1624 yylval.sval.length = obstack_object_size (&name_obstack);
1625 current.value = yylval;
1626 current.token = classification;
1630 if (classification == IDENTIFIER)
1633 context_type = yylval.tsym.type;
1635 else if (next->token == '.' && !last_was_dot)
1639 /* We've reached the end of the name. */
1644 /* If we have a replacement token, install it as the first token in
1645 the FIFO, and delete the other constituent tokens. */
1648 VEC_replace (token_and_value, token_fifo, 0, ¤t);
1650 VEC_block_remove (token_and_value, token_fifo, 1, checkpoint - 1);
1654 current = *VEC_index (token_and_value, token_fifo, 0);
1655 VEC_ordered_remove (token_and_value, token_fifo, 0);
1656 yylval = current.value;
1657 return current.token;
1661 d_parse (struct parser_state *par_state)
1664 struct cleanup *back_to;
1666 /* Setting up the parser state. */
1667 gdb_assert (par_state != NULL);
1670 back_to = make_cleanup (null_cleanup, NULL);
1672 make_cleanup_restore_integer (&yydebug);
1673 make_cleanup_clear_parser_state (&pstate);
1674 yydebug = parser_debug;
1676 /* Initialize some state used by the lexer. */
1677 last_was_structop = 0;
1678 saw_name_at_eof = 0;
1680 VEC_free (token_and_value, token_fifo);
1682 obstack_init (&name_obstack);
1683 make_cleanup_obstack_free (&name_obstack);
1685 result = yyparse ();
1686 do_cleanups (back_to);
1694 lexptr = prev_lexptr;
1696 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);