1 /* YACC parser for Go expressions, for GDB.
3 Copyright (C) 2012-2022 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, p-exp.y. */
22 /* Parse a Go 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. */
39 /* Known bugs or limitations:
43 - '_' (blank identifier)
44 - automatic deref of pointers
46 - interfaces, channels, etc.
48 And lots of other things.
49 I'm sure there's some cleanup to do.
56 #include "expression.h"
58 #include "parser-defs.h"
62 #include "bfd.h" /* Required by objfiles.h. */
63 #include "symfile.h" /* Required by objfiles.h. */
64 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
69 #define parse_type(ps) builtin_type (ps->gdbarch ())
71 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
73 #define GDB_YY_REMAP_PREFIX go_
76 /* The state of the parser, used internally when we are parsing the
79 static struct parser_state *pstate = NULL;
83 static int yylex (void);
85 static void yyerror (const char *);
89 /* Although the yacc "value" of an expression is not used,
90 since the result is stored in the structure being created,
91 other node types do have values. */
105 struct symtoken ssym;
107 struct typed_stoken tsval;
110 enum exp_opcode opcode;
111 struct internalvar *ivar;
112 struct stoken_vector svec;
116 /* YYSTYPE gets defined by %union. */
117 static int parse_number (struct parser_state *,
118 const char *, int, int, YYSTYPE *);
120 using namespace expr;
123 %type <voidval> exp exp1 type_exp start variable lcurly
127 %token <typed_val_int> INT
128 %token <typed_val_float> FLOAT
130 /* Both NAME and TYPENAME tokens represent symbols in the input,
131 and both convey their data as strings.
132 But a TYPENAME is a string that happens to be defined as a type
133 or builtin type name (such as int or char)
134 and a NAME is any other symbol.
135 Contexts where this distinction is not important can use the
136 nonterminal "name", which matches either NAME or TYPENAME. */
138 %token <tsval> RAW_STRING
139 %token <tsval> STRING
142 %token <tsym> TYPENAME /* Not TYPE_NAME cus already taken. */
143 %token <voidval> COMPLETE
144 /*%type <sval> name*/
145 %type <svec> string_exp
146 %type <ssym> name_not_typename
148 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
149 but which would parse as a valid number in the current input radix.
150 E.g. "c" when input_radix==16. Depending on the parse, it will be
151 turned into a name or into a number. */
152 %token <ssym> NAME_OR_INT
154 %token <lval> TRUE_KEYWORD FALSE_KEYWORD
155 %token STRUCT_KEYWORD INTERFACE_KEYWORD TYPE_KEYWORD CHAN_KEYWORD
156 %token SIZEOF_KEYWORD
157 %token LEN_KEYWORD CAP_KEYWORD
159 %token IOTA_KEYWORD NIL_KEYWORD
165 /* Special type cases. */
166 %token BYTE_KEYWORD /* An alias of uint8. */
168 %token <sval> DOLLAR_VARIABLE
170 %token <opcode> ASSIGN_MODIFY
174 %right '=' ASSIGN_MODIFY
183 %left '<' '>' LEQ GEQ
188 %right UNARY INCREMENT DECREMENT
189 %right LEFT_ARROW '.' '[' '('
199 { pstate->push_new<type_operation> ($1); }
202 /* Expressions, including the comma operator. */
205 { pstate->wrap2<comma_operation> (); }
208 /* Expressions, not including the comma operator. */
209 exp : '*' exp %prec UNARY
210 { pstate->wrap<unop_ind_operation> (); }
213 exp : '&' exp %prec UNARY
214 { pstate->wrap<unop_addr_operation> (); }
217 exp : '-' exp %prec UNARY
218 { pstate->wrap<unary_neg_operation> (); }
221 exp : '+' exp %prec UNARY
222 { pstate->wrap<unary_plus_operation> (); }
225 exp : '!' exp %prec UNARY
226 { pstate->wrap<unary_logical_not_operation> (); }
229 exp : '^' exp %prec UNARY
230 { pstate->wrap<unary_complement_operation> (); }
233 exp : exp INCREMENT %prec UNARY
234 { pstate->wrap<postinc_operation> (); }
237 exp : exp DECREMENT %prec UNARY
238 { pstate->wrap<postdec_operation> (); }
241 /* foo->bar is not in Go. May want as a gdb extension. Later. */
243 exp : exp '.' name_not_typename
245 pstate->push_new<structop_operation>
246 (pstate->pop (), copy_name ($3.stoken));
250 exp : exp '.' name_not_typename COMPLETE
252 structop_base_operation *op
253 = new structop_operation (pstate->pop (),
254 copy_name ($3.stoken));
255 pstate->mark_struct_expression (op);
256 pstate->push (operation_up (op));
260 exp : exp '.' COMPLETE
262 structop_base_operation *op
263 = new structop_operation (pstate->pop (), "");
264 pstate->mark_struct_expression (op);
265 pstate->push (operation_up (op));
269 exp : exp '[' exp1 ']'
270 { pstate->wrap2<subscript_operation> (); }
274 /* This is to save the value of arglist_len
275 being accumulated by an outer function call. */
276 { pstate->start_arglist (); }
277 arglist ')' %prec LEFT_ARROW
279 std::vector<operation_up> args
280 = pstate->pop_vector (pstate->end_arglist ());
281 pstate->push_new<funcall_operation>
282 (pstate->pop (), std::move (args));
287 { pstate->start_arglist (); }
294 { pstate->arglist_len = 1; }
297 arglist : arglist ',' exp %prec ABOVE_COMMA
298 { pstate->arglist_len++; }
302 { $$ = pstate->end_arglist () - 1; }
305 exp : lcurly type rcurly exp %prec UNARY
307 pstate->push_new<unop_memval_operation>
308 (pstate->pop (), $2);
312 exp : type '(' exp ')' %prec UNARY
314 pstate->push_new<unop_cast_operation>
315 (pstate->pop (), $1);
323 /* Binary operators in order of decreasing precedence. */
326 { pstate->wrap2<repeat_operation> (); }
330 { pstate->wrap2<mul_operation> (); }
334 { pstate->wrap2<div_operation> (); }
338 { pstate->wrap2<rem_operation> (); }
342 { pstate->wrap2<add_operation> (); }
346 { pstate->wrap2<sub_operation> (); }
350 { pstate->wrap2<lsh_operation> (); }
354 { pstate->wrap2<rsh_operation> (); }
358 { pstate->wrap2<equal_operation> (); }
361 exp : exp NOTEQUAL exp
362 { pstate->wrap2<notequal_operation> (); }
366 { pstate->wrap2<leq_operation> (); }
370 { pstate->wrap2<geq_operation> (); }
374 { pstate->wrap2<less_operation> (); }
378 { pstate->wrap2<gtr_operation> (); }
382 { pstate->wrap2<bitwise_and_operation> (); }
386 { pstate->wrap2<bitwise_xor_operation> (); }
390 { pstate->wrap2<bitwise_ior_operation> (); }
394 { pstate->wrap2<logical_and_operation> (); }
398 { pstate->wrap2<logical_or_operation> (); }
401 exp : exp '?' exp ':' exp %prec '?'
403 operation_up last = pstate->pop ();
404 operation_up mid = pstate->pop ();
405 operation_up first = pstate->pop ();
406 pstate->push_new<ternop_cond_operation>
407 (std::move (first), std::move (mid),
413 { pstate->wrap2<assign_operation> (); }
416 exp : exp ASSIGN_MODIFY exp
418 operation_up rhs = pstate->pop ();
419 operation_up lhs = pstate->pop ();
420 pstate->push_new<assign_modify_operation>
421 ($2, std::move (lhs), std::move (rhs));
427 pstate->push_new<long_const_operation>
434 struct stoken_vector vec;
437 pstate->push_c_string ($1.type, &vec);
443 parse_number (pstate, $1.stoken.ptr,
444 $1.stoken.length, 0, &val);
445 pstate->push_new<long_const_operation>
446 (val.typed_val_int.type,
447 val.typed_val_int.val);
455 std::copy (std::begin ($1.val), std::end ($1.val),
457 pstate->push_new<float_const_operation> ($1.type, data);
464 exp : DOLLAR_VARIABLE
466 pstate->push_dollar ($1);
470 exp : SIZEOF_KEYWORD '(' type ')' %prec UNARY
472 /* TODO(dje): Go objects in structs. */
473 /* TODO(dje): What's the right type here? */
474 struct type *size_type
475 = parse_type (pstate)->builtin_unsigned_int;
476 $3 = check_typedef ($3);
477 pstate->push_new<long_const_operation>
478 (size_type, (LONGEST) TYPE_LENGTH ($3));
482 exp : SIZEOF_KEYWORD '(' exp ')' %prec UNARY
484 /* TODO(dje): Go objects in structs. */
485 pstate->wrap<unop_sizeof_operation> ();
491 /* We copy the string here, and not in the
492 lexer, to guarantee that we do not leak a
494 /* Note that we NUL-terminate here, but just
496 struct typed_stoken *vec = XNEW (struct typed_stoken);
501 vec->length = $1.length;
502 vec->ptr = (char *) malloc ($1.length + 1);
503 memcpy (vec->ptr, $1.ptr, $1.length + 1);
506 | string_exp '+' STRING
508 /* Note that we NUL-terminate here, but just
512 $$.tokens = XRESIZEVEC (struct typed_stoken,
515 p = (char *) malloc ($3.length + 1);
516 memcpy (p, $3.ptr, $3.length + 1);
518 $$.tokens[$$.len - 1].type = $3.type;
519 $$.tokens[$$.len - 1].length = $3.length;
520 $$.tokens[$$.len - 1].ptr = p;
524 exp : string_exp %prec ABOVE_COMMA
529 pstate->push_c_string (0, &$1);
530 for (i = 0; i < $1.len; ++i)
531 free ($1.tokens[i].ptr);
537 { pstate->push_new<bool_operation> ($1); }
541 { pstate->push_new<bool_operation> ($1); }
544 variable: name_not_typename ENTRY
545 { struct symbol *sym = $1.sym.symbol;
548 || !sym->is_argument ()
549 || !symbol_read_needs_frame (sym))
550 error (_("@entry can be used only for function "
551 "parameters, not for \"%s\""),
552 copy_name ($1.stoken).c_str ());
554 pstate->push_new<var_entry_value_operation> (sym);
558 variable: name_not_typename
559 { struct block_symbol sym = $1.sym;
563 if (symbol_read_needs_frame (sym.symbol))
564 pstate->block_tracker->update (sym);
566 pstate->push_new<var_value_operation> (sym);
568 else if ($1.is_a_field_of_this)
570 /* TODO(dje): Can we get here?
571 E.g., via a mix of c++ and go? */
572 gdb_assert_not_reached ("go with `this' field");
576 struct bound_minimal_symbol msymbol;
577 std::string arg = copy_name ($1.stoken);
580 lookup_bound_minimal_symbol (arg.c_str ());
581 if (msymbol.minsym != NULL)
582 pstate->push_new<var_msym_value_operation>
584 else if (!have_full_symbols ()
585 && !have_partial_symbols ())
586 error (_("No symbol table is loaded. "
587 "Use the \"file\" command."));
589 error (_("No symbol \"%s\" in current context."),
596 method_exp: PACKAGENAME '.' name '.' name
602 type /* Implements (approximately): [*] type-specifier */
604 { $$ = lookup_pointer_type ($2); }
608 | STRUCT_KEYWORD name
609 { $$ = lookup_struct (copy_name ($2),
610 expression_context_block); }
613 { $$ = builtin_go_type (pstate->gdbarch ())
618 name : NAME { $$ = $1.stoken; }
619 | TYPENAME { $$ = $1.stoken; }
620 | NAME_OR_INT { $$ = $1.stoken; }
626 /* These would be useful if name_not_typename was useful, but it is just
627 a fake for "variable", so these cause reduce/reduce conflicts because
628 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
629 =exp) or just an exp. If name_not_typename was ever used in an lvalue
630 context where only a name could occur, this might be useful.
637 /* Take care of parsing a number (anything that starts with a digit).
638 Set yylval and return the token type; update lexptr.
639 LEN is the number of characters in it. */
641 /* FIXME: Needs some error checking for the float case. */
642 /* FIXME(dje): IWBN to use c-exp.y's parse_number if we could.
643 That will require moving the guts into a function that we both call
644 as our YYSTYPE is different than c-exp.y's */
647 parse_number (struct parser_state *par_state,
648 const char *p, int len, int parsed_float, YYSTYPE *putithere)
650 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
651 here, and we do kind of silly things like cast to unsigned. */
658 int base = input_radix;
661 /* Number of "L" suffixes encountered. */
664 /* We have found a "L" or "U" suffix. */
665 int found_suffix = 0;
668 struct type *signed_type;
669 struct type *unsigned_type;
673 const struct builtin_go_type *builtin_go_types
674 = builtin_go_type (par_state->gdbarch ());
676 /* Handle suffixes: 'f' for float32, 'l' for long double.
677 FIXME: This appears to be an extension -- do we want this? */
678 if (len >= 1 && tolower (p[len - 1]) == 'f')
680 putithere->typed_val_float.type
681 = builtin_go_types->builtin_float32;
684 else if (len >= 1 && tolower (p[len - 1]) == 'l')
686 putithere->typed_val_float.type
687 = parse_type (par_state)->builtin_long_double;
690 /* Default type for floating-point literals is float64. */
693 putithere->typed_val_float.type
694 = builtin_go_types->builtin_float64;
697 if (!parse_float (p, len,
698 putithere->typed_val_float.type,
699 putithere->typed_val_float.val))
704 /* Handle base-switching prefixes 0x, 0t, 0d, 0. */
748 if (c >= 'A' && c <= 'Z')
750 if (c != 'l' && c != 'u')
752 if (c >= '0' && c <= '9')
760 if (base > 10 && c >= 'a' && c <= 'f')
764 n += i = c - 'a' + 10;
777 return ERROR; /* Char not a digit */
780 return ERROR; /* Invalid digit in this base. */
782 /* Portably test for overflow (only works for nonzero values, so make
783 a second check for zero). FIXME: Can't we just make n and prevn
784 unsigned and avoid this? */
785 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
786 unsigned_p = 1; /* Try something unsigned. */
788 /* Portably test for unsigned overflow.
789 FIXME: This check is wrong; for example it doesn't find overflow
790 on 0x123456789 when LONGEST is 32 bits. */
791 if (c != 'l' && c != 'u' && n != 0)
793 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
794 error (_("Numeric constant too large."));
799 /* An integer constant is an int, a long, or a long long. An L
800 suffix forces it to be long; an LL suffix forces it to be long
801 long. If not forced to a larger size, it gets the first type of
802 the above that it fits in. To figure out whether it fits, we
803 shift it right and see whether anything remains. Note that we
804 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
805 operation, because many compilers will warn about such a shift
806 (which always produces a zero result). Sometimes gdbarch_int_bit
807 or gdbarch_long_bit will be that big, sometimes not. To deal with
808 the case where it is we just always shift the value more than
809 once, with fewer bits each time. */
811 un = (ULONGEST)n >> 2;
813 && (un >> (gdbarch_int_bit (par_state->gdbarch ()) - 2)) == 0)
816 = ((ULONGEST)1) << (gdbarch_int_bit (par_state->gdbarch ()) - 1);
818 /* A large decimal (not hex or octal) constant (between INT_MAX
819 and UINT_MAX) is a long or unsigned long, according to ANSI,
820 never an unsigned int, but this code treats it as unsigned
821 int. This probably should be fixed. GCC gives a warning on
824 unsigned_type = parse_type (par_state)->builtin_unsigned_int;
825 signed_type = parse_type (par_state)->builtin_int;
828 && (un >> (gdbarch_long_bit (par_state->gdbarch ()) - 2)) == 0)
831 = ((ULONGEST)1) << (gdbarch_long_bit (par_state->gdbarch ()) - 1);
832 unsigned_type = parse_type (par_state)->builtin_unsigned_long;
833 signed_type = parse_type (par_state)->builtin_long;
838 if (sizeof (ULONGEST) * HOST_CHAR_BIT
839 < gdbarch_long_long_bit (par_state->gdbarch ()))
840 /* A long long does not fit in a LONGEST. */
841 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
843 shift = (gdbarch_long_long_bit (par_state->gdbarch ()) - 1);
844 high_bit = (ULONGEST) 1 << shift;
845 unsigned_type = parse_type (par_state)->builtin_unsigned_long_long;
846 signed_type = parse_type (par_state)->builtin_long_long;
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. */
854 if (unsigned_p || (n & high_bit))
856 putithere->typed_val_int.type = unsigned_type;
860 putithere->typed_val_int.type = signed_type;
866 /* Temporary obstack used for holding strings. */
867 static struct obstack tempbuf;
868 static int tempbuf_init;
870 /* Parse a string or character literal from TOKPTR. The string or
871 character may be wide or unicode. *OUTPTR is set to just after the
872 end of the literal in the input string. The resulting token is
873 stored in VALUE. This returns a token value, either STRING or
874 CHAR, depending on what was parsed. *HOST_CHARS is set to the
875 number of host characters in the literal. */
878 parse_string_or_char (const char *tokptr, const char **outptr,
879 struct typed_stoken *value, int *host_chars)
883 /* Build the gdb internal form of the input string in tempbuf. Note
884 that the buffer is null byte terminated *only* for the
885 convenience of debugging gdb itself and printing the buffer
886 contents when the buffer contains no embedded nulls. Gdb does
887 not depend upon the buffer being null byte terminated, it uses
888 the length string instead. This allows gdb to handle C strings
889 (as well as strings in other languages) with embedded null
895 obstack_free (&tempbuf, NULL);
896 obstack_init (&tempbuf);
898 /* Skip the quote. */
910 *host_chars += c_parse_escape (&tokptr, &tempbuf);
916 obstack_1grow (&tempbuf, c);
918 /* FIXME: this does the wrong thing with multi-byte host
919 characters. We could use mbrlen here, but that would
920 make "set host-charset" a bit less useful. */
925 if (*tokptr != quote)
928 error (_("Unterminated string in expression."));
930 error (_("Unmatched single quote."));
934 value->type = (int) C_STRING | (quote == '\'' ? C_CHAR : 0); /*FIXME*/
935 value->ptr = (char *) obstack_base (&tempbuf);
936 value->length = obstack_object_size (&tempbuf);
940 return quote == '\'' ? CHAR : STRING;
947 enum exp_opcode opcode;
950 static const struct token tokentab3[] =
952 {">>=", ASSIGN_MODIFY, BINOP_RSH},
953 {"<<=", ASSIGN_MODIFY, BINOP_LSH},
954 /*{"&^=", ASSIGN_MODIFY, BINOP_BITWISE_ANDNOT}, TODO */
955 {"...", DOTDOTDOT, OP_NULL},
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, OP_NULL},
969 {"--", DECREMENT, OP_NULL},
970 /*{"->", RIGHT_ARROW, OP_NULL}, Doesn't exist in Go. */
971 {"<-", LEFT_ARROW, OP_NULL},
972 {"&&", ANDAND, OP_NULL},
973 {"||", OROR, OP_NULL},
974 {"<<", LSH, OP_NULL},
975 {">>", RSH, OP_NULL},
976 {"==", EQUAL, OP_NULL},
977 {"!=", NOTEQUAL, OP_NULL},
978 {"<=", LEQ, OP_NULL},
979 {">=", GEQ, OP_NULL},
980 /*{"&^", ANDNOT, OP_NULL}, TODO */
983 /* Identifier-like tokens. */
984 static const struct token ident_tokens[] =
986 {"true", TRUE_KEYWORD, OP_NULL},
987 {"false", FALSE_KEYWORD, OP_NULL},
988 {"nil", NIL_KEYWORD, OP_NULL},
989 {"const", CONST_KEYWORD, OP_NULL},
990 {"struct", STRUCT_KEYWORD, OP_NULL},
991 {"type", TYPE_KEYWORD, OP_NULL},
992 {"interface", INTERFACE_KEYWORD, OP_NULL},
993 {"chan", CHAN_KEYWORD, OP_NULL},
994 {"byte", BYTE_KEYWORD, OP_NULL}, /* An alias of uint8. */
995 {"len", LEN_KEYWORD, OP_NULL},
996 {"cap", CAP_KEYWORD, OP_NULL},
997 {"new", NEW_KEYWORD, OP_NULL},
998 {"iota", IOTA_KEYWORD, OP_NULL},
1001 /* This is set if a NAME token appeared at the very end of the input
1002 string, with no whitespace separating the name from the EOF. This
1003 is used only when parsing to do field name completion. */
1004 static int saw_name_at_eof;
1006 /* This is set if the previously-returned token was a structure
1007 operator -- either '.' or ARROW. This is used only when parsing to
1008 do field name completion. */
1009 static int last_was_structop;
1011 /* Depth of parentheses. */
1012 static int paren_depth;
1014 /* Read one token, getting characters through lexptr. */
1017 lex_one_token (struct parser_state *par_state)
1021 const char *tokstart;
1022 int saw_structop = last_was_structop;
1024 last_was_structop = 0;
1028 par_state->prev_lexptr = par_state->lexptr;
1030 tokstart = par_state->lexptr;
1031 /* See if it is a special token of length 3. */
1032 for (const auto &token : tokentab3)
1033 if (strncmp (tokstart, token.oper, 3) == 0)
1035 par_state->lexptr += 3;
1036 yylval.opcode = token.opcode;
1040 /* See if it is a special token of length 2. */
1041 for (const auto &token : tokentab2)
1042 if (strncmp (tokstart, token.oper, 2) == 0)
1044 par_state->lexptr += 2;
1045 yylval.opcode = token.opcode;
1046 /* NOTE: -> doesn't exist in Go, so we don't need to watch for
1047 setting last_was_structop here. */
1051 switch (c = *tokstart)
1054 if (saw_name_at_eof)
1056 saw_name_at_eof = 0;
1059 else if (saw_structop)
1067 par_state->lexptr++;
1073 par_state->lexptr++;
1078 if (paren_depth == 0)
1081 par_state->lexptr++;
1085 if (pstate->comma_terminates
1086 && paren_depth == 0)
1088 par_state->lexptr++;
1092 /* Might be a floating point number. */
1093 if (par_state->lexptr[1] < '0' || par_state->lexptr[1] > '9')
1095 if (pstate->parse_completion)
1096 last_was_structop = 1;
1097 goto symbol; /* Nope, must be a symbol. */
1112 /* It's a number. */
1113 int got_dot = 0, got_e = 0, toktype;
1114 const char *p = tokstart;
1115 int hex = input_radix > 10;
1117 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1125 /* This test includes !hex because 'e' is a valid hex digit
1126 and thus does not indicate a floating point number when
1127 the radix is hex. */
1128 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1129 got_dot = got_e = 1;
1130 /* This test does not include !hex, because a '.' always indicates
1131 a decimal floating point number regardless of the radix. */
1132 else if (!got_dot && *p == '.')
1134 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1135 && (*p == '-' || *p == '+'))
1136 /* This is the sign of the exponent, not the end of the
1139 /* We will take any letters or digits. parse_number will
1140 complain if past the radix, or if L or U are not final. */
1141 else if ((*p < '0' || *p > '9')
1142 && ((*p < 'a' || *p > 'z')
1143 && (*p < 'A' || *p > 'Z')))
1146 toktype = parse_number (par_state, tokstart, p - tokstart,
1147 got_dot|got_e, &yylval);
1148 if (toktype == ERROR)
1150 char *err_copy = (char *) alloca (p - tokstart + 1);
1152 memcpy (err_copy, tokstart, p - tokstart);
1153 err_copy[p - tokstart] = 0;
1154 error (_("Invalid number \"%s\"."), err_copy);
1156 par_state->lexptr = p;
1162 const char *p = &tokstart[1];
1163 size_t len = strlen ("entry");
1165 while (isspace (*p))
1167 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1170 par_state->lexptr = &p[len];
1193 par_state->lexptr++;
1201 int result = parse_string_or_char (tokstart, &par_state->lexptr,
1202 &yylval.tsval, &host_len);
1206 error (_("Empty character constant."));
1207 else if (host_len > 2 && c == '\'')
1210 namelen = par_state->lexptr - tokstart - 1;
1213 else if (host_len > 1)
1214 error (_("Invalid character constant."));
1220 if (!(c == '_' || c == '$'
1221 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1222 /* We must have come across a bad character (e.g. ';'). */
1223 error (_("Invalid character '%c' in expression."), c);
1225 /* It's a name. See how long it is. */
1227 for (c = tokstart[namelen];
1228 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1229 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1231 c = tokstart[++namelen];
1234 /* The token "if" terminates the expression and is NOT removed from
1235 the input stream. It doesn't count if it appears in the
1236 expansion of a macro. */
1238 && tokstart[0] == 'i'
1239 && tokstart[1] == 'f')
1244 /* For the same reason (breakpoint conditions), "thread N"
1245 terminates the expression. "thread" could be an identifier, but
1246 an identifier is never followed by a number without intervening
1248 Handle abbreviations of these, similarly to
1249 breakpoint.c:find_condition_and_thread.
1250 TODO: Watch for "goroutine" here? */
1252 && strncmp (tokstart, "thread", namelen) == 0
1253 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1255 const char *p = tokstart + namelen + 1;
1257 while (*p == ' ' || *p == '\t')
1259 if (*p >= '0' && *p <= '9')
1263 par_state->lexptr += namelen;
1267 yylval.sval.ptr = tokstart;
1268 yylval.sval.length = namelen;
1270 /* Catch specific keywords. */
1271 std::string copy = copy_name (yylval.sval);
1272 for (const auto &token : ident_tokens)
1273 if (copy == token.oper)
1275 /* It is ok to always set this, even though we don't always
1276 strictly need to. */
1277 yylval.opcode = token.opcode;
1281 if (*tokstart == '$')
1282 return DOLLAR_VARIABLE;
1284 if (pstate->parse_completion && *par_state->lexptr == '\0')
1285 saw_name_at_eof = 1;
1289 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
1290 struct token_and_value
1296 /* A FIFO of tokens that have been read but not yet returned to the
1298 static std::vector<token_and_value> token_fifo;
1300 /* Non-zero if the lexer should return tokens from the FIFO. */
1303 /* Temporary storage for yylex; this holds symbol names as they are
1305 static auto_obstack name_obstack;
1307 /* Build "package.name" in name_obstack.
1308 For convenience of the caller, the name is NUL-terminated,
1309 but the NUL is not included in the recorded length. */
1311 static struct stoken
1312 build_packaged_name (const char *package, int package_len,
1313 const char *name, int name_len)
1315 struct stoken result;
1317 name_obstack.clear ();
1318 obstack_grow (&name_obstack, package, package_len);
1319 obstack_grow_str (&name_obstack, ".");
1320 obstack_grow (&name_obstack, name, name_len);
1321 obstack_grow (&name_obstack, "", 1);
1322 result.ptr = (char *) obstack_base (&name_obstack);
1323 result.length = obstack_object_size (&name_obstack) - 1;
1328 /* Return non-zero if NAME is a package name.
1329 BLOCK is the scope in which to interpret NAME; this can be NULL
1330 to mean the global scope. */
1333 package_name_p (const char *name, const struct block *block)
1336 struct field_of_this_result is_a_field_of_this;
1338 sym = lookup_symbol (name, block, STRUCT_DOMAIN, &is_a_field_of_this).symbol;
1341 && sym->aclass () == LOC_TYPEDEF
1342 && sym->type ()->code () == TYPE_CODE_MODULE)
1348 /* Classify a (potential) function in the "unsafe" package.
1349 We fold these into "keywords" to keep things simple, at least until
1350 something more complex is warranted. */
1353 classify_unsafe_function (struct stoken function_name)
1355 std::string copy = copy_name (function_name);
1357 if (copy == "Sizeof")
1359 yylval.sval = function_name;
1360 return SIZEOF_KEYWORD;
1363 error (_("Unknown function in `unsafe' package: %s"), copy.c_str ());
1366 /* Classify token(s) "name1.name2" where name1 is known to be a package.
1367 The contents of the token are in `yylval'.
1368 Updates yylval and returns the new token type.
1370 The result is one of NAME, NAME_OR_INT, or TYPENAME. */
1373 classify_packaged_name (const struct block *block)
1375 struct block_symbol sym;
1376 struct field_of_this_result is_a_field_of_this;
1378 std::string copy = copy_name (yylval.sval);
1380 sym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN, &is_a_field_of_this);
1384 yylval.ssym.sym = sym;
1385 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
1391 /* Classify a NAME token.
1392 The contents of the token are in `yylval'.
1393 Updates yylval and returns the new token type.
1394 BLOCK is the block in which lookups start; this can be NULL
1395 to mean the global scope.
1397 The result is one of NAME, NAME_OR_INT, or TYPENAME. */
1400 classify_name (struct parser_state *par_state, const struct block *block)
1403 struct block_symbol sym;
1404 struct field_of_this_result is_a_field_of_this;
1406 std::string copy = copy_name (yylval.sval);
1408 /* Try primitive types first so they win over bad/weird debug info. */
1409 type = language_lookup_primitive_type (par_state->language (),
1410 par_state->gdbarch (),
1414 /* NOTE: We take advantage of the fact that yylval coming in was a
1415 NAME, and that struct ttype is a compatible extension of struct
1416 stoken, so yylval.tsym.stoken is already filled in. */
1417 yylval.tsym.type = type;
1421 /* TODO: What about other types? */
1423 sym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN, &is_a_field_of_this);
1427 yylval.ssym.sym = sym;
1428 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
1432 /* If we didn't find a symbol, look again in the current package.
1433 This is to, e.g., make "p global_var" work without having to specify
1434 the package name. We intentionally only looks for objects in the
1438 char *current_package_name = go_block_package_name (block);
1440 if (current_package_name != NULL)
1442 struct stoken sval =
1443 build_packaged_name (current_package_name,
1444 strlen (current_package_name),
1445 copy.c_str (), copy.size ());
1447 xfree (current_package_name);
1448 sym = lookup_symbol (sval.ptr, block, VAR_DOMAIN,
1449 &is_a_field_of_this);
1452 yylval.ssym.stoken = sval;
1453 yylval.ssym.sym = sym;
1454 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
1460 /* Input names that aren't symbols but ARE valid hex numbers, when
1461 the input radix permits them, can be names or numbers depending
1462 on the parse. Note we support radixes > 16 here. */
1463 if ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
1464 || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10))
1466 YYSTYPE newlval; /* Its value is ignored. */
1467 int hextype = parse_number (par_state, copy.c_str (),
1468 yylval.sval.length, 0, &newlval);
1471 yylval.ssym.sym.symbol = NULL;
1472 yylval.ssym.sym.block = NULL;
1473 yylval.ssym.is_a_field_of_this = 0;
1478 yylval.ssym.sym.symbol = NULL;
1479 yylval.ssym.sym.block = NULL;
1480 yylval.ssym.is_a_field_of_this = 0;
1484 /* This is taken from c-exp.y mostly to get something working.
1485 The basic structure has been kept because we may yet need some of it. */
1490 token_and_value current, next;
1492 if (popping && !token_fifo.empty ())
1494 token_and_value tv = token_fifo[0];
1495 token_fifo.erase (token_fifo.begin ());
1497 /* There's no need to fall through to handle package.name
1498 as that can never happen here. In theory. */
1503 current.token = lex_one_token (pstate);
1505 /* TODO: Need a way to force specifying name1 as a package.
1508 if (current.token != NAME)
1509 return current.token;
1511 /* See if we have "name1 . name2". */
1513 current.value = yylval;
1514 next.token = lex_one_token (pstate);
1515 next.value = yylval;
1517 if (next.token == '.')
1519 token_and_value name2;
1521 name2.token = lex_one_token (pstate);
1522 name2.value = yylval;
1524 if (name2.token == NAME)
1526 /* Ok, we have "name1 . name2". */
1527 std::string copy = copy_name (current.value.sval);
1529 if (copy == "unsafe")
1532 return classify_unsafe_function (name2.value.sval);
1535 if (package_name_p (copy.c_str (), pstate->expression_context_block))
1538 yylval.sval = build_packaged_name (current.value.sval.ptr,
1539 current.value.sval.length,
1540 name2.value.sval.ptr,
1541 name2.value.sval.length);
1542 return classify_packaged_name (pstate->expression_context_block);
1546 token_fifo.push_back (next);
1547 token_fifo.push_back (name2);
1550 token_fifo.push_back (next);
1552 /* If we arrive here we don't have a package-qualified name. */
1555 yylval = current.value;
1556 return classify_name (pstate, pstate->expression_context_block);
1559 /* See language.h. */
1562 go_language::parser (struct parser_state *par_state) const
1564 /* Setting up the parser state. */
1565 scoped_restore pstate_restore = make_scoped_restore (&pstate);
1566 gdb_assert (par_state != NULL);
1569 scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
1572 /* Initialize some state used by the lexer. */
1573 last_was_structop = 0;
1574 saw_name_at_eof = 0;
1577 token_fifo.clear ();
1579 name_obstack.clear ();
1581 int result = yyparse ();
1583 pstate->set_operation (pstate->pop ());
1588 yyerror (const char *msg)
1590 if (pstate->prev_lexptr)
1591 pstate->lexptr = pstate->prev_lexptr;
1593 error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);