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); }
376 CAST_KEYWORD '(' TypeExp ')' UnaryExpression
377 { write_exp_elt_opcode (pstate, UNOP_CAST);
378 write_exp_elt_type (pstate, $3);
379 write_exp_elt_opcode (pstate, UNOP_CAST); }
380 /* C style cast is illegal D, but is still recognised in
381 the grammar, so we keep this around for convenience. */
382 | '(' TypeExp ')' UnaryExpression
383 { write_exp_elt_opcode (pstate, UNOP_CAST);
384 write_exp_elt_type (pstate, $2);
385 write_exp_elt_opcode (pstate, UNOP_CAST); }
390 | PostfixExpression HATHAT UnaryExpression
391 { write_exp_elt_opcode (pstate, BINOP_EXP); }
396 | PostfixExpression '.' COMPLETE
398 mark_struct_expression (pstate);
399 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
402 write_exp_string (pstate, s);
403 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
404 | PostfixExpression '.' IDENTIFIER
405 { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
406 write_exp_string (pstate, $3);
407 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
408 | PostfixExpression '.' IDENTIFIER COMPLETE
409 { mark_struct_expression (pstate);
410 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
411 write_exp_string (pstate, $3);
412 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
413 | PostfixExpression INCREMENT
414 { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); }
415 | PostfixExpression DECREMENT
416 { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); }
425 | ArgumentList ',' AssignExpression
436 PostfixExpression '('
437 { start_arglist (); }
439 { write_exp_elt_opcode (pstate, OP_FUNCALL);
440 write_exp_elt_longcst (pstate, (LONGEST) end_arglist ());
441 write_exp_elt_opcode (pstate, OP_FUNCALL); }
445 PostfixExpression '[' ArgumentList ']'
446 { if (arglist_len > 0)
448 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
449 write_exp_elt_longcst (pstate, (LONGEST) arglist_len);
450 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
453 write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT);
458 PostfixExpression '[' ']'
459 { /* Do nothing. */ }
460 | PostfixExpression '[' AssignExpression DOTDOT AssignExpression ']'
461 { write_exp_elt_opcode (pstate, TERNOP_SLICE); }
466 { /* Do nothing. */ }
468 { struct bound_minimal_symbol msymbol;
469 char *copy = copy_name ($1);
470 struct field_of_this_result is_a_field_of_this;
471 struct block_symbol sym;
473 /* Handle VAR, which could be local or global. */
474 sym = lookup_symbol (copy, expression_context_block, VAR_DOMAIN,
475 &is_a_field_of_this);
476 if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
478 if (symbol_read_needs_frame (sym.symbol))
480 if (innermost_block == 0
481 || contained_in (sym.block, innermost_block))
482 innermost_block = sym.block;
485 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
486 /* We want to use the selected frame, not another more inner frame
487 which happens to be in the same block. */
488 write_exp_elt_block (pstate, NULL);
489 write_exp_elt_sym (pstate, sym.symbol);
490 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
492 else if (is_a_field_of_this.type != NULL)
494 /* It hangs off of `this'. Must not inadvertently convert from a
495 method call to data ref. */
496 if (innermost_block == 0
497 || contained_in (sym.block, innermost_block))
498 innermost_block = sym.block;
499 write_exp_elt_opcode (pstate, OP_THIS);
500 write_exp_elt_opcode (pstate, OP_THIS);
501 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
502 write_exp_string (pstate, $1);
503 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
507 /* Lookup foreign name in global static symbols. */
508 msymbol = lookup_bound_minimal_symbol (copy);
509 if (msymbol.minsym != NULL)
510 write_exp_msymbol (pstate, msymbol);
511 else if (!have_full_symbols () && !have_partial_symbols ())
512 error (_("No symbol table is loaded. Use the \"file\" command"));
514 error (_("No symbol \"%s\" in current context."), copy);
517 | TypeExp '.' IdentifierExp
518 { struct type *type = check_typedef ($1);
520 /* Check if the qualified name is in the global
521 context. However if the symbol has not already
522 been resolved, it's not likely to be found. */
523 if (TYPE_CODE (type) == TYPE_CODE_MODULE)
525 struct bound_minimal_symbol msymbol;
526 struct block_symbol sym;
527 const char *type_name = TYPE_SAFE_NAME (type);
528 int type_name_len = strlen (type_name);
531 name = xstrprintf ("%.*s.%.*s",
532 type_name_len, type_name,
534 make_cleanup (xfree, name);
537 lookup_symbol (name, (const struct block *) NULL,
541 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
542 write_exp_elt_block (pstate, sym.block);
543 write_exp_elt_sym (pstate, sym.symbol);
544 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
548 msymbol = lookup_bound_minimal_symbol (name);
549 if (msymbol.minsym != NULL)
550 write_exp_msymbol (pstate, msymbol);
551 else if (!have_full_symbols () && !have_partial_symbols ())
552 error (_("No symbol table is loaded. Use the \"file\" command."));
554 error (_("No symbol \"%s\" in current context."), name);
557 /* Check if the qualified name resolves as a member
558 of an aggregate or an enum type. */
559 if (!type_aggregate_p (type))
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 = (char *) 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
652 = XRESIZEVEC (struct typed_stoken, $$.tokens, $$.len);
654 p = (char *) 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 /* Return true if the type is aggregate-like. */
701 type_aggregate_p (struct type *type)
703 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
704 || TYPE_CODE (type) == TYPE_CODE_UNION
705 || (TYPE_CODE (type) == TYPE_CODE_ENUM
706 && TYPE_DECLARED_CLASS (type)));
709 /* Take care of parsing a number (anything that starts with a digit).
710 Set yylval and return the token type; update lexptr.
711 LEN is the number of characters in it. */
713 /*** Needs some error checking for the float case ***/
716 parse_number (struct parser_state *ps, const char *p,
717 int len, int parsed_float, YYSTYPE *putithere)
725 int base = input_radix;
729 /* We have found a "L" or "U" suffix. */
730 int found_suffix = 0;
733 struct type *signed_type;
734 struct type *unsigned_type;
738 const struct builtin_d_type *builtin_d_types;
743 /* Strip out all embedded '_' before passing to parse_float. */
744 s = (char *) alloca (len + 1);
755 if (! parse_float (s, len, &putithere->typed_val_float.dval, &suffix))
758 suffix_len = s + len - suffix;
762 putithere->typed_val_float.type
763 = parse_d_type (ps)->builtin_double;
765 else if (suffix_len == 1)
767 /* Check suffix for `f', `l', or `i' (float, real, or idouble). */
768 if (tolower (*suffix) == 'f')
770 putithere->typed_val_float.type
771 = parse_d_type (ps)->builtin_float;
773 else if (tolower (*suffix) == 'l')
775 putithere->typed_val_float.type
776 = parse_d_type (ps)->builtin_real;
778 else if (tolower (*suffix) == 'i')
780 putithere->typed_val_float.type
781 = parse_d_type (ps)->builtin_idouble;
786 else if (suffix_len == 2)
788 /* Check suffix for `fi' or `li' (ifloat or ireal). */
789 if (tolower (suffix[0]) == 'f' && tolower (suffix[1] == 'i'))
791 putithere->typed_val_float.type
792 = parse_d_type (ps)->builtin_ifloat;
794 else if (tolower (suffix[0]) == 'l' && tolower (suffix[1] == 'i'))
796 putithere->typed_val_float.type
797 = parse_d_type (ps)->builtin_ireal;
805 return FLOAT_LITERAL;
808 /* Handle base-switching prefixes 0x, 0b, 0 */
841 continue; /* Ignore embedded '_'. */
842 if (c >= 'A' && c <= 'Z')
844 if (c != 'l' && c != 'u')
846 if (c >= '0' && c <= '9')
854 if (base > 10 && c >= 'a' && c <= 'f')
858 n += i = c - 'a' + 10;
860 else if (c == 'l' && long_p == 0)
865 else if (c == 'u' && unsigned_p == 0)
871 return ERROR; /* Char not a digit */
874 return ERROR; /* Invalid digit in this base. */
875 /* Portably test for integer overflow. */
876 if (c != 'l' && c != 'u')
878 ULONGEST n2 = prevn * base;
879 if ((n2 / base != prevn) || (n2 + i < prevn))
880 error (_("Numeric constant too large."));
885 /* An integer constant is an int or a long. An L suffix forces it to
886 be long, and a U suffix forces it to be unsigned. To figure out
887 whether it fits, we shift it right and see whether anything remains.
888 Note that we can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or
889 more in one operation, because many compilers will warn about such a
890 shift (which always produces a zero result). To deal with the case
891 where it is we just always shift the value more than once, with fewer
893 un = (ULONGEST) n >> 2;
894 if (long_p == 0 && (un >> 30) == 0)
896 high_bit = ((ULONGEST) 1) << 31;
897 signed_type = parse_d_type (ps)->builtin_int;
898 /* For decimal notation, keep the sign of the worked out type. */
899 if (base == 10 && !unsigned_p)
900 unsigned_type = parse_d_type (ps)->builtin_long;
902 unsigned_type = parse_d_type (ps)->builtin_uint;
907 if (sizeof (ULONGEST) * HOST_CHAR_BIT < 64)
908 /* A long long does not fit in a LONGEST. */
909 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
912 high_bit = (ULONGEST) 1 << shift;
913 signed_type = parse_d_type (ps)->builtin_long;
914 unsigned_type = parse_d_type (ps)->builtin_ulong;
917 putithere->typed_val_int.val = n;
919 /* If the high bit of the worked out type is set then this number
920 has to be unsigned_type. */
921 if (unsigned_p || (n & high_bit))
922 putithere->typed_val_int.type = unsigned_type;
924 putithere->typed_val_int.type = signed_type;
926 return INTEGER_LITERAL;
929 /* Temporary obstack used for holding strings. */
930 static struct obstack tempbuf;
931 static int tempbuf_init;
933 /* Parse a string or character literal from TOKPTR. The string or
934 character may be wide or unicode. *OUTPTR is set to just after the
935 end of the literal in the input string. The resulting token is
936 stored in VALUE. This returns a token value, either STRING or
937 CHAR, depending on what was parsed. *HOST_CHARS is set to the
938 number of host characters in the literal. */
941 parse_string_or_char (const char *tokptr, const char **outptr,
942 struct typed_stoken *value, int *host_chars)
946 /* Build the gdb internal form of the input string in tempbuf. Note
947 that the buffer is null byte terminated *only* for the
948 convenience of debugging gdb itself and printing the buffer
949 contents when the buffer contains no embedded nulls. Gdb does
950 not depend upon the buffer being null byte terminated, it uses
951 the length string instead. This allows gdb to handle C strings
952 (as well as strings in other languages) with embedded null
958 obstack_free (&tempbuf, NULL);
959 obstack_init (&tempbuf);
961 /* Skip the quote. */
973 *host_chars += c_parse_escape (&tokptr, &tempbuf);
979 obstack_1grow (&tempbuf, c);
981 /* FIXME: this does the wrong thing with multi-byte host
982 characters. We could use mbrlen here, but that would
983 make "set host-charset" a bit less useful. */
988 if (*tokptr != quote)
990 if (quote == '"' || quote == '`')
991 error (_("Unterminated string in expression."));
993 error (_("Unmatched single quote."));
997 /* FIXME: should instead use own language string_type enum
998 and handle D-specific string suffixes here. */
1000 value->type = C_CHAR;
1002 value->type = C_STRING;
1004 value->ptr = obstack_base (&tempbuf);
1005 value->length = obstack_object_size (&tempbuf);
1009 return quote == '\'' ? CHARACTER_LITERAL : STRING_LITERAL;
1016 enum exp_opcode opcode;
1019 static const struct token tokentab3[] =
1021 {"^^=", ASSIGN_MODIFY, BINOP_EXP},
1022 {"<<=", ASSIGN_MODIFY, BINOP_LSH},
1023 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1026 static const struct token tokentab2[] =
1028 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1029 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1030 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1031 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1032 {"%=", ASSIGN_MODIFY, BINOP_REM},
1033 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1034 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1035 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1036 {"++", INCREMENT, BINOP_END},
1037 {"--", DECREMENT, BINOP_END},
1038 {"&&", ANDAND, BINOP_END},
1039 {"||", OROR, BINOP_END},
1040 {"^^", HATHAT, BINOP_END},
1041 {"<<", LSH, BINOP_END},
1042 {">>", RSH, BINOP_END},
1043 {"==", EQUAL, BINOP_END},
1044 {"!=", NOTEQUAL, BINOP_END},
1045 {"<=", LEQ, BINOP_END},
1046 {">=", GEQ, BINOP_END},
1047 {"..", DOTDOT, BINOP_END},
1050 /* Identifier-like tokens. */
1051 static const struct token ident_tokens[] =
1053 {"is", IDENTITY, BINOP_END},
1054 {"!is", NOTIDENTITY, BINOP_END},
1056 {"cast", CAST_KEYWORD, OP_NULL},
1057 {"const", CONST_KEYWORD, OP_NULL},
1058 {"immutable", IMMUTABLE_KEYWORD, OP_NULL},
1059 {"shared", SHARED_KEYWORD, OP_NULL},
1060 {"super", SUPER_KEYWORD, OP_NULL},
1062 {"null", NULL_KEYWORD, OP_NULL},
1063 {"true", TRUE_KEYWORD, OP_NULL},
1064 {"false", FALSE_KEYWORD, OP_NULL},
1066 {"init", INIT_KEYWORD, OP_NULL},
1067 {"sizeof", SIZEOF_KEYWORD, OP_NULL},
1068 {"typeof", TYPEOF_KEYWORD, OP_NULL},
1069 {"typeid", TYPEID_KEYWORD, OP_NULL},
1071 {"delegate", DELEGATE_KEYWORD, OP_NULL},
1072 {"function", FUNCTION_KEYWORD, OP_NULL},
1073 {"struct", STRUCT_KEYWORD, OP_NULL},
1074 {"union", UNION_KEYWORD, OP_NULL},
1075 {"class", CLASS_KEYWORD, OP_NULL},
1076 {"interface", INTERFACE_KEYWORD, OP_NULL},
1077 {"enum", ENUM_KEYWORD, OP_NULL},
1078 {"template", TEMPLATE_KEYWORD, OP_NULL},
1081 /* This is set if a NAME token appeared at the very end of the input
1082 string, with no whitespace separating the name from the EOF. This
1083 is used only when parsing to do field name completion. */
1084 static int saw_name_at_eof;
1086 /* This is set if the previously-returned token was a structure operator.
1087 This is used only when parsing to do field name completion. */
1088 static int last_was_structop;
1090 /* Read one token, getting characters through lexptr. */
1093 lex_one_token (struct parser_state *par_state)
1098 const char *tokstart;
1099 int saw_structop = last_was_structop;
1102 last_was_structop = 0;
1106 prev_lexptr = lexptr;
1109 /* See if it is a special token of length 3. */
1110 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1111 if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
1114 yylval.opcode = tokentab3[i].opcode;
1115 return tokentab3[i].token;
1118 /* See if it is a special token of length 2. */
1119 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1120 if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
1123 yylval.opcode = tokentab2[i].opcode;
1124 return tokentab2[i].token;
1127 switch (c = *tokstart)
1130 /* If we're parsing for field name completion, and the previous
1131 token allows such completion, return a COMPLETE token.
1132 Otherwise, we were already scanning the original text, and
1133 we're really done. */
1134 if (saw_name_at_eof)
1136 saw_name_at_eof = 0;
1139 else if (saw_structop)
1158 if (paren_depth == 0)
1165 if (comma_terminates && paren_depth == 0)
1171 /* Might be a floating point number. */
1172 if (lexptr[1] < '0' || lexptr[1] > '9')
1174 if (parse_completion)
1175 last_was_structop = 1;
1176 goto symbol; /* Nope, must be a symbol. */
1178 /* FALL THRU into number case. */
1191 /* It's a number. */
1192 int got_dot = 0, got_e = 0, toktype;
1193 const char *p = tokstart;
1194 int hex = input_radix > 10;
1196 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1204 /* Hex exponents start with 'p', because 'e' is a valid hex
1205 digit and thus does not indicate a floating point number
1206 when the radix is hex. */
1207 if ((!hex && !got_e && tolower (p[0]) == 'e')
1208 || (hex && !got_e && tolower (p[0] == 'p')))
1209 got_dot = got_e = 1;
1210 /* A '.' always indicates a decimal floating point number
1211 regardless of the radix. If we have a '..' then its the
1212 end of the number and the beginning of a slice. */
1213 else if (!got_dot && (p[0] == '.' && p[1] != '.'))
1215 /* This is the sign of the exponent, not the end of the number. */
1216 else if (got_e && (tolower (p[-1]) == 'e' || tolower (p[-1]) == 'p')
1217 && (*p == '-' || *p == '+'))
1219 /* We will take any letters or digits, ignoring any embedded '_'.
1220 parse_number will complain if past the radix, or if L or U are
1222 else if ((*p < '0' || *p > '9') && (*p != '_')
1223 && ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z')))
1227 toktype = parse_number (par_state, tokstart, p - tokstart,
1228 got_dot|got_e, &yylval);
1229 if (toktype == ERROR)
1231 char *err_copy = (char *) alloca (p - tokstart + 1);
1233 memcpy (err_copy, tokstart, p - tokstart);
1234 err_copy[p - tokstart] = 0;
1235 error (_("Invalid number \"%s\"."), err_copy);
1243 const char *p = &tokstart[1];
1244 size_t len = strlen ("entry");
1246 while (isspace (*p))
1248 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1282 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
1284 if (result == CHARACTER_LITERAL)
1287 error (_("Empty character constant."));
1288 else if (host_len > 2 && c == '\'')
1291 namelen = lexptr - tokstart - 1;
1294 else if (host_len > 1)
1295 error (_("Invalid character constant."));
1301 if (!(c == '_' || c == '$'
1302 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1303 /* We must have come across a bad character (e.g. ';'). */
1304 error (_("Invalid character '%c' in expression"), c);
1306 /* It's a name. See how long it is. */
1308 for (c = tokstart[namelen];
1309 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1310 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1311 c = tokstart[++namelen];
1313 /* The token "if" terminates the expression and is NOT
1314 removed from the input stream. */
1315 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1318 /* For the same reason (breakpoint conditions), "thread N"
1319 terminates the expression. "thread" could be an identifier, but
1320 an identifier is never followed by a number without intervening
1321 punctuation. "task" is similar. Handle abbreviations of these,
1322 similarly to breakpoint.c:find_condition_and_thread. */
1324 && (strncmp (tokstart, "thread", namelen) == 0
1325 || strncmp (tokstart, "task", namelen) == 0)
1326 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1328 const char *p = tokstart + namelen + 1;
1330 while (*p == ' ' || *p == '\t')
1332 if (*p >= '0' && *p <= '9')
1340 yylval.sval.ptr = tokstart;
1341 yylval.sval.length = namelen;
1343 /* Catch specific keywords. */
1344 copy = copy_name (yylval.sval);
1345 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
1346 if (strcmp (copy, ident_tokens[i].oper) == 0)
1348 /* It is ok to always set this, even though we don't always
1349 strictly need to. */
1350 yylval.opcode = ident_tokens[i].opcode;
1351 return ident_tokens[i].token;
1354 if (*tokstart == '$')
1355 return DOLLAR_VARIABLE;
1358 = language_lookup_primitive_type (parse_language (par_state),
1359 parse_gdbarch (par_state), copy);
1360 if (yylval.tsym.type != NULL)
1363 /* Input names that aren't symbols but ARE valid hex numbers,
1364 when the input radix permits them, can be names or numbers
1365 depending on the parse. Note we support radixes > 16 here. */
1366 if ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1367 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))
1369 YYSTYPE newlval; /* Its value is ignored. */
1370 int hextype = parse_number (par_state, tokstart, namelen, 0, &newlval);
1371 if (hextype == INTEGER_LITERAL)
1375 if (parse_completion && *lexptr == '\0')
1376 saw_name_at_eof = 1;
1381 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
1388 DEF_VEC_O (token_and_value);
1390 /* A FIFO of tokens that have been read but not yet returned to the
1392 static VEC (token_and_value) *token_fifo;
1394 /* Non-zero if the lexer should return tokens from the FIFO. */
1397 /* Temporary storage for yylex; this holds symbol names as they are
1399 static struct obstack name_obstack;
1401 /* Classify an IDENTIFIER token. The contents of the token are in `yylval'.
1402 Updates yylval and returns the new token type. BLOCK is the block
1403 in which lookups start; this can be NULL to mean the global scope. */
1406 classify_name (struct parser_state *par_state, const struct block *block)
1408 struct block_symbol sym;
1410 struct field_of_this_result is_a_field_of_this;
1412 copy = copy_name (yylval.sval);
1414 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
1415 if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)
1417 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1420 else if (sym.symbol == NULL)
1422 /* Look-up first for a module name, then a type. */
1423 sym = lookup_symbol (copy, block, MODULE_DOMAIN, NULL);
1424 if (sym.symbol == NULL)
1425 sym = lookup_symbol (copy, block, STRUCT_DOMAIN, NULL);
1427 if (sym.symbol != NULL)
1429 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1433 return UNKNOWN_NAME;
1439 /* Like classify_name, but used by the inner loop of the lexer, when a
1440 name might have already been seen. CONTEXT is the context type, or
1441 NULL if this is the first component of a name. */
1444 classify_inner_name (struct parser_state *par_state,
1445 const struct block *block, struct type *context)
1450 if (context == NULL)
1451 return classify_name (par_state, block);
1453 type = check_typedef (context);
1454 if (!type_aggregate_p (type))
1457 copy = copy_name (yylval.ssym.stoken);
1458 yylval.ssym.sym = d_lookup_nested_symbol (type, copy, block);
1460 if (yylval.ssym.sym.symbol == NULL)
1463 if (SYMBOL_CLASS (yylval.ssym.sym.symbol) == LOC_TYPEDEF)
1465 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
1472 /* The outer level of a two-level lexer. This calls the inner lexer
1473 to return tokens. It then either returns these tokens, or
1474 aggregates them into a larger token. This lets us work around a
1475 problem in our parsing approach, where the parser could not
1476 distinguish between qualified names and qualified types at the
1482 token_and_value current;
1484 struct type *context_type = NULL;
1485 int last_to_examine, next_to_examine, checkpoint;
1486 const struct block *search_block;
1488 if (popping && !VEC_empty (token_and_value, token_fifo))
1492 /* Read the first token and decide what to do. */
1493 current.token = lex_one_token (pstate);
1494 if (current.token != IDENTIFIER && current.token != '.')
1495 return current.token;
1497 /* Read any sequence of alternating "." and identifier tokens into
1499 current.value = yylval;
1500 VEC_safe_push (token_and_value, token_fifo, ¤t);
1501 last_was_dot = current.token == '.';
1505 current.token = lex_one_token (pstate);
1506 current.value = yylval;
1507 VEC_safe_push (token_and_value, token_fifo, ¤t);
1509 if ((last_was_dot && current.token != IDENTIFIER)
1510 || (!last_was_dot && current.token != '.'))
1513 last_was_dot = !last_was_dot;
1517 /* We always read one extra token, so compute the number of tokens
1518 to examine accordingly. */
1519 last_to_examine = VEC_length (token_and_value, token_fifo) - 2;
1520 next_to_examine = 0;
1522 current = *VEC_index (token_and_value, token_fifo, next_to_examine);
1525 /* If we are not dealing with a typename, now is the time to find out. */
1526 if (current.token == IDENTIFIER)
1528 yylval = current.value;
1529 current.token = classify_name (pstate, expression_context_block);
1530 current.value = yylval;
1533 /* If the IDENTIFIER is not known, it could be a package symbol,
1534 first try building up a name until we find the qualified module. */
1535 if (current.token == UNKNOWN_NAME)
1537 obstack_free (&name_obstack, obstack_base (&name_obstack));
1538 obstack_grow (&name_obstack, current.value.sval.ptr,
1539 current.value.sval.length);
1543 while (next_to_examine <= last_to_examine)
1545 token_and_value *next;
1547 next = VEC_index (token_and_value, token_fifo, next_to_examine);
1550 if (next->token == IDENTIFIER && last_was_dot)
1552 /* Update the partial name we are constructing. */
1553 obstack_grow_str (&name_obstack, ".");
1554 obstack_grow (&name_obstack, next->value.sval.ptr,
1555 next->value.sval.length);
1557 yylval.sval.ptr = obstack_base (&name_obstack);
1558 yylval.sval.length = obstack_object_size (&name_obstack);
1560 current.token = classify_name (pstate, expression_context_block);
1561 current.value = yylval;
1563 /* We keep going until we find a TYPENAME. */
1564 if (current.token == TYPENAME)
1566 /* Install it as the first token in the FIFO. */
1567 VEC_replace (token_and_value, token_fifo, 0, ¤t);
1568 VEC_block_remove (token_and_value, token_fifo, 1,
1569 next_to_examine - 1);
1573 else if (next->token == '.' && !last_was_dot)
1577 /* We've reached the end of the name. */
1582 /* Reset our current token back to the start, if we found nothing
1583 this means that we will just jump to do pop. */
1584 current = *VEC_index (token_and_value, token_fifo, 0);
1585 next_to_examine = 1;
1587 if (current.token != TYPENAME && current.token != '.')
1590 obstack_free (&name_obstack, obstack_base (&name_obstack));
1592 if (current.token == '.')
1593 search_block = NULL;
1596 gdb_assert (current.token == TYPENAME);
1597 search_block = expression_context_block;
1598 obstack_grow (&name_obstack, current.value.sval.ptr,
1599 current.value.sval.length);
1600 context_type = current.value.tsym.type;
1604 last_was_dot = current.token == '.';
1606 while (next_to_examine <= last_to_examine)
1608 token_and_value *next;
1610 next = VEC_index (token_and_value, token_fifo, next_to_examine);
1613 if (next->token == IDENTIFIER && last_was_dot)
1617 yylval = next->value;
1618 classification = classify_inner_name (pstate, search_block,
1620 /* We keep going until we either run out of names, or until
1621 we have a qualified name which is not a type. */
1622 if (classification != TYPENAME && classification != IDENTIFIER)
1625 /* Accept up to this token. */
1626 checkpoint = next_to_examine;
1628 /* Update the partial name we are constructing. */
1629 if (context_type != NULL)
1631 /* We don't want to put a leading "." into the name. */
1632 obstack_grow_str (&name_obstack, ".");
1634 obstack_grow (&name_obstack, next->value.sval.ptr,
1635 next->value.sval.length);
1637 yylval.sval.ptr = obstack_base (&name_obstack);
1638 yylval.sval.length = obstack_object_size (&name_obstack);
1639 current.value = yylval;
1640 current.token = classification;
1644 if (classification == IDENTIFIER)
1647 context_type = yylval.tsym.type;
1649 else if (next->token == '.' && !last_was_dot)
1653 /* We've reached the end of the name. */
1658 /* If we have a replacement token, install it as the first token in
1659 the FIFO, and delete the other constituent tokens. */
1662 VEC_replace (token_and_value, token_fifo, 0, ¤t);
1664 VEC_block_remove (token_and_value, token_fifo, 1, checkpoint - 1);
1668 current = *VEC_index (token_and_value, token_fifo, 0);
1669 VEC_ordered_remove (token_and_value, token_fifo, 0);
1670 yylval = current.value;
1671 return current.token;
1675 d_parse (struct parser_state *par_state)
1678 struct cleanup *back_to;
1680 /* Setting up the parser state. */
1681 gdb_assert (par_state != NULL);
1684 back_to = make_cleanup (null_cleanup, NULL);
1686 make_cleanup_restore_integer (&yydebug);
1687 make_cleanup_clear_parser_state (&pstate);
1688 yydebug = parser_debug;
1690 /* Initialize some state used by the lexer. */
1691 last_was_structop = 0;
1692 saw_name_at_eof = 0;
1694 VEC_free (token_and_value, token_fifo);
1696 obstack_init (&name_obstack);
1697 make_cleanup_obstack_free (&name_obstack);
1699 result = yyparse ();
1700 do_cleanups (back_to);
1708 lexptr = prev_lexptr;
1710 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);