1 /* YACC parser for D expressions, for GDB.
3 Copyright (C) 2014-2021 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 */
54 #include "type-stack.h"
57 #define parse_type(ps) builtin_type (ps->gdbarch ())
58 #define parse_d_type(ps) builtin_d_type (ps->gdbarch ())
60 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
62 #define GDB_YY_REMAP_PREFIX d_
65 /* The state of the parser, used internally when we are parsing the
68 static struct parser_state *pstate = NULL;
70 /* The current type stack. */
71 static struct type_stack *type_stack;
75 static int yylex (void);
77 static void yyerror (const char *);
79 static int type_aggregate_p (struct type *);
85 /* Although the yacc "value" of an expression is not used,
86 since the result is stored in the structure being created,
87 other node types do have values. */
101 struct typed_stoken tsval;
104 struct symtoken ssym;
107 enum exp_opcode opcode;
108 struct stoken_vector svec;
112 /* YYSTYPE gets defined by %union */
113 static int parse_number (struct parser_state *, const char *,
114 int, int, YYSTYPE *);
117 %token <sval> IDENTIFIER UNKNOWN_NAME
118 %token <tsym> TYPENAME
119 %token <voidval> COMPLETE
121 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
122 but which would parse as a valid number in the current input radix.
123 E.g. "c" when input_radix==16. Depending on the parse, it will be
124 turned into a name or into a number. */
126 %token <sval> NAME_OR_INT
128 %token <typed_val_int> INTEGER_LITERAL
129 %token <typed_val_float> FLOAT_LITERAL
130 %token <tsval> CHARACTER_LITERAL
131 %token <tsval> STRING_LITERAL
133 %type <svec> StringExp
134 %type <tval> BasicType TypeExp
135 %type <sval> IdentifierExp
136 %type <ival> ArrayLiteral
141 /* Keywords that have a constant value. */
142 %token TRUE_KEYWORD FALSE_KEYWORD NULL_KEYWORD
143 /* Class 'super' accessor. */
146 %token CAST_KEYWORD SIZEOF_KEYWORD
147 %token TYPEOF_KEYWORD TYPEID_KEYWORD
149 /* Comparison keywords. */
150 /* Type storage classes. */
151 %token IMMUTABLE_KEYWORD CONST_KEYWORD SHARED_KEYWORD
152 /* Non-scalar type keywords. */
153 %token STRUCT_KEYWORD UNION_KEYWORD
154 %token CLASS_KEYWORD INTERFACE_KEYWORD
155 %token ENUM_KEYWORD TEMPLATE_KEYWORD
156 %token DELEGATE_KEYWORD FUNCTION_KEYWORD
158 %token <sval> DOLLAR_VARIABLE
160 %token <opcode> ASSIGN_MODIFY
163 %right '=' ASSIGN_MODIFY
170 %left EQUAL NOTEQUAL '<' '>' LEQ GEQ
175 %left IDENTITY NOTIDENTITY
176 %right INCREMENT DECREMENT
188 /* Expressions, including the comma operator. */
196 | AssignExpression ',' CommaExpression
197 { pstate->wrap2<comma_operation> (); }
201 ConditionalExpression
202 | ConditionalExpression '=' AssignExpression
203 { pstate->wrap2<assign_operation> (); }
204 | ConditionalExpression ASSIGN_MODIFY AssignExpression
206 operation_up rhs = pstate->pop ();
207 operation_up lhs = pstate->pop ();
208 pstate->push_new<assign_modify_operation>
209 ($2, std::move (lhs), std::move (rhs));
213 ConditionalExpression:
215 | OrOrExpression '?' Expression ':' ConditionalExpression
217 operation_up last = pstate->pop ();
218 operation_up mid = pstate->pop ();
219 operation_up first = pstate->pop ();
220 pstate->push_new<ternop_cond_operation>
221 (std::move (first), std::move (mid),
228 | OrOrExpression OROR AndAndExpression
229 { pstate->wrap2<logical_or_operation> (); }
234 | AndAndExpression ANDAND OrExpression
235 { pstate->wrap2<logical_and_operation> (); }
240 | OrExpression '|' XorExpression
241 { pstate->wrap2<bitwise_ior_operation> (); }
246 | XorExpression '^' AndExpression
247 { pstate->wrap2<bitwise_xor_operation> (); }
252 | AndExpression '&' CmpExpression
253 { pstate->wrap2<bitwise_and_operation> (); }
264 ShiftExpression EQUAL ShiftExpression
265 { pstate->wrap2<equal_operation> (); }
266 | ShiftExpression NOTEQUAL ShiftExpression
267 { pstate->wrap2<notequal_operation> (); }
271 ShiftExpression IDENTITY ShiftExpression
272 { pstate->wrap2<equal_operation> (); }
273 | ShiftExpression NOTIDENTITY ShiftExpression
274 { pstate->wrap2<notequal_operation> (); }
278 ShiftExpression '<' ShiftExpression
279 { pstate->wrap2<less_operation> (); }
280 | ShiftExpression LEQ ShiftExpression
281 { pstate->wrap2<leq_operation> (); }
282 | ShiftExpression '>' ShiftExpression
283 { pstate->wrap2<gtr_operation> (); }
284 | ShiftExpression GEQ ShiftExpression
285 { pstate->wrap2<geq_operation> (); }
290 | ShiftExpression LSH AddExpression
291 { pstate->wrap2<lsh_operation> (); }
292 | ShiftExpression RSH AddExpression
293 { pstate->wrap2<rsh_operation> (); }
298 | AddExpression '+' MulExpression
299 { pstate->wrap2<add_operation> (); }
300 | AddExpression '-' MulExpression
301 { pstate->wrap2<sub_operation> (); }
302 | AddExpression '~' MulExpression
303 { pstate->wrap2<concat_operation> (); }
308 | MulExpression '*' UnaryExpression
309 { pstate->wrap2<mul_operation> (); }
310 | MulExpression '/' UnaryExpression
311 { pstate->wrap2<div_operation> (); }
312 | MulExpression '%' UnaryExpression
313 { pstate->wrap2<rem_operation> (); }
317 { pstate->wrap<unop_addr_operation> (); }
318 | INCREMENT UnaryExpression
319 { pstate->wrap<preinc_operation> (); }
320 | DECREMENT UnaryExpression
321 { pstate->wrap<predec_operation> (); }
322 | '*' UnaryExpression
323 { pstate->wrap<unop_ind_operation> (); }
324 | '-' UnaryExpression
325 { pstate->wrap<unary_neg_operation> (); }
326 | '+' UnaryExpression
327 { pstate->wrap<unary_plus_operation> (); }
328 | '!' UnaryExpression
329 { pstate->wrap<unary_logical_not_operation> (); }
330 | '~' UnaryExpression
331 { pstate->wrap<unary_complement_operation> (); }
332 | TypeExp '.' SIZEOF_KEYWORD
333 { pstate->wrap<unop_sizeof_operation> (); }
339 CAST_KEYWORD '(' TypeExp ')' UnaryExpression
340 { pstate->wrap2<unop_cast_type_operation> (); }
341 /* C style cast is illegal D, but is still recognised in
342 the grammar, so we keep this around for convenience. */
343 | '(' TypeExp ')' UnaryExpression
344 { pstate->wrap2<unop_cast_type_operation> (); }
349 | PostfixExpression HATHAT UnaryExpression
350 { pstate->wrap2<exp_operation> (); }
355 | PostfixExpression '.' COMPLETE
357 structop_base_operation *op
358 = new structop_ptr_operation (pstate->pop (), "");
359 pstate->mark_struct_expression (op);
360 pstate->push (operation_up (op));
362 | PostfixExpression '.' IDENTIFIER
364 pstate->push_new<structop_operation>
365 (pstate->pop (), copy_name ($3));
367 | PostfixExpression '.' IDENTIFIER COMPLETE
369 structop_base_operation *op
370 = new structop_operation (pstate->pop (), copy_name ($3));
371 pstate->mark_struct_expression (op);
372 pstate->push (operation_up (op));
374 | PostfixExpression '.' SIZEOF_KEYWORD
375 { pstate->wrap<unop_sizeof_operation> (); }
376 | PostfixExpression INCREMENT
377 { pstate->wrap<postinc_operation> (); }
378 | PostfixExpression DECREMENT
379 { pstate->wrap<postdec_operation> (); }
387 { pstate->arglist_len = 1; }
388 | ArgumentList ',' AssignExpression
389 { pstate->arglist_len++; }
394 { pstate->arglist_len = 0; }
399 PostfixExpression '('
400 { pstate->start_arglist (); }
403 std::vector<operation_up> args
404 = pstate->pop_vector (pstate->end_arglist ());
405 pstate->push_new<funcall_operation>
406 (pstate->pop (), std::move (args));
411 PostfixExpression '[' ArgumentList ']'
412 { if (pstate->arglist_len > 0)
414 std::vector<operation_up> args
415 = pstate->pop_vector (pstate->arglist_len);
416 pstate->push_new<multi_subscript_operation>
417 (pstate->pop (), std::move (args));
420 pstate->wrap2<subscript_operation> ();
425 PostfixExpression '[' ']'
426 { /* Do nothing. */ }
427 | PostfixExpression '[' AssignExpression DOTDOT AssignExpression ']'
429 operation_up last = pstate->pop ();
430 operation_up mid = pstate->pop ();
431 operation_up first = pstate->pop ();
432 pstate->push_new<ternop_slice_operation>
433 (std::move (first), std::move (mid),
440 { /* Do nothing. */ }
442 { struct bound_minimal_symbol msymbol;
443 std::string copy = copy_name ($1);
444 struct field_of_this_result is_a_field_of_this;
445 struct block_symbol sym;
447 /* Handle VAR, which could be local or global. */
448 sym = lookup_symbol (copy.c_str (),
449 pstate->expression_context_block,
450 VAR_DOMAIN, &is_a_field_of_this);
451 if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
453 if (symbol_read_needs_frame (sym.symbol))
454 pstate->block_tracker->update (sym);
455 pstate->push_new<var_value_operation> (sym.symbol,
458 else if (is_a_field_of_this.type != NULL)
460 /* It hangs off of `this'. Must not inadvertently convert from a
461 method call to data ref. */
462 pstate->block_tracker->update (sym);
464 = make_operation<op_this_operation> ();
465 pstate->push_new<structop_ptr_operation>
466 (std::move (thisop), std::move (copy));
470 /* Lookup foreign name in global static symbols. */
471 msymbol = lookup_bound_minimal_symbol (copy.c_str ());
472 if (msymbol.minsym != NULL)
473 pstate->push_new<var_msym_value_operation>
474 (msymbol.minsym, msymbol.objfile);
475 else if (!have_full_symbols () && !have_partial_symbols ())
476 error (_("No symbol table is loaded. Use the \"file\" command"));
478 error (_("No symbol \"%s\" in current context."),
482 | TypeExp '.' IdentifierExp
483 { struct type *type = check_typedef ($1);
485 /* Check if the qualified name is in the global
486 context. However if the symbol has not already
487 been resolved, it's not likely to be found. */
488 if (type->code () == TYPE_CODE_MODULE)
490 struct block_symbol sym;
491 const char *type_name = TYPE_SAFE_NAME (type);
492 int type_name_len = strlen (type_name);
494 = string_printf ("%.*s.%.*s",
495 type_name_len, type_name,
499 lookup_symbol (name.c_str (),
500 (const struct block *) NULL,
502 pstate->push_symbol (name.c_str (), sym);
506 /* Check if the qualified name resolves as a member
507 of an aggregate or an enum type. */
508 if (!type_aggregate_p (type))
509 error (_("`%s' is not defined as an aggregate type."),
510 TYPE_SAFE_NAME (type));
512 pstate->push_new<scope_operation>
513 (type, copy_name ($3));
517 { pstate->push_dollar ($1); }
520 parse_number (pstate, $1.ptr, $1.length, 0, &val);
521 pstate->push_new<long_const_operation>
522 (val.typed_val_int.type, val.typed_val_int.val); }
524 { struct type *type = parse_d_type (pstate)->builtin_void;
525 type = lookup_pointer_type (type);
526 pstate->push_new<long_const_operation> (type, 0); }
528 { pstate->push_new<bool_operation> (true); }
530 { pstate->push_new<bool_operation> (false); }
532 { pstate->push_new<long_const_operation> ($1.type, $1.val); }
536 std::copy (std::begin ($1.val), std::end ($1.val),
538 pstate->push_new<float_const_operation> ($1.type, data);
541 { struct stoken_vector vec;
544 pstate->push_c_string (0, &vec); }
547 pstate->push_c_string (0, &$1);
548 for (i = 0; i < $1.len; ++i)
549 free ($1.tokens[i].ptr);
553 std::vector<operation_up> args
554 = pstate->pop_vector ($1);
555 pstate->push_new<array_operation>
556 (0, $1 - 1, std::move (args));
558 | TYPEOF_KEYWORD '(' Expression ')'
559 { pstate->wrap<typeof_operation> (); }
563 '[' ArgumentList_opt ']'
564 { $$ = pstate->arglist_len; }
573 { /* We copy the string here, and not in the
574 lexer, to guarantee that we do not leak a
575 string. Note that we follow the
576 NUL-termination convention of the
578 struct typed_stoken *vec = XNEW (struct typed_stoken);
583 vec->length = $1.length;
584 vec->ptr = (char *) malloc ($1.length + 1);
585 memcpy (vec->ptr, $1.ptr, $1.length + 1);
587 | StringExp STRING_LITERAL
588 { /* Note that we NUL-terminate here, but just
593 = XRESIZEVEC (struct typed_stoken, $$.tokens, $$.len);
595 p = (char *) malloc ($2.length + 1);
596 memcpy (p, $2.ptr, $2.length + 1);
598 $$.tokens[$$.len - 1].type = $2.type;
599 $$.tokens[$$.len - 1].length = $2.length;
600 $$.tokens[$$.len - 1].ptr = p;
606 { /* Do nothing. */ }
608 { pstate->push_new<type_operation> ($1); }
609 | BasicType BasicType2
610 { $$ = type_stack->follow_types ($1);
611 pstate->push_new<type_operation> ($$);
617 { type_stack->push (tp_pointer); }
619 { type_stack->push (tp_pointer); }
620 | '[' INTEGER_LITERAL ']'
621 { type_stack->push ($2.val);
622 type_stack->push (tp_array); }
623 | '[' INTEGER_LITERAL ']' BasicType2
624 { type_stack->push ($2.val);
625 type_stack->push (tp_array); }
635 /* Return true if the type is aggregate-like. */
638 type_aggregate_p (struct type *type)
640 return (type->code () == TYPE_CODE_STRUCT
641 || type->code () == TYPE_CODE_UNION
642 || type->code () == TYPE_CODE_MODULE
643 || (type->code () == TYPE_CODE_ENUM
644 && TYPE_DECLARED_CLASS (type)));
647 /* Take care of parsing a number (anything that starts with a digit).
648 Set yylval and return the token type; update lexptr.
649 LEN is the number of characters in it. */
651 /*** Needs some error checking for the float case ***/
654 parse_number (struct parser_state *ps, const char *p,
655 int len, int parsed_float, YYSTYPE *putithere)
663 int base = input_radix;
667 /* We have found a "L" or "U" suffix. */
668 int found_suffix = 0;
671 struct type *signed_type;
672 struct type *unsigned_type;
678 /* Strip out all embedded '_' before passing to parse_float. */
679 s = (char *) alloca (len + 1);
690 /* Check suffix for `i' , `fi' or `li' (idouble, ifloat or ireal). */
691 if (len >= 1 && tolower (s[len - 1]) == 'i')
693 if (len >= 2 && tolower (s[len - 2]) == 'f')
695 putithere->typed_val_float.type
696 = parse_d_type (ps)->builtin_ifloat;
699 else if (len >= 2 && tolower (s[len - 2]) == 'l')
701 putithere->typed_val_float.type
702 = parse_d_type (ps)->builtin_ireal;
707 putithere->typed_val_float.type
708 = parse_d_type (ps)->builtin_idouble;
712 /* Check suffix for `f' or `l'' (float or real). */
713 else if (len >= 1 && tolower (s[len - 1]) == 'f')
715 putithere->typed_val_float.type
716 = parse_d_type (ps)->builtin_float;
719 else if (len >= 1 && tolower (s[len - 1]) == 'l')
721 putithere->typed_val_float.type
722 = parse_d_type (ps)->builtin_real;
725 /* Default type if no suffix. */
728 putithere->typed_val_float.type
729 = parse_d_type (ps)->builtin_double;
732 if (!parse_float (s, len,
733 putithere->typed_val_float.type,
734 putithere->typed_val_float.val))
737 return FLOAT_LITERAL;
740 /* Handle base-switching prefixes 0x, 0b, 0 */
773 continue; /* Ignore embedded '_'. */
774 if (c >= 'A' && c <= 'Z')
776 if (c != 'l' && c != 'u')
778 if (c >= '0' && c <= '9')
786 if (base > 10 && c >= 'a' && c <= 'f')
790 n += i = c - 'a' + 10;
792 else if (c == 'l' && long_p == 0)
797 else if (c == 'u' && unsigned_p == 0)
803 return ERROR; /* Char not a digit */
806 return ERROR; /* Invalid digit in this base. */
807 /* Portably test for integer overflow. */
808 if (c != 'l' && c != 'u')
810 ULONGEST n2 = prevn * base;
811 if ((n2 / base != prevn) || (n2 + i < prevn))
812 error (_("Numeric constant too large."));
817 /* An integer constant is an int or a long. An L suffix forces it to
818 be long, and a U suffix forces it to be unsigned. To figure out
819 whether it fits, we shift it right and see whether anything remains.
820 Note that we can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or
821 more in one operation, because many compilers will warn about such a
822 shift (which always produces a zero result). To deal with the case
823 where it is we just always shift the value more than once, with fewer
825 un = (ULONGEST) n >> 2;
826 if (long_p == 0 && (un >> 30) == 0)
828 high_bit = ((ULONGEST) 1) << 31;
829 signed_type = parse_d_type (ps)->builtin_int;
830 /* For decimal notation, keep the sign of the worked out type. */
831 if (base == 10 && !unsigned_p)
832 unsigned_type = parse_d_type (ps)->builtin_long;
834 unsigned_type = parse_d_type (ps)->builtin_uint;
839 if (sizeof (ULONGEST) * HOST_CHAR_BIT < 64)
840 /* A long long does not fit in a LONGEST. */
841 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
844 high_bit = (ULONGEST) 1 << shift;
845 signed_type = parse_d_type (ps)->builtin_long;
846 unsigned_type = parse_d_type (ps)->builtin_ulong;
849 putithere->typed_val_int.val = n;
851 /* If the high bit of the worked out type is set then this number
852 has to be unsigned_type. */
853 if (unsigned_p || (n & high_bit))
854 putithere->typed_val_int.type = unsigned_type;
856 putithere->typed_val_int.type = signed_type;
858 return INTEGER_LITERAL;
861 /* Temporary obstack used for holding strings. */
862 static struct obstack tempbuf;
863 static int tempbuf_init;
865 /* Parse a string or character literal from TOKPTR. The string or
866 character may be wide or unicode. *OUTPTR is set to just after the
867 end of the literal in the input string. The resulting token is
868 stored in VALUE. This returns a token value, either STRING or
869 CHAR, depending on what was parsed. *HOST_CHARS is set to the
870 number of host characters in the literal. */
873 parse_string_or_char (const char *tokptr, const char **outptr,
874 struct typed_stoken *value, int *host_chars)
878 /* Build the gdb internal form of the input string in tempbuf. Note
879 that the buffer is null byte terminated *only* for the
880 convenience of debugging gdb itself and printing the buffer
881 contents when the buffer contains no embedded nulls. Gdb does
882 not depend upon the buffer being null byte terminated, it uses
883 the length string instead. This allows gdb to handle C strings
884 (as well as strings in other languages) with embedded null
890 obstack_free (&tempbuf, NULL);
891 obstack_init (&tempbuf);
893 /* Skip the quote. */
905 *host_chars += c_parse_escape (&tokptr, &tempbuf);
911 obstack_1grow (&tempbuf, c);
913 /* FIXME: this does the wrong thing with multi-byte host
914 characters. We could use mbrlen here, but that would
915 make "set host-charset" a bit less useful. */
920 if (*tokptr != quote)
922 if (quote == '"' || quote == '`')
923 error (_("Unterminated string in expression."));
925 error (_("Unmatched single quote."));
929 /* FIXME: should instead use own language string_type enum
930 and handle D-specific string suffixes here. */
932 value->type = C_CHAR;
934 value->type = C_STRING;
936 value->ptr = (char *) obstack_base (&tempbuf);
937 value->length = obstack_object_size (&tempbuf);
941 return quote == '\'' ? CHARACTER_LITERAL : STRING_LITERAL;
948 enum exp_opcode opcode;
951 static const struct token tokentab3[] =
953 {"^^=", ASSIGN_MODIFY, BINOP_EXP},
954 {"<<=", ASSIGN_MODIFY, BINOP_LSH},
955 {">>=", ASSIGN_MODIFY, BINOP_RSH},
958 static const struct token tokentab2[] =
960 {"+=", ASSIGN_MODIFY, BINOP_ADD},
961 {"-=", ASSIGN_MODIFY, BINOP_SUB},
962 {"*=", ASSIGN_MODIFY, BINOP_MUL},
963 {"/=", ASSIGN_MODIFY, BINOP_DIV},
964 {"%=", ASSIGN_MODIFY, BINOP_REM},
965 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
966 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
967 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
968 {"++", INCREMENT, BINOP_END},
969 {"--", DECREMENT, BINOP_END},
970 {"&&", ANDAND, BINOP_END},
971 {"||", OROR, BINOP_END},
972 {"^^", HATHAT, BINOP_END},
973 {"<<", LSH, BINOP_END},
974 {">>", RSH, BINOP_END},
975 {"==", EQUAL, BINOP_END},
976 {"!=", NOTEQUAL, BINOP_END},
977 {"<=", LEQ, BINOP_END},
978 {">=", GEQ, BINOP_END},
979 {"..", DOTDOT, BINOP_END},
982 /* Identifier-like tokens. */
983 static const struct token ident_tokens[] =
985 {"is", IDENTITY, BINOP_END},
986 {"!is", NOTIDENTITY, BINOP_END},
988 {"cast", CAST_KEYWORD, OP_NULL},
989 {"const", CONST_KEYWORD, OP_NULL},
990 {"immutable", IMMUTABLE_KEYWORD, OP_NULL},
991 {"shared", SHARED_KEYWORD, OP_NULL},
992 {"super", SUPER_KEYWORD, OP_NULL},
994 {"null", NULL_KEYWORD, OP_NULL},
995 {"true", TRUE_KEYWORD, OP_NULL},
996 {"false", FALSE_KEYWORD, OP_NULL},
998 {"init", INIT_KEYWORD, OP_NULL},
999 {"sizeof", SIZEOF_KEYWORD, OP_NULL},
1000 {"typeof", TYPEOF_KEYWORD, OP_NULL},
1001 {"typeid", TYPEID_KEYWORD, OP_NULL},
1003 {"delegate", DELEGATE_KEYWORD, OP_NULL},
1004 {"function", FUNCTION_KEYWORD, OP_NULL},
1005 {"struct", STRUCT_KEYWORD, OP_NULL},
1006 {"union", UNION_KEYWORD, OP_NULL},
1007 {"class", CLASS_KEYWORD, OP_NULL},
1008 {"interface", INTERFACE_KEYWORD, OP_NULL},
1009 {"enum", ENUM_KEYWORD, OP_NULL},
1010 {"template", TEMPLATE_KEYWORD, OP_NULL},
1013 /* This is set if a NAME token appeared at the very end of the input
1014 string, with no whitespace separating the name from the EOF. This
1015 is used only when parsing to do field name completion. */
1016 static int saw_name_at_eof;
1018 /* This is set if the previously-returned token was a structure operator.
1019 This is used only when parsing to do field name completion. */
1020 static int last_was_structop;
1022 /* Depth of parentheses. */
1023 static int paren_depth;
1025 /* Read one token, getting characters through lexptr. */
1028 lex_one_token (struct parser_state *par_state)
1033 const char *tokstart;
1034 int saw_structop = last_was_structop;
1036 last_was_structop = 0;
1040 pstate->prev_lexptr = pstate->lexptr;
1042 tokstart = pstate->lexptr;
1043 /* See if it is a special token of length 3. */
1044 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1045 if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
1047 pstate->lexptr += 3;
1048 yylval.opcode = tokentab3[i].opcode;
1049 return tokentab3[i].token;
1052 /* See if it is a special token of length 2. */
1053 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1054 if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
1056 pstate->lexptr += 2;
1057 yylval.opcode = tokentab2[i].opcode;
1058 return tokentab2[i].token;
1061 switch (c = *tokstart)
1064 /* If we're parsing for field name completion, and the previous
1065 token allows such completion, return a COMPLETE token.
1066 Otherwise, we were already scanning the original text, and
1067 we're really done. */
1068 if (saw_name_at_eof)
1070 saw_name_at_eof = 0;
1073 else if (saw_structop)
1092 if (paren_depth == 0)
1099 if (pstate->comma_terminates && paren_depth == 0)
1105 /* Might be a floating point number. */
1106 if (pstate->lexptr[1] < '0' || pstate->lexptr[1] > '9')
1108 if (pstate->parse_completion)
1109 last_was_structop = 1;
1110 goto symbol; /* Nope, must be a symbol. */
1125 /* It's a number. */
1126 int got_dot = 0, got_e = 0, toktype;
1127 const char *p = tokstart;
1128 int hex = input_radix > 10;
1130 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1138 /* Hex exponents start with 'p', because 'e' is a valid hex
1139 digit and thus does not indicate a floating point number
1140 when the radix is hex. */
1141 if ((!hex && !got_e && tolower (p[0]) == 'e')
1142 || (hex && !got_e && tolower (p[0] == 'p')))
1143 got_dot = got_e = 1;
1144 /* A '.' always indicates a decimal floating point number
1145 regardless of the radix. If we have a '..' then its the
1146 end of the number and the beginning of a slice. */
1147 else if (!got_dot && (p[0] == '.' && p[1] != '.'))
1149 /* This is the sign of the exponent, not the end of the number. */
1150 else if (got_e && (tolower (p[-1]) == 'e' || tolower (p[-1]) == 'p')
1151 && (*p == '-' || *p == '+'))
1153 /* We will take any letters or digits, ignoring any embedded '_'.
1154 parse_number will complain if past the radix, or if L or U are
1156 else if ((*p < '0' || *p > '9') && (*p != '_')
1157 && ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z')))
1161 toktype = parse_number (par_state, tokstart, p - tokstart,
1162 got_dot|got_e, &yylval);
1163 if (toktype == ERROR)
1165 char *err_copy = (char *) alloca (p - tokstart + 1);
1167 memcpy (err_copy, tokstart, p - tokstart);
1168 err_copy[p - tokstart] = 0;
1169 error (_("Invalid number \"%s\"."), err_copy);
1177 const char *p = &tokstart[1];
1178 size_t len = strlen ("entry");
1180 while (isspace (*p))
1182 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1185 pstate->lexptr = &p[len];
1216 int result = parse_string_or_char (tokstart, &pstate->lexptr,
1217 &yylval.tsval, &host_len);
1218 if (result == CHARACTER_LITERAL)
1221 error (_("Empty character constant."));
1222 else if (host_len > 2 && c == '\'')
1225 namelen = pstate->lexptr - tokstart - 1;
1228 else if (host_len > 1)
1229 error (_("Invalid character constant."));
1235 if (!(c == '_' || c == '$'
1236 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1237 /* We must have come across a bad character (e.g. ';'). */
1238 error (_("Invalid character '%c' in expression"), c);
1240 /* It's a name. See how long it is. */
1242 for (c = tokstart[namelen];
1243 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1244 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1245 c = tokstart[++namelen];
1247 /* The token "if" terminates the expression and is NOT
1248 removed from the input stream. */
1249 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1252 /* For the same reason (breakpoint conditions), "thread N"
1253 terminates the expression. "thread" could be an identifier, but
1254 an identifier is never followed by a number without intervening
1255 punctuation. "task" is similar. Handle abbreviations of these,
1256 similarly to breakpoint.c:find_condition_and_thread. */
1258 && (strncmp (tokstart, "thread", namelen) == 0
1259 || strncmp (tokstart, "task", namelen) == 0)
1260 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1262 const char *p = tokstart + namelen + 1;
1264 while (*p == ' ' || *p == '\t')
1266 if (*p >= '0' && *p <= '9')
1270 pstate->lexptr += namelen;
1274 yylval.sval.ptr = tokstart;
1275 yylval.sval.length = namelen;
1277 /* Catch specific keywords. */
1278 std::string copy = copy_name (yylval.sval);
1279 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
1280 if (copy == ident_tokens[i].oper)
1282 /* It is ok to always set this, even though we don't always
1283 strictly need to. */
1284 yylval.opcode = ident_tokens[i].opcode;
1285 return ident_tokens[i].token;
1288 if (*tokstart == '$')
1289 return DOLLAR_VARIABLE;
1292 = language_lookup_primitive_type (par_state->language (),
1293 par_state->gdbarch (), copy.c_str ());
1294 if (yylval.tsym.type != NULL)
1297 /* Input names that aren't symbols but ARE valid hex numbers,
1298 when the input radix permits them, can be names or numbers
1299 depending on the parse. Note we support radixes > 16 here. */
1300 if ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1301 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))
1303 YYSTYPE newlval; /* Its value is ignored. */
1304 int hextype = parse_number (par_state, tokstart, namelen, 0, &newlval);
1305 if (hextype == INTEGER_LITERAL)
1309 if (pstate->parse_completion && *pstate->lexptr == '\0')
1310 saw_name_at_eof = 1;
1315 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
1316 struct token_and_value
1323 /* A FIFO of tokens that have been read but not yet returned to the
1325 static std::vector<token_and_value> token_fifo;
1327 /* Non-zero if the lexer should return tokens from the FIFO. */
1330 /* Temporary storage for yylex; this holds symbol names as they are
1332 static auto_obstack name_obstack;
1334 /* Classify an IDENTIFIER token. The contents of the token are in `yylval'.
1335 Updates yylval and returns the new token type. BLOCK is the block
1336 in which lookups start; this can be NULL to mean the global scope. */
1339 classify_name (struct parser_state *par_state, const struct block *block)
1341 struct block_symbol sym;
1342 struct field_of_this_result is_a_field_of_this;
1344 std::string copy = copy_name (yylval.sval);
1346 sym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN, &is_a_field_of_this);
1347 if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)
1349 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1352 else if (sym.symbol == NULL)
1354 /* Look-up first for a module name, then a type. */
1355 sym = lookup_symbol (copy.c_str (), block, MODULE_DOMAIN, NULL);
1356 if (sym.symbol == NULL)
1357 sym = lookup_symbol (copy.c_str (), block, STRUCT_DOMAIN, NULL);
1359 if (sym.symbol != NULL)
1361 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1365 return UNKNOWN_NAME;
1371 /* Like classify_name, but used by the inner loop of the lexer, when a
1372 name might have already been seen. CONTEXT is the context type, or
1373 NULL if this is the first component of a name. */
1376 classify_inner_name (struct parser_state *par_state,
1377 const struct block *block, struct type *context)
1381 if (context == NULL)
1382 return classify_name (par_state, block);
1384 type = check_typedef (context);
1385 if (!type_aggregate_p (type))
1388 std::string copy = copy_name (yylval.ssym.stoken);
1389 yylval.ssym.sym = d_lookup_nested_symbol (type, copy.c_str (), block);
1391 if (yylval.ssym.sym.symbol == NULL)
1394 if (SYMBOL_CLASS (yylval.ssym.sym.symbol) == LOC_TYPEDEF)
1396 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
1403 /* The outer level of a two-level lexer. This calls the inner lexer
1404 to return tokens. It then either returns these tokens, or
1405 aggregates them into a larger token. This lets us work around a
1406 problem in our parsing approach, where the parser could not
1407 distinguish between qualified names and qualified types at the
1413 token_and_value current;
1415 struct type *context_type = NULL;
1416 int last_to_examine, next_to_examine, checkpoint;
1417 const struct block *search_block;
1419 if (popping && !token_fifo.empty ())
1423 /* Read the first token and decide what to do. */
1424 current.token = lex_one_token (pstate);
1425 if (current.token != IDENTIFIER && current.token != '.')
1426 return current.token;
1428 /* Read any sequence of alternating "." and identifier tokens into
1430 current.value = yylval;
1431 token_fifo.push_back (current);
1432 last_was_dot = current.token == '.';
1436 current.token = lex_one_token (pstate);
1437 current.value = yylval;
1438 token_fifo.push_back (current);
1440 if ((last_was_dot && current.token != IDENTIFIER)
1441 || (!last_was_dot && current.token != '.'))
1444 last_was_dot = !last_was_dot;
1448 /* We always read one extra token, so compute the number of tokens
1449 to examine accordingly. */
1450 last_to_examine = token_fifo.size () - 2;
1451 next_to_examine = 0;
1453 current = token_fifo[next_to_examine];
1456 /* If we are not dealing with a typename, now is the time to find out. */
1457 if (current.token == IDENTIFIER)
1459 yylval = current.value;
1460 current.token = classify_name (pstate, pstate->expression_context_block);
1461 current.value = yylval;
1464 /* If the IDENTIFIER is not known, it could be a package symbol,
1465 first try building up a name until we find the qualified module. */
1466 if (current.token == UNKNOWN_NAME)
1468 name_obstack.clear ();
1469 obstack_grow (&name_obstack, current.value.sval.ptr,
1470 current.value.sval.length);
1474 while (next_to_examine <= last_to_examine)
1476 token_and_value next;
1478 next = token_fifo[next_to_examine];
1481 if (next.token == IDENTIFIER && last_was_dot)
1483 /* Update the partial name we are constructing. */
1484 obstack_grow_str (&name_obstack, ".");
1485 obstack_grow (&name_obstack, next.value.sval.ptr,
1486 next.value.sval.length);
1488 yylval.sval.ptr = (char *) obstack_base (&name_obstack);
1489 yylval.sval.length = obstack_object_size (&name_obstack);
1491 current.token = classify_name (pstate,
1492 pstate->expression_context_block);
1493 current.value = yylval;
1495 /* We keep going until we find a TYPENAME. */
1496 if (current.token == TYPENAME)
1498 /* Install it as the first token in the FIFO. */
1499 token_fifo[0] = current;
1500 token_fifo.erase (token_fifo.begin () + 1,
1501 token_fifo.begin () + next_to_examine);
1505 else if (next.token == '.' && !last_was_dot)
1509 /* We've reached the end of the name. */
1514 /* Reset our current token back to the start, if we found nothing
1515 this means that we will just jump to do pop. */
1516 current = token_fifo[0];
1517 next_to_examine = 1;
1519 if (current.token != TYPENAME && current.token != '.')
1522 name_obstack.clear ();
1524 if (current.token == '.')
1525 search_block = NULL;
1528 gdb_assert (current.token == TYPENAME);
1529 search_block = pstate->expression_context_block;
1530 obstack_grow (&name_obstack, current.value.sval.ptr,
1531 current.value.sval.length);
1532 context_type = current.value.tsym.type;
1536 last_was_dot = current.token == '.';
1538 while (next_to_examine <= last_to_examine)
1540 token_and_value next;
1542 next = token_fifo[next_to_examine];
1545 if (next.token == IDENTIFIER && last_was_dot)
1549 yylval = next.value;
1550 classification = classify_inner_name (pstate, search_block,
1552 /* We keep going until we either run out of names, or until
1553 we have a qualified name which is not a type. */
1554 if (classification != TYPENAME && classification != IDENTIFIER)
1557 /* Accept up to this token. */
1558 checkpoint = next_to_examine;
1560 /* Update the partial name we are constructing. */
1561 if (context_type != NULL)
1563 /* We don't want to put a leading "." into the name. */
1564 obstack_grow_str (&name_obstack, ".");
1566 obstack_grow (&name_obstack, next.value.sval.ptr,
1567 next.value.sval.length);
1569 yylval.sval.ptr = (char *) obstack_base (&name_obstack);
1570 yylval.sval.length = obstack_object_size (&name_obstack);
1571 current.value = yylval;
1572 current.token = classification;
1576 if (classification == IDENTIFIER)
1579 context_type = yylval.tsym.type;
1581 else if (next.token == '.' && !last_was_dot)
1585 /* We've reached the end of the name. */
1590 /* If we have a replacement token, install it as the first token in
1591 the FIFO, and delete the other constituent tokens. */
1594 token_fifo[0] = current;
1596 token_fifo.erase (token_fifo.begin () + 1,
1597 token_fifo.begin () + checkpoint);
1601 current = token_fifo[0];
1602 token_fifo.erase (token_fifo.begin ());
1603 yylval = current.value;
1604 return current.token;
1608 d_parse (struct parser_state *par_state)
1610 /* Setting up the parser state. */
1611 scoped_restore pstate_restore = make_scoped_restore (&pstate);
1612 gdb_assert (par_state != NULL);
1615 scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
1618 struct type_stack stack;
1619 scoped_restore restore_type_stack = make_scoped_restore (&type_stack,
1622 /* Initialize some state used by the lexer. */
1623 last_was_structop = 0;
1624 saw_name_at_eof = 0;
1627 token_fifo.clear ();
1629 name_obstack.clear ();
1631 int result = yyparse ();
1633 pstate->set_operation (pstate->pop ());
1638 yyerror (const char *msg)
1640 if (pstate->prev_lexptr)
1641 pstate->lexptr = pstate->prev_lexptr;
1643 error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);