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);
457 else if (is_a_field_of_this.type != NULL)
459 /* It hangs off of `this'. Must not inadvertently convert from a
460 method call to data ref. */
461 pstate->block_tracker->update (sym);
463 = make_operation<op_this_operation> ();
464 pstate->push_new<structop_ptr_operation>
465 (std::move (thisop), std::move (copy));
469 /* Lookup foreign name in global static symbols. */
470 msymbol = lookup_bound_minimal_symbol (copy.c_str ());
471 if (msymbol.minsym != NULL)
472 pstate->push_new<var_msym_value_operation> (msymbol);
473 else if (!have_full_symbols () && !have_partial_symbols ())
474 error (_("No symbol table is loaded. Use the \"file\" command"));
476 error (_("No symbol \"%s\" in current context."),
480 | TypeExp '.' IdentifierExp
481 { struct type *type = check_typedef ($1);
483 /* Check if the qualified name is in the global
484 context. However if the symbol has not already
485 been resolved, it's not likely to be found. */
486 if (type->code () == TYPE_CODE_MODULE)
488 struct block_symbol sym;
489 const char *type_name = TYPE_SAFE_NAME (type);
490 int type_name_len = strlen (type_name);
492 = string_printf ("%.*s.%.*s",
493 type_name_len, type_name,
497 lookup_symbol (name.c_str (),
498 (const struct block *) NULL,
500 pstate->push_symbol (name.c_str (), sym);
504 /* Check if the qualified name resolves as a member
505 of an aggregate or an enum type. */
506 if (!type_aggregate_p (type))
507 error (_("`%s' is not defined as an aggregate type."),
508 TYPE_SAFE_NAME (type));
510 pstate->push_new<scope_operation>
511 (type, copy_name ($3));
515 { pstate->push_dollar ($1); }
518 parse_number (pstate, $1.ptr, $1.length, 0, &val);
519 pstate->push_new<long_const_operation>
520 (val.typed_val_int.type, val.typed_val_int.val); }
522 { struct type *type = parse_d_type (pstate)->builtin_void;
523 type = lookup_pointer_type (type);
524 pstate->push_new<long_const_operation> (type, 0); }
526 { pstate->push_new<bool_operation> (true); }
528 { pstate->push_new<bool_operation> (false); }
530 { pstate->push_new<long_const_operation> ($1.type, $1.val); }
534 std::copy (std::begin ($1.val), std::end ($1.val),
536 pstate->push_new<float_const_operation> ($1.type, data);
539 { struct stoken_vector vec;
542 pstate->push_c_string (0, &vec); }
545 pstate->push_c_string (0, &$1);
546 for (i = 0; i < $1.len; ++i)
547 free ($1.tokens[i].ptr);
551 std::vector<operation_up> args
552 = pstate->pop_vector ($1);
553 pstate->push_new<array_operation>
554 (0, $1 - 1, std::move (args));
556 | TYPEOF_KEYWORD '(' Expression ')'
557 { pstate->wrap<typeof_operation> (); }
561 '[' ArgumentList_opt ']'
562 { $$ = pstate->arglist_len; }
571 { /* We copy the string here, and not in the
572 lexer, to guarantee that we do not leak a
573 string. Note that we follow the
574 NUL-termination convention of the
576 struct typed_stoken *vec = XNEW (struct typed_stoken);
581 vec->length = $1.length;
582 vec->ptr = (char *) malloc ($1.length + 1);
583 memcpy (vec->ptr, $1.ptr, $1.length + 1);
585 | StringExp STRING_LITERAL
586 { /* Note that we NUL-terminate here, but just
591 = XRESIZEVEC (struct typed_stoken, $$.tokens, $$.len);
593 p = (char *) malloc ($2.length + 1);
594 memcpy (p, $2.ptr, $2.length + 1);
596 $$.tokens[$$.len - 1].type = $2.type;
597 $$.tokens[$$.len - 1].length = $2.length;
598 $$.tokens[$$.len - 1].ptr = p;
604 { /* Do nothing. */ }
606 { pstate->push_new<type_operation> ($1); }
607 | BasicType BasicType2
608 { $$ = type_stack->follow_types ($1);
609 pstate->push_new<type_operation> ($$);
615 { type_stack->push (tp_pointer); }
617 { type_stack->push (tp_pointer); }
618 | '[' INTEGER_LITERAL ']'
619 { type_stack->push ($2.val);
620 type_stack->push (tp_array); }
621 | '[' INTEGER_LITERAL ']' BasicType2
622 { type_stack->push ($2.val);
623 type_stack->push (tp_array); }
633 /* Return true if the type is aggregate-like. */
636 type_aggregate_p (struct type *type)
638 return (type->code () == TYPE_CODE_STRUCT
639 || type->code () == TYPE_CODE_UNION
640 || type->code () == TYPE_CODE_MODULE
641 || (type->code () == TYPE_CODE_ENUM
642 && type->is_declared_class ()));
645 /* Take care of parsing a number (anything that starts with a digit).
646 Set yylval and return the token type; update lexptr.
647 LEN is the number of characters in it. */
649 /*** Needs some error checking for the float case ***/
652 parse_number (struct parser_state *ps, const char *p,
653 int len, int parsed_float, YYSTYPE *putithere)
661 int base = input_radix;
665 /* We have found a "L" or "U" suffix. */
666 int found_suffix = 0;
669 struct type *signed_type;
670 struct type *unsigned_type;
676 /* Strip out all embedded '_' before passing to parse_float. */
677 s = (char *) alloca (len + 1);
688 /* Check suffix for `i' , `fi' or `li' (idouble, ifloat or ireal). */
689 if (len >= 1 && tolower (s[len - 1]) == 'i')
691 if (len >= 2 && tolower (s[len - 2]) == 'f')
693 putithere->typed_val_float.type
694 = parse_d_type (ps)->builtin_ifloat;
697 else if (len >= 2 && tolower (s[len - 2]) == 'l')
699 putithere->typed_val_float.type
700 = parse_d_type (ps)->builtin_ireal;
705 putithere->typed_val_float.type
706 = parse_d_type (ps)->builtin_idouble;
710 /* Check suffix for `f' or `l'' (float or real). */
711 else if (len >= 1 && tolower (s[len - 1]) == 'f')
713 putithere->typed_val_float.type
714 = parse_d_type (ps)->builtin_float;
717 else if (len >= 1 && tolower (s[len - 1]) == 'l')
719 putithere->typed_val_float.type
720 = parse_d_type (ps)->builtin_real;
723 /* Default type if no suffix. */
726 putithere->typed_val_float.type
727 = parse_d_type (ps)->builtin_double;
730 if (!parse_float (s, len,
731 putithere->typed_val_float.type,
732 putithere->typed_val_float.val))
735 return FLOAT_LITERAL;
738 /* Handle base-switching prefixes 0x, 0b, 0 */
771 continue; /* Ignore embedded '_'. */
772 if (c >= 'A' && c <= 'Z')
774 if (c != 'l' && c != 'u')
776 if (c >= '0' && c <= '9')
784 if (base > 10 && c >= 'a' && c <= 'f')
788 n += i = c - 'a' + 10;
790 else if (c == 'l' && long_p == 0)
795 else if (c == 'u' && unsigned_p == 0)
801 return ERROR; /* Char not a digit */
804 return ERROR; /* Invalid digit in this base. */
805 /* Portably test for integer overflow. */
806 if (c != 'l' && c != 'u')
808 ULONGEST n2 = prevn * base;
809 if ((n2 / base != prevn) || (n2 + i < prevn))
810 error (_("Numeric constant too large."));
815 /* An integer constant is an int or a long. An L suffix forces it to
816 be long, and a U suffix forces it to be unsigned. To figure out
817 whether it fits, we shift it right and see whether anything remains.
818 Note that we can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or
819 more in one operation, because many compilers will warn about such a
820 shift (which always produces a zero result). To deal with the case
821 where it is we just always shift the value more than once, with fewer
823 un = (ULONGEST) n >> 2;
824 if (long_p == 0 && (un >> 30) == 0)
826 high_bit = ((ULONGEST) 1) << 31;
827 signed_type = parse_d_type (ps)->builtin_int;
828 /* For decimal notation, keep the sign of the worked out type. */
829 if (base == 10 && !unsigned_p)
830 unsigned_type = parse_d_type (ps)->builtin_long;
832 unsigned_type = parse_d_type (ps)->builtin_uint;
837 if (sizeof (ULONGEST) * HOST_CHAR_BIT < 64)
838 /* A long long does not fit in a LONGEST. */
839 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
842 high_bit = (ULONGEST) 1 << shift;
843 signed_type = parse_d_type (ps)->builtin_long;
844 unsigned_type = parse_d_type (ps)->builtin_ulong;
847 putithere->typed_val_int.val = n;
849 /* If the high bit of the worked out type is set then this number
850 has to be unsigned_type. */
851 if (unsigned_p || (n & high_bit))
852 putithere->typed_val_int.type = unsigned_type;
854 putithere->typed_val_int.type = signed_type;
856 return INTEGER_LITERAL;
859 /* Temporary obstack used for holding strings. */
860 static struct obstack tempbuf;
861 static int tempbuf_init;
863 /* Parse a string or character literal from TOKPTR. The string or
864 character may be wide or unicode. *OUTPTR is set to just after the
865 end of the literal in the input string. The resulting token is
866 stored in VALUE. This returns a token value, either STRING or
867 CHAR, depending on what was parsed. *HOST_CHARS is set to the
868 number of host characters in the literal. */
871 parse_string_or_char (const char *tokptr, const char **outptr,
872 struct typed_stoken *value, int *host_chars)
876 /* Build the gdb internal form of the input string in tempbuf. Note
877 that the buffer is null byte terminated *only* for the
878 convenience of debugging gdb itself and printing the buffer
879 contents when the buffer contains no embedded nulls. Gdb does
880 not depend upon the buffer being null byte terminated, it uses
881 the length string instead. This allows gdb to handle C strings
882 (as well as strings in other languages) with embedded null
888 obstack_free (&tempbuf, NULL);
889 obstack_init (&tempbuf);
891 /* Skip the quote. */
903 *host_chars += c_parse_escape (&tokptr, &tempbuf);
909 obstack_1grow (&tempbuf, c);
911 /* FIXME: this does the wrong thing with multi-byte host
912 characters. We could use mbrlen here, but that would
913 make "set host-charset" a bit less useful. */
918 if (*tokptr != quote)
920 if (quote == '"' || quote == '`')
921 error (_("Unterminated string in expression."));
923 error (_("Unmatched single quote."));
927 /* FIXME: should instead use own language string_type enum
928 and handle D-specific string suffixes here. */
930 value->type = C_CHAR;
932 value->type = C_STRING;
934 value->ptr = (char *) obstack_base (&tempbuf);
935 value->length = obstack_object_size (&tempbuf);
939 return quote == '\'' ? CHARACTER_LITERAL : STRING_LITERAL;
946 enum exp_opcode opcode;
949 static const struct token tokentab3[] =
951 {"^^=", ASSIGN_MODIFY, BINOP_EXP},
952 {"<<=", ASSIGN_MODIFY, BINOP_LSH},
953 {">>=", ASSIGN_MODIFY, BINOP_RSH},
956 static const struct token tokentab2[] =
958 {"+=", ASSIGN_MODIFY, BINOP_ADD},
959 {"-=", ASSIGN_MODIFY, BINOP_SUB},
960 {"*=", ASSIGN_MODIFY, BINOP_MUL},
961 {"/=", ASSIGN_MODIFY, BINOP_DIV},
962 {"%=", ASSIGN_MODIFY, BINOP_REM},
963 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
964 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
965 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
966 {"++", INCREMENT, OP_NULL},
967 {"--", DECREMENT, OP_NULL},
968 {"&&", ANDAND, OP_NULL},
969 {"||", OROR, OP_NULL},
970 {"^^", HATHAT, OP_NULL},
971 {"<<", LSH, OP_NULL},
972 {">>", RSH, OP_NULL},
973 {"==", EQUAL, OP_NULL},
974 {"!=", NOTEQUAL, OP_NULL},
975 {"<=", LEQ, OP_NULL},
976 {">=", GEQ, OP_NULL},
977 {"..", DOTDOT, OP_NULL},
980 /* Identifier-like tokens. */
981 static const struct token ident_tokens[] =
983 {"is", IDENTITY, OP_NULL},
984 {"!is", NOTIDENTITY, OP_NULL},
986 {"cast", CAST_KEYWORD, OP_NULL},
987 {"const", CONST_KEYWORD, OP_NULL},
988 {"immutable", IMMUTABLE_KEYWORD, OP_NULL},
989 {"shared", SHARED_KEYWORD, OP_NULL},
990 {"super", SUPER_KEYWORD, OP_NULL},
992 {"null", NULL_KEYWORD, OP_NULL},
993 {"true", TRUE_KEYWORD, OP_NULL},
994 {"false", FALSE_KEYWORD, OP_NULL},
996 {"init", INIT_KEYWORD, OP_NULL},
997 {"sizeof", SIZEOF_KEYWORD, OP_NULL},
998 {"typeof", TYPEOF_KEYWORD, OP_NULL},
999 {"typeid", TYPEID_KEYWORD, OP_NULL},
1001 {"delegate", DELEGATE_KEYWORD, OP_NULL},
1002 {"function", FUNCTION_KEYWORD, OP_NULL},
1003 {"struct", STRUCT_KEYWORD, OP_NULL},
1004 {"union", UNION_KEYWORD, OP_NULL},
1005 {"class", CLASS_KEYWORD, OP_NULL},
1006 {"interface", INTERFACE_KEYWORD, OP_NULL},
1007 {"enum", ENUM_KEYWORD, OP_NULL},
1008 {"template", TEMPLATE_KEYWORD, OP_NULL},
1011 /* This is set if a NAME token appeared at the very end of the input
1012 string, with no whitespace separating the name from the EOF. This
1013 is used only when parsing to do field name completion. */
1014 static int saw_name_at_eof;
1016 /* This is set if the previously-returned token was a structure operator.
1017 This is used only when parsing to do field name completion. */
1018 static int last_was_structop;
1020 /* Depth of parentheses. */
1021 static int paren_depth;
1023 /* Read one token, getting characters through lexptr. */
1026 lex_one_token (struct parser_state *par_state)
1031 const char *tokstart;
1032 int saw_structop = last_was_structop;
1034 last_was_structop = 0;
1038 pstate->prev_lexptr = pstate->lexptr;
1040 tokstart = pstate->lexptr;
1041 /* See if it is a special token of length 3. */
1042 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1043 if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
1045 pstate->lexptr += 3;
1046 yylval.opcode = tokentab3[i].opcode;
1047 return tokentab3[i].token;
1050 /* See if it is a special token of length 2. */
1051 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1052 if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
1054 pstate->lexptr += 2;
1055 yylval.opcode = tokentab2[i].opcode;
1056 return tokentab2[i].token;
1059 switch (c = *tokstart)
1062 /* If we're parsing for field name completion, and the previous
1063 token allows such completion, return a COMPLETE token.
1064 Otherwise, we were already scanning the original text, and
1065 we're really done. */
1066 if (saw_name_at_eof)
1068 saw_name_at_eof = 0;
1071 else if (saw_structop)
1090 if (paren_depth == 0)
1097 if (pstate->comma_terminates && paren_depth == 0)
1103 /* Might be a floating point number. */
1104 if (pstate->lexptr[1] < '0' || pstate->lexptr[1] > '9')
1106 if (pstate->parse_completion)
1107 last_was_structop = 1;
1108 goto symbol; /* Nope, must be a symbol. */
1123 /* It's a number. */
1124 int got_dot = 0, got_e = 0, toktype;
1125 const char *p = tokstart;
1126 int hex = input_radix > 10;
1128 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1136 /* Hex exponents start with 'p', because 'e' is a valid hex
1137 digit and thus does not indicate a floating point number
1138 when the radix is hex. */
1139 if ((!hex && !got_e && tolower (p[0]) == 'e')
1140 || (hex && !got_e && tolower (p[0] == 'p')))
1141 got_dot = got_e = 1;
1142 /* A '.' always indicates a decimal floating point number
1143 regardless of the radix. If we have a '..' then its the
1144 end of the number and the beginning of a slice. */
1145 else if (!got_dot && (p[0] == '.' && p[1] != '.'))
1147 /* This is the sign of the exponent, not the end of the number. */
1148 else if (got_e && (tolower (p[-1]) == 'e' || tolower (p[-1]) == 'p')
1149 && (*p == '-' || *p == '+'))
1151 /* We will take any letters or digits, ignoring any embedded '_'.
1152 parse_number will complain if past the radix, or if L or U are
1154 else if ((*p < '0' || *p > '9') && (*p != '_')
1155 && ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z')))
1159 toktype = parse_number (par_state, tokstart, p - tokstart,
1160 got_dot|got_e, &yylval);
1161 if (toktype == ERROR)
1163 char *err_copy = (char *) alloca (p - tokstart + 1);
1165 memcpy (err_copy, tokstart, p - tokstart);
1166 err_copy[p - tokstart] = 0;
1167 error (_("Invalid number \"%s\"."), err_copy);
1175 const char *p = &tokstart[1];
1176 size_t len = strlen ("entry");
1178 while (isspace (*p))
1180 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1183 pstate->lexptr = &p[len];
1214 int result = parse_string_or_char (tokstart, &pstate->lexptr,
1215 &yylval.tsval, &host_len);
1216 if (result == CHARACTER_LITERAL)
1219 error (_("Empty character constant."));
1220 else if (host_len > 2 && c == '\'')
1223 namelen = pstate->lexptr - tokstart - 1;
1226 else if (host_len > 1)
1227 error (_("Invalid character constant."));
1233 if (!(c == '_' || c == '$'
1234 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1235 /* We must have come across a bad character (e.g. ';'). */
1236 error (_("Invalid character '%c' in expression"), c);
1238 /* It's a name. See how long it is. */
1240 for (c = tokstart[namelen];
1241 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1242 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1243 c = tokstart[++namelen];
1245 /* The token "if" terminates the expression and is NOT
1246 removed from the input stream. */
1247 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1250 /* For the same reason (breakpoint conditions), "thread N"
1251 terminates the expression. "thread" could be an identifier, but
1252 an identifier is never followed by a number without intervening
1253 punctuation. "task" is similar. Handle abbreviations of these,
1254 similarly to breakpoint.c:find_condition_and_thread. */
1256 && (strncmp (tokstart, "thread", namelen) == 0
1257 || strncmp (tokstart, "task", namelen) == 0)
1258 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1260 const char *p = tokstart + namelen + 1;
1262 while (*p == ' ' || *p == '\t')
1264 if (*p >= '0' && *p <= '9')
1268 pstate->lexptr += namelen;
1272 yylval.sval.ptr = tokstart;
1273 yylval.sval.length = namelen;
1275 /* Catch specific keywords. */
1276 std::string copy = copy_name (yylval.sval);
1277 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
1278 if (copy == ident_tokens[i].oper)
1280 /* It is ok to always set this, even though we don't always
1281 strictly need to. */
1282 yylval.opcode = ident_tokens[i].opcode;
1283 return ident_tokens[i].token;
1286 if (*tokstart == '$')
1287 return DOLLAR_VARIABLE;
1290 = language_lookup_primitive_type (par_state->language (),
1291 par_state->gdbarch (), copy.c_str ());
1292 if (yylval.tsym.type != NULL)
1295 /* Input names that aren't symbols but ARE valid hex numbers,
1296 when the input radix permits them, can be names or numbers
1297 depending on the parse. Note we support radixes > 16 here. */
1298 if ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1299 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))
1301 YYSTYPE newlval; /* Its value is ignored. */
1302 int hextype = parse_number (par_state, tokstart, namelen, 0, &newlval);
1303 if (hextype == INTEGER_LITERAL)
1307 if (pstate->parse_completion && *pstate->lexptr == '\0')
1308 saw_name_at_eof = 1;
1313 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
1314 struct token_and_value
1321 /* A FIFO of tokens that have been read but not yet returned to the
1323 static std::vector<token_and_value> token_fifo;
1325 /* Non-zero if the lexer should return tokens from the FIFO. */
1328 /* Temporary storage for yylex; this holds symbol names as they are
1330 static auto_obstack name_obstack;
1332 /* Classify an IDENTIFIER token. The contents of the token are in `yylval'.
1333 Updates yylval and returns the new token type. BLOCK is the block
1334 in which lookups start; this can be NULL to mean the global scope. */
1337 classify_name (struct parser_state *par_state, const struct block *block)
1339 struct block_symbol sym;
1340 struct field_of_this_result is_a_field_of_this;
1342 std::string copy = copy_name (yylval.sval);
1344 sym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN, &is_a_field_of_this);
1345 if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)
1347 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1350 else if (sym.symbol == NULL)
1352 /* Look-up first for a module name, then a type. */
1353 sym = lookup_symbol (copy.c_str (), block, MODULE_DOMAIN, NULL);
1354 if (sym.symbol == NULL)
1355 sym = lookup_symbol (copy.c_str (), block, STRUCT_DOMAIN, NULL);
1357 if (sym.symbol != NULL)
1359 yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1363 return UNKNOWN_NAME;
1369 /* Like classify_name, but used by the inner loop of the lexer, when a
1370 name might have already been seen. CONTEXT is the context type, or
1371 NULL if this is the first component of a name. */
1374 classify_inner_name (struct parser_state *par_state,
1375 const struct block *block, struct type *context)
1379 if (context == NULL)
1380 return classify_name (par_state, block);
1382 type = check_typedef (context);
1383 if (!type_aggregate_p (type))
1386 std::string copy = copy_name (yylval.ssym.stoken);
1387 yylval.ssym.sym = d_lookup_nested_symbol (type, copy.c_str (), block);
1389 if (yylval.ssym.sym.symbol == NULL)
1392 if (SYMBOL_CLASS (yylval.ssym.sym.symbol) == LOC_TYPEDEF)
1394 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
1401 /* The outer level of a two-level lexer. This calls the inner lexer
1402 to return tokens. It then either returns these tokens, or
1403 aggregates them into a larger token. This lets us work around a
1404 problem in our parsing approach, where the parser could not
1405 distinguish between qualified names and qualified types at the
1411 token_and_value current;
1413 struct type *context_type = NULL;
1414 int last_to_examine, next_to_examine, checkpoint;
1415 const struct block *search_block;
1417 if (popping && !token_fifo.empty ())
1421 /* Read the first token and decide what to do. */
1422 current.token = lex_one_token (pstate);
1423 if (current.token != IDENTIFIER && current.token != '.')
1424 return current.token;
1426 /* Read any sequence of alternating "." and identifier tokens into
1428 current.value = yylval;
1429 token_fifo.push_back (current);
1430 last_was_dot = current.token == '.';
1434 current.token = lex_one_token (pstate);
1435 current.value = yylval;
1436 token_fifo.push_back (current);
1438 if ((last_was_dot && current.token != IDENTIFIER)
1439 || (!last_was_dot && current.token != '.'))
1442 last_was_dot = !last_was_dot;
1446 /* We always read one extra token, so compute the number of tokens
1447 to examine accordingly. */
1448 last_to_examine = token_fifo.size () - 2;
1449 next_to_examine = 0;
1451 current = token_fifo[next_to_examine];
1454 /* If we are not dealing with a typename, now is the time to find out. */
1455 if (current.token == IDENTIFIER)
1457 yylval = current.value;
1458 current.token = classify_name (pstate, pstate->expression_context_block);
1459 current.value = yylval;
1462 /* If the IDENTIFIER is not known, it could be a package symbol,
1463 first try building up a name until we find the qualified module. */
1464 if (current.token == UNKNOWN_NAME)
1466 name_obstack.clear ();
1467 obstack_grow (&name_obstack, current.value.sval.ptr,
1468 current.value.sval.length);
1472 while (next_to_examine <= last_to_examine)
1474 token_and_value next;
1476 next = token_fifo[next_to_examine];
1479 if (next.token == IDENTIFIER && last_was_dot)
1481 /* Update the partial name we are constructing. */
1482 obstack_grow_str (&name_obstack, ".");
1483 obstack_grow (&name_obstack, next.value.sval.ptr,
1484 next.value.sval.length);
1486 yylval.sval.ptr = (char *) obstack_base (&name_obstack);
1487 yylval.sval.length = obstack_object_size (&name_obstack);
1489 current.token = classify_name (pstate,
1490 pstate->expression_context_block);
1491 current.value = yylval;
1493 /* We keep going until we find a TYPENAME. */
1494 if (current.token == TYPENAME)
1496 /* Install it as the first token in the FIFO. */
1497 token_fifo[0] = current;
1498 token_fifo.erase (token_fifo.begin () + 1,
1499 token_fifo.begin () + next_to_examine);
1503 else if (next.token == '.' && !last_was_dot)
1507 /* We've reached the end of the name. */
1512 /* Reset our current token back to the start, if we found nothing
1513 this means that we will just jump to do pop. */
1514 current = token_fifo[0];
1515 next_to_examine = 1;
1517 if (current.token != TYPENAME && current.token != '.')
1520 name_obstack.clear ();
1522 if (current.token == '.')
1523 search_block = NULL;
1526 gdb_assert (current.token == TYPENAME);
1527 search_block = pstate->expression_context_block;
1528 obstack_grow (&name_obstack, current.value.sval.ptr,
1529 current.value.sval.length);
1530 context_type = current.value.tsym.type;
1534 last_was_dot = current.token == '.';
1536 while (next_to_examine <= last_to_examine)
1538 token_and_value next;
1540 next = token_fifo[next_to_examine];
1543 if (next.token == IDENTIFIER && last_was_dot)
1547 yylval = next.value;
1548 classification = classify_inner_name (pstate, search_block,
1550 /* We keep going until we either run out of names, or until
1551 we have a qualified name which is not a type. */
1552 if (classification != TYPENAME && classification != IDENTIFIER)
1555 /* Accept up to this token. */
1556 checkpoint = next_to_examine;
1558 /* Update the partial name we are constructing. */
1559 if (context_type != NULL)
1561 /* We don't want to put a leading "." into the name. */
1562 obstack_grow_str (&name_obstack, ".");
1564 obstack_grow (&name_obstack, next.value.sval.ptr,
1565 next.value.sval.length);
1567 yylval.sval.ptr = (char *) obstack_base (&name_obstack);
1568 yylval.sval.length = obstack_object_size (&name_obstack);
1569 current.value = yylval;
1570 current.token = classification;
1574 if (classification == IDENTIFIER)
1577 context_type = yylval.tsym.type;
1579 else if (next.token == '.' && !last_was_dot)
1583 /* We've reached the end of the name. */
1588 /* If we have a replacement token, install it as the first token in
1589 the FIFO, and delete the other constituent tokens. */
1592 token_fifo[0] = current;
1594 token_fifo.erase (token_fifo.begin () + 1,
1595 token_fifo.begin () + checkpoint);
1599 current = token_fifo[0];
1600 token_fifo.erase (token_fifo.begin ());
1601 yylval = current.value;
1602 return current.token;
1606 d_parse (struct parser_state *par_state)
1608 /* Setting up the parser state. */
1609 scoped_restore pstate_restore = make_scoped_restore (&pstate);
1610 gdb_assert (par_state != NULL);
1613 scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
1616 struct type_stack stack;
1617 scoped_restore restore_type_stack = make_scoped_restore (&type_stack,
1620 /* Initialize some state used by the lexer. */
1621 last_was_structop = 0;
1622 saw_name_at_eof = 0;
1625 token_fifo.clear ();
1627 name_obstack.clear ();
1629 int result = yyparse ();
1631 pstate->set_operation (pstate->pop ());
1636 yyerror (const char *msg)
1638 if (pstate->prev_lexptr)
1639 pstate->lexptr = pstate->prev_lexptr;
1641 error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);