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 *);
129 static int type_aggregate_p (struct type *);
133 /* Although the yacc "value" of an expression is not used,
134 since the result is stored in the structure being created,
135 other node types do have values. */
149 struct typed_stoken tsval;
152 struct symtoken ssym;
156 enum exp_opcode opcode;
157 struct stoken_vector svec;
161 /* YYSTYPE gets defined by %union */
162 static int parse_number (struct parser_state *, const char *,
163 int, int, YYSTYPE *);
166 %token <sval> IDENTIFIER UNKNOWN_NAME
167 %token <tsym> TYPENAME
168 %token <voidval> COMPLETE
170 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
171 but which would parse as a valid number in the current input radix.
172 E.g. "c" when input_radix==16. Depending on the parse, it will be
173 turned into a name or into a number. */
175 %token <sval> NAME_OR_INT
177 %token <typed_val_int> INTEGER_LITERAL
178 %token <typed_val_float> FLOAT_LITERAL
179 %token <tsval> CHARACTER_LITERAL
180 %token <tsval> STRING_LITERAL
182 %type <svec> StringExp
183 %type <tval> BasicType TypeExp
184 %type <sval> IdentifierExp
185 %type <ival> ArrayLiteral
190 /* Keywords that have a constant value. */
191 %token TRUE_KEYWORD FALSE_KEYWORD NULL_KEYWORD
192 /* Class 'super' accessor. */
195 %token CAST_KEYWORD SIZEOF_KEYWORD
196 %token TYPEOF_KEYWORD TYPEID_KEYWORD
198 /* Comparison keywords. */
199 /* Type storage classes. */
200 %token IMMUTABLE_KEYWORD CONST_KEYWORD SHARED_KEYWORD
201 /* Non-scalar type keywords. */
202 %token STRUCT_KEYWORD UNION_KEYWORD
203 %token CLASS_KEYWORD INTERFACE_KEYWORD
204 %token ENUM_KEYWORD TEMPLATE_KEYWORD
205 %token DELEGATE_KEYWORD FUNCTION_KEYWORD
207 %token <sval> DOLLAR_VARIABLE
209 %token <opcode> ASSIGN_MODIFY
212 %right '=' ASSIGN_MODIFY
219 %left EQUAL NOTEQUAL '<' '>' LEQ GEQ
224 %left IDENTITY NOTIDENTITY
225 %right INCREMENT DECREMENT
237 /* Expressions, including the comma operator. */
245 | AssignExpression ',' CommaExpression
246 { write_exp_elt_opcode (pstate, BINOP_COMMA); }
250 ConditionalExpression
251 | ConditionalExpression '=' AssignExpression
252 { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
253 | ConditionalExpression ASSIGN_MODIFY AssignExpression
254 { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
255 write_exp_elt_opcode (pstate, $2);
256 write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY); }
259 ConditionalExpression:
261 | OrOrExpression '?' Expression ':' ConditionalExpression
262 { write_exp_elt_opcode (pstate, TERNOP_COND); }
267 | OrOrExpression OROR AndAndExpression
268 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
273 | AndAndExpression ANDAND OrExpression
274 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
279 | OrExpression '|' XorExpression
280 { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
285 | XorExpression '^' AndExpression
286 { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
291 | AndExpression '&' CmpExpression
292 { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
303 ShiftExpression EQUAL ShiftExpression
304 { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
305 | ShiftExpression NOTEQUAL ShiftExpression
306 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
310 ShiftExpression IDENTITY ShiftExpression
311 { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
312 | ShiftExpression NOTIDENTITY ShiftExpression
313 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
317 ShiftExpression '<' ShiftExpression
318 { write_exp_elt_opcode (pstate, BINOP_LESS); }
319 | ShiftExpression LEQ ShiftExpression
320 { write_exp_elt_opcode (pstate, BINOP_LEQ); }
321 | ShiftExpression '>' ShiftExpression
322 { write_exp_elt_opcode (pstate, BINOP_GTR); }
323 | ShiftExpression GEQ ShiftExpression
324 { write_exp_elt_opcode (pstate, BINOP_GEQ); }
329 | ShiftExpression LSH AddExpression
330 { write_exp_elt_opcode (pstate, BINOP_LSH); }
331 | ShiftExpression RSH AddExpression
332 { write_exp_elt_opcode (pstate, BINOP_RSH); }
337 | AddExpression '+' MulExpression
338 { write_exp_elt_opcode (pstate, BINOP_ADD); }
339 | AddExpression '-' MulExpression
340 { write_exp_elt_opcode (pstate, BINOP_SUB); }
341 | AddExpression '~' MulExpression
342 { write_exp_elt_opcode (pstate, BINOP_CONCAT); }
347 | MulExpression '*' UnaryExpression
348 { write_exp_elt_opcode (pstate, BINOP_MUL); }
349 | MulExpression '/' UnaryExpression
350 { write_exp_elt_opcode (pstate, BINOP_DIV); }
351 | MulExpression '%' UnaryExpression
352 { write_exp_elt_opcode (pstate, BINOP_REM); }
356 { write_exp_elt_opcode (pstate, UNOP_ADDR); }
357 | INCREMENT UnaryExpression
358 { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
359 | DECREMENT UnaryExpression
360 { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); }
361 | '*' UnaryExpression
362 { write_exp_elt_opcode (pstate, UNOP_IND); }
363 | '-' UnaryExpression
364 { write_exp_elt_opcode (pstate, UNOP_NEG); }
365 | '+' UnaryExpression
366 { write_exp_elt_opcode (pstate, UNOP_PLUS); }
367 | '!' UnaryExpression
368 { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
369 | '~' UnaryExpression
370 { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); }
371 | TypeExp '.' SIZEOF_KEYWORD
372 { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
378 CAST_KEYWORD '(' TypeExp ')' UnaryExpression
379 { write_exp_elt_opcode (pstate, UNOP_CAST);
380 write_exp_elt_type (pstate, $3);
381 write_exp_elt_opcode (pstate, UNOP_CAST); }
382 /* C style cast is illegal D, but is still recognised in
383 the grammar, so we keep this around for convenience. */
384 | '(' TypeExp ')' UnaryExpression
385 { write_exp_elt_opcode (pstate, UNOP_CAST);
386 write_exp_elt_type (pstate, $2);
387 write_exp_elt_opcode (pstate, UNOP_CAST); }
392 | PostfixExpression HATHAT UnaryExpression
393 { write_exp_elt_opcode (pstate, BINOP_EXP); }
398 | PostfixExpression '.' COMPLETE
400 mark_struct_expression (pstate);
401 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
404 write_exp_string (pstate, s);
405 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
406 | PostfixExpression '.' IDENTIFIER
407 { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
408 write_exp_string (pstate, $3);
409 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
410 | PostfixExpression '.' IDENTIFIER COMPLETE
411 { mark_struct_expression (pstate);
412 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
413 write_exp_string (pstate, $3);
414 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
415 | PostfixExpression '.' SIZEOF_KEYWORD
416 { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
417 | PostfixExpression INCREMENT
418 { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); }
419 | PostfixExpression DECREMENT
420 { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); }
429 | ArgumentList ',' AssignExpression
440 PostfixExpression '('
441 { start_arglist (); }
443 { write_exp_elt_opcode (pstate, OP_FUNCALL);
444 write_exp_elt_longcst (pstate, (LONGEST) end_arglist ());
445 write_exp_elt_opcode (pstate, OP_FUNCALL); }
449 PostfixExpression '[' ArgumentList ']'
450 { if (arglist_len > 0)
452 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
453 write_exp_elt_longcst (pstate, (LONGEST) arglist_len);
454 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
457 write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT);
462 PostfixExpression '[' ']'
463 { /* Do nothing. */ }
464 | PostfixExpression '[' AssignExpression DOTDOT AssignExpression ']'
465 { write_exp_elt_opcode (pstate, TERNOP_SLICE); }
470 { /* Do nothing. */ }
472 { struct bound_minimal_symbol msymbol;
473 char *copy = copy_name ($1);
474 struct field_of_this_result is_a_field_of_this;
475 struct block_symbol sym;
477 /* Handle VAR, which could be local or global. */
478 sym = lookup_symbol (copy, expression_context_block, VAR_DOMAIN,
479 &is_a_field_of_this);
480 if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
482 if (symbol_read_needs_frame (sym.symbol))
484 if (innermost_block == 0
485 || contained_in (sym.block, innermost_block))
486 innermost_block = sym.block;
489 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
490 /* We want to use the selected frame, not another more inner frame
491 which happens to be in the same block. */
492 write_exp_elt_block (pstate, NULL);
493 write_exp_elt_sym (pstate, sym.symbol);
494 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
496 else if (is_a_field_of_this.type != NULL)
498 /* It hangs off of `this'. Must not inadvertently convert from a
499 method call to data ref. */
500 if (innermost_block == 0
501 || contained_in (sym.block, innermost_block))
502 innermost_block = sym.block;
503 write_exp_elt_opcode (pstate, OP_THIS);
504 write_exp_elt_opcode (pstate, OP_THIS);
505 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
506 write_exp_string (pstate, $1);
507 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
511 /* Lookup foreign name in global static symbols. */
512 msymbol = lookup_bound_minimal_symbol (copy);
513 if (msymbol.minsym != NULL)
514 write_exp_msymbol (pstate, msymbol);
515 else if (!have_full_symbols () && !have_partial_symbols ())
516 error (_("No symbol table is loaded. Use the \"file\" command"));
518 error (_("No symbol \"%s\" in current context."), copy);
521 | TypeExp '.' IdentifierExp
522 { struct type *type = check_typedef ($1);
524 /* Check if the qualified name is in the global
525 context. However if the symbol has not already
526 been resolved, it's not likely to be found. */
527 if (TYPE_CODE (type) == TYPE_CODE_MODULE)
529 struct bound_minimal_symbol msymbol;
530 struct block_symbol sym;
531 const char *type_name = TYPE_SAFE_NAME (type);
532 int type_name_len = strlen (type_name);
535 name = xstrprintf ("%.*s.%.*s",
536 type_name_len, type_name,
538 make_cleanup (xfree, name);
541 lookup_symbol (name, (const struct block *) NULL,
545 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
546 write_exp_elt_block (pstate, sym.block);
547 write_exp_elt_sym (pstate, sym.symbol);
548 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
552 msymbol = lookup_bound_minimal_symbol (name);
553 if (msymbol.minsym != NULL)
554 write_exp_msymbol (pstate, msymbol);
555 else if (!have_full_symbols () && !have_partial_symbols ())
556 error (_("No symbol table is loaded. Use the \"file\" command."));
558 error (_("No symbol \"%s\" in current context."), name);
561 /* Check if the qualified name resolves as a member
562 of an aggregate or an enum type. */
563 if (!type_aggregate_p (type))
564 error (_("`%s' is not defined as an aggregate type."),
565 TYPE_SAFE_NAME (type));
567 write_exp_elt_opcode (pstate, OP_SCOPE);
568 write_exp_elt_type (pstate, type);
569 write_exp_string (pstate, $3);
570 write_exp_elt_opcode (pstate, OP_SCOPE);
573 { write_dollar_variable (pstate, $1); }
576 parse_number (pstate, $1.ptr, $1.length, 0, &val);
577 write_exp_elt_opcode (pstate, OP_LONG);
578 write_exp_elt_type (pstate, val.typed_val_int.type);
579 write_exp_elt_longcst (pstate,
580 (LONGEST) val.typed_val_int.val);
581 write_exp_elt_opcode (pstate, OP_LONG); }
583 { struct type *type = parse_d_type (pstate)->builtin_void;
584 type = lookup_pointer_type (type);
585 write_exp_elt_opcode (pstate, OP_LONG);
586 write_exp_elt_type (pstate, type);
587 write_exp_elt_longcst (pstate, (LONGEST) 0);
588 write_exp_elt_opcode (pstate, OP_LONG); }
590 { write_exp_elt_opcode (pstate, OP_BOOL);
591 write_exp_elt_longcst (pstate, (LONGEST) 1);
592 write_exp_elt_opcode (pstate, OP_BOOL); }
594 { write_exp_elt_opcode (pstate, OP_BOOL);
595 write_exp_elt_longcst (pstate, (LONGEST) 0);
596 write_exp_elt_opcode (pstate, OP_BOOL); }
598 { write_exp_elt_opcode (pstate, OP_LONG);
599 write_exp_elt_type (pstate, $1.type);
600 write_exp_elt_longcst (pstate, (LONGEST)($1.val));
601 write_exp_elt_opcode (pstate, OP_LONG); }
603 { write_exp_elt_opcode (pstate, OP_DOUBLE);
604 write_exp_elt_type (pstate, $1.type);
605 write_exp_elt_dblcst (pstate, $1.dval);
606 write_exp_elt_opcode (pstate, OP_DOUBLE); }
608 { struct stoken_vector vec;
611 write_exp_string_vector (pstate, $1.type, &vec); }
614 write_exp_string_vector (pstate, 0, &$1);
615 for (i = 0; i < $1.len; ++i)
616 free ($1.tokens[i].ptr);
619 { write_exp_elt_opcode (pstate, OP_ARRAY);
620 write_exp_elt_longcst (pstate, (LONGEST) 0);
621 write_exp_elt_longcst (pstate, (LONGEST) $1 - 1);
622 write_exp_elt_opcode (pstate, OP_ARRAY); }
623 | TYPEOF_KEYWORD '(' Expression ')'
624 { write_exp_elt_opcode (pstate, OP_TYPEOF); }
628 '[' ArgumentList_opt ']'
629 { $$ = arglist_len; }
638 { /* We copy the string here, and not in the
639 lexer, to guarantee that we do not leak a
640 string. Note that we follow the
641 NUL-termination convention of the
643 struct typed_stoken *vec = XNEW (struct typed_stoken);
648 vec->length = $1.length;
649 vec->ptr = (char *) malloc ($1.length + 1);
650 memcpy (vec->ptr, $1.ptr, $1.length + 1);
652 | StringExp STRING_LITERAL
653 { /* Note that we NUL-terminate here, but just
658 = XRESIZEVEC (struct typed_stoken, $$.tokens, $$.len);
660 p = (char *) malloc ($2.length + 1);
661 memcpy (p, $2.ptr, $2.length + 1);
663 $$.tokens[$$.len - 1].type = $2.type;
664 $$.tokens[$$.len - 1].length = $2.length;
665 $$.tokens[$$.len - 1].ptr = p;
671 { /* Do nothing. */ }
673 { write_exp_elt_opcode (pstate, OP_TYPE);
674 write_exp_elt_type (pstate, $1);
675 write_exp_elt_opcode (pstate, OP_TYPE); }
676 | BasicType BasicType2
677 { $$ = follow_types ($1);
678 write_exp_elt_opcode (pstate, OP_TYPE);
679 write_exp_elt_type (pstate, $$);
680 write_exp_elt_opcode (pstate, OP_TYPE);
686 { push_type (tp_pointer); }
688 { push_type (tp_pointer); }
689 | '[' INTEGER_LITERAL ']'
690 { push_type_int ($2.val);
691 push_type (tp_array); }
692 | '[' INTEGER_LITERAL ']' BasicType2
693 { push_type_int ($2.val);
694 push_type (tp_array); }
704 /* Return true if the type is aggregate-like. */
707 type_aggregate_p (struct type *type)
709 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
710 || TYPE_CODE (type) == TYPE_CODE_UNION
711 || (TYPE_CODE (type) == TYPE_CODE_ENUM
712 && TYPE_DECLARED_CLASS (type)));
715 /* Take care of parsing a number (anything that starts with a digit).
716 Set yylval and return the token type; update lexptr.
717 LEN is the number of characters in it. */
719 /*** Needs some error checking for the float case ***/
722 parse_number (struct parser_state *ps, const char *p,
723 int len, int parsed_float, YYSTYPE *putithere)
731 int base = input_radix;
735 /* We have found a "L" or "U" suffix. */
736 int found_suffix = 0;
739 struct type *signed_type;
740 struct type *unsigned_type;
744 const struct builtin_d_type *builtin_d_types;
749 /* Strip out all embedded '_' before passing to parse_float. */
750 s = (char *) alloca (len + 1);
761 if (! parse_float (s, len, &putithere->typed_val_float.dval, &suffix))
764 suffix_len = s + len - suffix;
768 putithere->typed_val_float.type
769 = parse_d_type (ps)->builtin_double;
771 else if (suffix_len == 1)
773 /* Check suffix for `f', `l', or `i' (float, real, or idouble). */
774 if (tolower (*suffix) == 'f')
776 putithere->typed_val_float.type
777 = parse_d_type (ps)->builtin_float;
779 else if (tolower (*suffix) == 'l')
781 putithere->typed_val_float.type
782 = parse_d_type (ps)->builtin_real;
784 else if (tolower (*suffix) == 'i')
786 putithere->typed_val_float.type
787 = parse_d_type (ps)->builtin_idouble;
792 else if (suffix_len == 2)
794 /* Check suffix for `fi' or `li' (ifloat or ireal). */
795 if (tolower (suffix[0]) == 'f' && tolower (suffix[1] == 'i'))
797 putithere->typed_val_float.type
798 = parse_d_type (ps)->builtin_ifloat;
800 else if (tolower (suffix[0]) == 'l' && tolower (suffix[1] == 'i'))
802 putithere->typed_val_float.type
803 = parse_d_type (ps)->builtin_ireal;
811 return FLOAT_LITERAL;
814 /* Handle base-switching prefixes 0x, 0b, 0 */
847 continue; /* Ignore embedded '_'. */
848 if (c >= 'A' && c <= 'Z')
850 if (c != 'l' && c != 'u')
852 if (c >= '0' && c <= '9')
860 if (base > 10 && c >= 'a' && c <= 'f')
864 n += i = c - 'a' + 10;
866 else if (c == 'l' && long_p == 0)
871 else if (c == 'u' && unsigned_p == 0)
877 return ERROR; /* Char not a digit */
880 return ERROR; /* Invalid digit in this base. */
881 /* Portably test for integer overflow. */
882 if (c != 'l' && c != 'u')
884 ULONGEST n2 = prevn * base;
885 if ((n2 / base != prevn) || (n2 + i < prevn))
886 error (_("Numeric constant too large."));
891 /* An integer constant is an int or a long. An L suffix forces it to
892 be long, and a U suffix forces it to be unsigned. To figure out
893 whether it fits, we shift it right and see whether anything remains.
894 Note that we can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or
895 more in one operation, because many compilers will warn about such a
896 shift (which always produces a zero result). To deal with the case
897 where it is we just always shift the value more than once, with fewer
899 un = (ULONGEST) n >> 2;
900 if (long_p == 0 && (un >> 30) == 0)
902 high_bit = ((ULONGEST) 1) << 31;
903 signed_type = parse_d_type (ps)->builtin_int;
904 /* For decimal notation, keep the sign of the worked out type. */
905 if (base == 10 && !unsigned_p)
906 unsigned_type = parse_d_type (ps)->builtin_long;
908 unsigned_type = parse_d_type (ps)->builtin_uint;
913 if (sizeof (ULONGEST) * HOST_CHAR_BIT < 64)
914 /* A long long does not fit in a LONGEST. */
915 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
918 high_bit = (ULONGEST) 1 << shift;
919 signed_type = parse_d_type (ps)->builtin_long;
920 unsigned_type = parse_d_type (ps)->builtin_ulong;
923 putithere->typed_val_int.val = n;
925 /* If the high bit of the worked out type is set then this number
926 has to be unsigned_type. */
927 if (unsigned_p || (n & high_bit))
928 putithere->typed_val_int.type = unsigned_type;
930 putithere->typed_val_int.type = signed_type;
932 return INTEGER_LITERAL;
935 /* Temporary obstack used for holding strings. */
936 static struct obstack tempbuf;
937 static int tempbuf_init;
939 /* Parse a string or character literal from TOKPTR. The string or
940 character may be wide or unicode. *OUTPTR is set to just after the
941 end of the literal in the input string. The resulting token is
942 stored in VALUE. This returns a token value, either STRING or
943 CHAR, depending on what was parsed. *HOST_CHARS is set to the
944 number of host characters in the literal. */
947 parse_string_or_char (const char *tokptr, const char **outptr,
948 struct typed_stoken *value, int *host_chars)
952 /* Build the gdb internal form of the input string in tempbuf. Note
953 that the buffer is null byte terminated *only* for the
954 convenience of debugging gdb itself and printing the buffer
955 contents when the buffer contains no embedded nulls. Gdb does
956 not depend upon the buffer being null byte terminated, it uses
957 the length string instead. This allows gdb to handle C strings
958 (as well as strings in other languages) with embedded null
964 obstack_free (&tempbuf, NULL);
965 obstack_init (&tempbuf);
967 /* Skip the quote. */
979 *host_chars += c_parse_escape (&tokptr, &tempbuf);
985 obstack_1grow (&tempbuf, c);
987 /* FIXME: this does the wrong thing with multi-byte host
988 characters. We could use mbrlen here, but that would
989 make "set host-charset" a bit less useful. */
994 if (*tokptr != quote)
996 if (quote == '"' || quote == '`')
997 error (_("Unterminated string in expression."));
999 error (_("Unmatched single quote."));
1003 /* FIXME: should instead use own language string_type enum
1004 and handle D-specific string suffixes here. */
1006 value->type = C_CHAR;
1008 value->type = C_STRING;
1010 value->ptr = obstack_base (&tempbuf);
1011 value->length = obstack_object_size (&tempbuf);
1015 return quote == '\'' ? CHARACTER_LITERAL : STRING_LITERAL;
1022 enum exp_opcode opcode;
1025 static const struct token tokentab3[] =
1027 {"^^=", ASSIGN_MODIFY, BINOP_EXP},
1028 {"<<=", ASSIGN_MODIFY, BINOP_LSH},
1029 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1032 static const struct token tokentab2[] =
1034 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1035 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1036 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1037 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1038 {"%=", ASSIGN_MODIFY, BINOP_REM},
1039 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1040 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1041 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1042 {"++", INCREMENT, BINOP_END},
1043 {"--", DECREMENT, BINOP_END},
1044 {"&&", ANDAND, BINOP_END},
1045 {"||", OROR, BINOP_END},
1046 {"^^", HATHAT, BINOP_END},
1047 {"<<", LSH, BINOP_END},
1048 {">>", RSH, BINOP_END},
1049 {"==", EQUAL, BINOP_END},
1050 {"!=", NOTEQUAL, BINOP_END},
1051 {"<=", LEQ, BINOP_END},
1052 {">=", GEQ, BINOP_END},
1053 {"..", DOTDOT, BINOP_END},
1056 /* Identifier-like tokens. */
1057 static const struct token ident_tokens[] =
1059 {"is", IDENTITY, BINOP_END},
1060 {"!is", NOTIDENTITY, BINOP_END},
1062 {"cast", CAST_KEYWORD, OP_NULL},
1063 {"const", CONST_KEYWORD, OP_NULL},
1064 {"immutable", IMMUTABLE_KEYWORD, OP_NULL},
1065 {"shared", SHARED_KEYWORD, OP_NULL},
1066 {"super", SUPER_KEYWORD, OP_NULL},
1068 {"null", NULL_KEYWORD, OP_NULL},
1069 {"true", TRUE_KEYWORD, OP_NULL},
1070 {"false", FALSE_KEYWORD, OP_NULL},
1072 {"init", INIT_KEYWORD, OP_NULL},
1073 {"sizeof", SIZEOF_KEYWORD, OP_NULL},
1074 {"typeof", TYPEOF_KEYWORD, OP_NULL},
1075 {"typeid", TYPEID_KEYWORD, OP_NULL},
1077 {"delegate", DELEGATE_KEYWORD, OP_NULL},
1078 {"function", FUNCTION_KEYWORD, OP_NULL},
1079 {"struct", STRUCT_KEYWORD, OP_NULL},
1080 {"union", UNION_KEYWORD, OP_NULL},
1081 {"class", CLASS_KEYWORD, OP_NULL},
1082 {"interface", INTERFACE_KEYWORD, OP_NULL},
1083 {"enum", ENUM_KEYWORD, OP_NULL},
1084 {"template", TEMPLATE_KEYWORD, OP_NULL},
1087 /* This is set if a NAME token appeared at the very end of the input
1088 string, with no whitespace separating the name from the EOF. This
1089 is used only when parsing to do field name completion. */
1090 static int saw_name_at_eof;
1092 /* This is set if the previously-returned token was a structure operator.
1093 This is used only when parsing to do field name completion. */
1094 static int last_was_structop;
1096 /* Read one token, getting characters through lexptr. */
1099 lex_one_token (struct parser_state *par_state)
1104 const char *tokstart;
1105 int saw_structop = last_was_structop;
1108 last_was_structop = 0;
1112 prev_lexptr = lexptr;
1115 /* See if it is a special token of length 3. */
1116 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1117 if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
1120 yylval.opcode = tokentab3[i].opcode;
1121 return tokentab3[i].token;
1124 /* See if it is a special token of length 2. */
1125 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1126 if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
1129 yylval.opcode = tokentab2[i].opcode;
1130 return tokentab2[i].token;
1133 switch (c = *tokstart)
1136 /* If we're parsing for field name completion, and the previous
1137 token allows such completion, return a COMPLETE token.
1138 Otherwise, we were already scanning the original text, and
1139 we're really done. */
1140 if (saw_name_at_eof)
1142 saw_name_at_eof = 0;
1145 else if (saw_structop)
1164 if (paren_depth == 0)
1171 if (comma_terminates && paren_depth == 0)
1177 /* Might be a floating point number. */
1178 if (lexptr[1] < '0' || lexptr[1] > '9')
1180 if (parse_completion)
1181 last_was_structop = 1;
1182 goto symbol; /* Nope, must be a symbol. */
1184 /* FALL THRU into number case. */
1197 /* It's a number. */
1198 int got_dot = 0, got_e = 0, toktype;
1199 const char *p = tokstart;
1200 int hex = input_radix > 10;
1202 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1210 /* Hex exponents start with 'p', because 'e' is a valid hex
1211 digit and thus does not indicate a floating point number
1212 when the radix is hex. */
1213 if ((!hex && !got_e && tolower (p[0]) == 'e')
1214 || (hex && !got_e && tolower (p[0] == 'p')))
1215 got_dot = got_e = 1;
1216 /* A '.' always indicates a decimal floating point number
1217 regardless of the radix. If we have a '..' then its the
1218 end of the number and the beginning of a slice. */
1219 else if (!got_dot && (p[0] == '.' && p[1] != '.'))
1221 /* This is the sign of the exponent, not the end of the number. */
1222 else if (got_e && (tolower (p[-1]) == 'e' || tolower (p[-1]) == 'p')
1223 && (*p == '-' || *p == '+'))
1225 /* We will take any letters or digits, ignoring any embedded '_'.
1226 parse_number will complain if past the radix, or if L or U are
1228 else if ((*p < '0' || *p > '9') && (*p != '_')
1229 && ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z')))
1233 toktype = parse_number (par_state, tokstart, p - tokstart,
1234 got_dot|got_e, &yylval);
1235 if (toktype == ERROR)
1237 char *err_copy = (char *) alloca (p - tokstart + 1);
1239 memcpy (err_copy, tokstart, p - tokstart);
1240 err_copy[p - tokstart] = 0;
1241 error (_("Invalid number \"%s\"."), err_copy);
1249 const char *p = &tokstart[1];
1250 size_t len = strlen ("entry");
1252 while (isspace (*p))
1254 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1288 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
1290 if (result == CHARACTER_LITERAL)
1293 error (_("Empty character constant."));
1294 else if (host_len > 2 && c == '\'')
1297 namelen = lexptr - tokstart - 1;
1300 else if (host_len > 1)
1301 error (_("Invalid character constant."));
1307 if (!(c == '_' || c == '$'
1308 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1309 /* We must have come across a bad character (e.g. ';'). */
1310 error (_("Invalid character '%c' in expression"), c);
1312 /* It's a name. See how long it is. */
1314 for (c = tokstart[namelen];
1315 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1316 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1317 c = tokstart[++namelen];
1319 /* The token "if" terminates the expression and is NOT
1320 removed from the input stream. */
1321 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1324 /* For the same reason (breakpoint conditions), "thread N"
1325 terminates the expression. "thread" could be an identifier, but
1326 an identifier is never followed by a number without intervening
1327 punctuation. "task" is similar. Handle abbreviations of these,
1328 similarly to breakpoint.c:find_condition_and_thread. */
1330 && (strncmp (tokstart, "thread", namelen) == 0
1331 || strncmp (tokstart, "task", namelen) == 0)
1332 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1334 const char *p = tokstart + namelen + 1;
1336 while (*p == ' ' || *p == '\t')
1338 if (*p >= '0' && *p <= '9')
1346 yylval.sval.ptr = tokstart;
1347 yylval.sval.length = namelen;
1349 /* Catch specific keywords. */
1350 copy = copy_name (yylval.sval);
1351 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
1352 if (strcmp (copy, ident_tokens[i].oper) == 0)
1354 /* It is ok to always set this, even though we don't always
1355 strictly need to. */
1356 yylval.opcode = ident_tokens[i].opcode;
1357 return ident_tokens[i].token;
1360 if (*tokstart == '$')
1361 return DOLLAR_VARIABLE;
1364 = language_lookup_primitive_type (parse_language (par_state),
1365 parse_gdbarch (par_state), copy);
1366 if (yylval.tsym.type != NULL)
1369 /* Input names that aren't symbols but ARE valid hex numbers,
1370 when the input radix permits them, can be names or numbers
1371 depending on the parse. Note we support radixes > 16 here. */
1372 if ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1373 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))
1375 YYSTYPE newlval; /* Its value is ignored. */
1376 int hextype = parse_number (par_state, tokstart, namelen, 0, &newlval);
1377 if (hextype == INTEGER_LITERAL)
1381 if (parse_completion && *lexptr == '\0')
1382 saw_name_at_eof = 1;
1387 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
1394 DEF_VEC_O (token_and_value);
1396 /* A FIFO of tokens that have been read but not yet returned to the
1398 static VEC (token_and_value) *token_fifo;
1400 /* Non-zero if the lexer should return tokens from the FIFO. */
1403 /* Temporary storage for yylex; this holds symbol names as they are
1405 static struct obstack name_obstack;
1407 /* Classify an IDENTIFIER token. The contents of the token are in `yylval'.
1408 Updates yylval and returns the new token type. BLOCK is the block
1409 in which lookups start; this can be NULL to mean the global scope. */
1412 classify_name (struct parser_state *par_state, const struct block *block)
1414 struct block_symbol sym;
1416 struct field_of_this_result is_a_field_of_this;
1418 copy = copy_name (yylval.sval);
1420 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
1421 if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)
1423 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1426 else if (sym.symbol == NULL)
1428 /* Look-up first for a module name, then a type. */
1429 sym = lookup_symbol (copy, block, MODULE_DOMAIN, NULL);
1430 if (sym.symbol == NULL)
1431 sym = lookup_symbol (copy, block, STRUCT_DOMAIN, NULL);
1433 if (sym.symbol != NULL)
1435 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1439 return UNKNOWN_NAME;
1445 /* Like classify_name, but used by the inner loop of the lexer, when a
1446 name might have already been seen. CONTEXT is the context type, or
1447 NULL if this is the first component of a name. */
1450 classify_inner_name (struct parser_state *par_state,
1451 const struct block *block, struct type *context)
1456 if (context == NULL)
1457 return classify_name (par_state, block);
1459 type = check_typedef (context);
1460 if (!type_aggregate_p (type))
1463 copy = copy_name (yylval.ssym.stoken);
1464 yylval.ssym.sym = d_lookup_nested_symbol (type, copy, block);
1466 if (yylval.ssym.sym.symbol == NULL)
1469 if (SYMBOL_CLASS (yylval.ssym.sym.symbol) == LOC_TYPEDEF)
1471 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
1478 /* The outer level of a two-level lexer. This calls the inner lexer
1479 to return tokens. It then either returns these tokens, or
1480 aggregates them into a larger token. This lets us work around a
1481 problem in our parsing approach, where the parser could not
1482 distinguish between qualified names and qualified types at the
1488 token_and_value current;
1490 struct type *context_type = NULL;
1491 int last_to_examine, next_to_examine, checkpoint;
1492 const struct block *search_block;
1494 if (popping && !VEC_empty (token_and_value, token_fifo))
1498 /* Read the first token and decide what to do. */
1499 current.token = lex_one_token (pstate);
1500 if (current.token != IDENTIFIER && current.token != '.')
1501 return current.token;
1503 /* Read any sequence of alternating "." and identifier tokens into
1505 current.value = yylval;
1506 VEC_safe_push (token_and_value, token_fifo, ¤t);
1507 last_was_dot = current.token == '.';
1511 current.token = lex_one_token (pstate);
1512 current.value = yylval;
1513 VEC_safe_push (token_and_value, token_fifo, ¤t);
1515 if ((last_was_dot && current.token != IDENTIFIER)
1516 || (!last_was_dot && current.token != '.'))
1519 last_was_dot = !last_was_dot;
1523 /* We always read one extra token, so compute the number of tokens
1524 to examine accordingly. */
1525 last_to_examine = VEC_length (token_and_value, token_fifo) - 2;
1526 next_to_examine = 0;
1528 current = *VEC_index (token_and_value, token_fifo, next_to_examine);
1531 /* If we are not dealing with a typename, now is the time to find out. */
1532 if (current.token == IDENTIFIER)
1534 yylval = current.value;
1535 current.token = classify_name (pstate, expression_context_block);
1536 current.value = yylval;
1539 /* If the IDENTIFIER is not known, it could be a package symbol,
1540 first try building up a name until we find the qualified module. */
1541 if (current.token == UNKNOWN_NAME)
1543 obstack_free (&name_obstack, obstack_base (&name_obstack));
1544 obstack_grow (&name_obstack, current.value.sval.ptr,
1545 current.value.sval.length);
1549 while (next_to_examine <= last_to_examine)
1551 token_and_value *next;
1553 next = VEC_index (token_and_value, token_fifo, next_to_examine);
1556 if (next->token == IDENTIFIER && last_was_dot)
1558 /* Update the partial name we are constructing. */
1559 obstack_grow_str (&name_obstack, ".");
1560 obstack_grow (&name_obstack, next->value.sval.ptr,
1561 next->value.sval.length);
1563 yylval.sval.ptr = obstack_base (&name_obstack);
1564 yylval.sval.length = obstack_object_size (&name_obstack);
1566 current.token = classify_name (pstate, expression_context_block);
1567 current.value = yylval;
1569 /* We keep going until we find a TYPENAME. */
1570 if (current.token == TYPENAME)
1572 /* Install it as the first token in the FIFO. */
1573 VEC_replace (token_and_value, token_fifo, 0, ¤t);
1574 VEC_block_remove (token_and_value, token_fifo, 1,
1575 next_to_examine - 1);
1579 else if (next->token == '.' && !last_was_dot)
1583 /* We've reached the end of the name. */
1588 /* Reset our current token back to the start, if we found nothing
1589 this means that we will just jump to do pop. */
1590 current = *VEC_index (token_and_value, token_fifo, 0);
1591 next_to_examine = 1;
1593 if (current.token != TYPENAME && current.token != '.')
1596 obstack_free (&name_obstack, obstack_base (&name_obstack));
1598 if (current.token == '.')
1599 search_block = NULL;
1602 gdb_assert (current.token == TYPENAME);
1603 search_block = expression_context_block;
1604 obstack_grow (&name_obstack, current.value.sval.ptr,
1605 current.value.sval.length);
1606 context_type = current.value.tsym.type;
1610 last_was_dot = current.token == '.';
1612 while (next_to_examine <= last_to_examine)
1614 token_and_value *next;
1616 next = VEC_index (token_and_value, token_fifo, next_to_examine);
1619 if (next->token == IDENTIFIER && last_was_dot)
1623 yylval = next->value;
1624 classification = classify_inner_name (pstate, search_block,
1626 /* We keep going until we either run out of names, or until
1627 we have a qualified name which is not a type. */
1628 if (classification != TYPENAME && classification != IDENTIFIER)
1631 /* Accept up to this token. */
1632 checkpoint = next_to_examine;
1634 /* Update the partial name we are constructing. */
1635 if (context_type != NULL)
1637 /* We don't want to put a leading "." into the name. */
1638 obstack_grow_str (&name_obstack, ".");
1640 obstack_grow (&name_obstack, next->value.sval.ptr,
1641 next->value.sval.length);
1643 yylval.sval.ptr = obstack_base (&name_obstack);
1644 yylval.sval.length = obstack_object_size (&name_obstack);
1645 current.value = yylval;
1646 current.token = classification;
1650 if (classification == IDENTIFIER)
1653 context_type = yylval.tsym.type;
1655 else if (next->token == '.' && !last_was_dot)
1659 /* We've reached the end of the name. */
1664 /* If we have a replacement token, install it as the first token in
1665 the FIFO, and delete the other constituent tokens. */
1668 VEC_replace (token_and_value, token_fifo, 0, ¤t);
1670 VEC_block_remove (token_and_value, token_fifo, 1, checkpoint - 1);
1674 current = *VEC_index (token_and_value, token_fifo, 0);
1675 VEC_ordered_remove (token_and_value, token_fifo, 0);
1676 yylval = current.value;
1677 return current.token;
1681 d_parse (struct parser_state *par_state)
1684 struct cleanup *back_to;
1686 /* Setting up the parser state. */
1687 gdb_assert (par_state != NULL);
1690 back_to = make_cleanup (null_cleanup, NULL);
1692 make_cleanup_restore_integer (&yydebug);
1693 make_cleanup_clear_parser_state (&pstate);
1694 yydebug = parser_debug;
1696 /* Initialize some state used by the lexer. */
1697 last_was_structop = 0;
1698 saw_name_at_eof = 0;
1700 VEC_free (token_and_value, token_fifo);
1702 obstack_init (&name_obstack);
1703 make_cleanup_obstack_free (&name_obstack);
1705 result = yyparse ();
1706 do_cleanups (back_to);
1714 lexptr = prev_lexptr;
1716 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);