gdb/go-exp.y

   1 /* YACC parser for Go expressions, for GDB.
   2
   3    Copyright (C) 2012-2019 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   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.
  11
  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.
  16
  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/>.  */
  19
  20 /* This file is derived from c-exp.y, p-exp.y.  */
  21
  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.
  30
  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.  */
  38
  39 /* Known bugs or limitations:
  40
  41    - Unicode
  42    - &^
  43    - '_' (blank identifier)
  44    - automatic deref of pointers
  45    - method expressions
  46    - interfaces, channels, etc.
  47
  48    And lots of other things.
  49    I'm sure there's some cleanup to do.
  50 */
  51
  52 %{
  53
  54 #include "defs.h"
  55 #include <ctype.h>
  56 #include "expression.h"
  57 #include "value.h"
  58 #include "parser-defs.h"
  59 #include "language.h"
  60 #include "c-lang.h"
  61 #include "go-lang.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 */
  65 #include "charset.h"
  66 #include "block.h"
  67
  68 #define parse_type(ps) builtin_type (parse_gdbarch (ps))
  69
  70 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
  71    etc).  */
  72 #define GDB_YY_REMAP_PREFIX go_
  73 #include "yy-remap.h"
  74
  75 /* The state of the parser, used internally when we are parsing the
  76    expression.  */
  77
  78 static struct parser_state *pstate = NULL;
  79
  80 int yyparse (void);
  81
  82 static int yylex (void);
  83
  84 static void yyerror (const char *);
  85
  86 %}
  87
  88 /* Although the yacc "value" of an expression is not used,
  89    since the result is stored in the structure being created,
  90    other node types do have values.  */
  91
  92 %union
  93   {
  94     LONGEST lval;
  95     struct {
  96       LONGEST val;
  97       struct type *type;
  98     } typed_val_int;
  99     struct {
 100       gdb_byte val[16];
 101       struct type *type;
 102     } typed_val_float;
 103     struct stoken sval;
 104     struct symtoken ssym;
 105     struct type *tval;
 106     struct typed_stoken tsval;
 107     struct ttype tsym;
 108     int voidval;
 109     enum exp_opcode opcode;
 110     struct internalvar *ivar;
 111     struct stoken_vector svec;
 112   }
 113
 114 %{
 115 /* YYSTYPE gets defined by %union.  */
 116 static int parse_number (struct parser_state *,
 117                          const char *, int, int, YYSTYPE *);
 118 %}
 119
 120 %type <voidval> exp exp1 type_exp start variable lcurly
 121 %type <lval> rcurly
 122 %type <tval> type
 123
 124 %token <typed_val_int> INT
 125 %token <typed_val_float> FLOAT
 126
 127 /* Both NAME and TYPENAME tokens represent symbols in the input,
 128    and both convey their data as strings.
 129    But a TYPENAME is a string that happens to be defined as a type
 130    or builtin type name (such as int or char)
 131    and a NAME is any other symbol.
 132    Contexts where this distinction is not important can use the
 133    nonterminal "name", which matches either NAME or TYPENAME.  */
 134
 135 %token <tsval> RAW_STRING
 136 %token <tsval> STRING
 137 %token <tsval> CHAR
 138 %token <ssym> NAME
 139 %token <tsym> TYPENAME /* Not TYPE_NAME cus already taken.  */
 140 %token <voidval> COMPLETE
 141 /*%type <sval> name*/
 142 %type <svec> string_exp
 143 %type <ssym> name_not_typename
 144
 145 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
 146    but which would parse as a valid number in the current input radix.
 147    E.g. "c" when input_radix==16.  Depending on the parse, it will be
 148    turned into a name or into a number.  */
 149 %token <ssym> NAME_OR_INT
 150
 151 %token <lval> TRUE_KEYWORD FALSE_KEYWORD
 152 %token STRUCT_KEYWORD INTERFACE_KEYWORD TYPE_KEYWORD CHAN_KEYWORD
 153 %token SIZEOF_KEYWORD
 154 %token LEN_KEYWORD CAP_KEYWORD
 155 %token NEW_KEYWORD
 156 %token IOTA_KEYWORD NIL_KEYWORD
 157 %token CONST_KEYWORD
 158 %token DOTDOTDOT
 159 %token ENTRY
 160 %token ERROR
 161
 162 /* Special type cases.  */
 163 %token BYTE_KEYWORD /* An alias of uint8.  */
 164
 165 %token <sval> DOLLAR_VARIABLE
 166
 167 %token <opcode> ASSIGN_MODIFY
 168
 169 %left ','
 170 %left ABOVE_COMMA
 171 %right '=' ASSIGN_MODIFY
 172 %right '?'
 173 %left OROR
 174 %left ANDAND
 175 %left '|'
 176 %left '^'
 177 %left '&'
 178 %left ANDNOT
 179 %left EQUAL NOTEQUAL
 180 %left '<' '>' LEQ GEQ
 181 %left LSH RSH
 182 %left '@'
 183 %left '+' '-'
 184 %left '*' '/' '%'
 185 %right UNARY INCREMENT DECREMENT
 186 %right LEFT_ARROW '.' '[' '('
 187
 188 \f
 189 %%
 190
 191 start   :       exp1
 192         |       type_exp
 193         ;
 194
 195 type_exp:       type
 196                         { write_exp_elt_opcode (pstate, OP_TYPE);
 197                           write_exp_elt_type (pstate, $1);
 198                           write_exp_elt_opcode (pstate, OP_TYPE); }
 199         ;
 200
 201 /* Expressions, including the comma operator.  */
 202 exp1    :       exp
 203         |       exp1 ',' exp
 204                         { write_exp_elt_opcode (pstate, BINOP_COMMA); }
 205         ;
 206
 207 /* Expressions, not including the comma operator.  */
 208 exp     :       '*' exp    %prec UNARY
 209                         { write_exp_elt_opcode (pstate, UNOP_IND); }
 210         ;
 211
 212 exp     :       '&' exp    %prec UNARY
 213                         { write_exp_elt_opcode (pstate, UNOP_ADDR); }
 214         ;
 215
 216 exp     :       '-' exp    %prec UNARY
 217                         { write_exp_elt_opcode (pstate, UNOP_NEG); }
 218         ;
 219
 220 exp     :       '+' exp    %prec UNARY
 221                         { write_exp_elt_opcode (pstate, UNOP_PLUS); }
 222         ;
 223
 224 exp     :       '!' exp    %prec UNARY
 225                         { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
 226         ;
 227
 228 exp     :       '^' exp    %prec UNARY
 229                         { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); }
 230         ;
 231
 232 exp     :       exp INCREMENT    %prec UNARY
 233                         { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); }
 234         ;
 235
 236 exp     :       exp DECREMENT    %prec UNARY
 237                         { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); }
 238         ;
 239
 240 /* foo->bar is not in Go.  May want as a gdb extension.  Later.  */
 241
 242 exp     :       exp '.' name_not_typename
 243                         { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
 244                           write_exp_string (pstate, $3.stoken);
 245                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
 246         ;
 247
 248 exp     :       exp '.' name_not_typename COMPLETE
 249                         { mark_struct_expression (pstate);
 250                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
 251                           write_exp_string (pstate, $3.stoken);
 252                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
 253         ;
 254
 255 exp     :       exp '.' COMPLETE
 256                         { struct stoken s;
 257                           mark_struct_expression (pstate);
 258                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
 259                           s.ptr = "";
 260                           s.length = 0;
 261                           write_exp_string (pstate, s);
 262                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
 263         ;
 264
 265 exp     :       exp '[' exp1 ']'
 266                         { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }
 267         ;
 268
 269 exp     :       exp '('
 270                         /* This is to save the value of arglist_len
 271                            being accumulated by an outer function call.  */
 272                         { start_arglist (); }
 273                 arglist ')'     %prec LEFT_ARROW
 274                         { write_exp_elt_opcode (pstate, OP_FUNCALL);
 275                           write_exp_elt_longcst (pstate,
 276                                                  (LONGEST) end_arglist ());
 277                           write_exp_elt_opcode (pstate, OP_FUNCALL); }
 278         ;
 279
 280 lcurly  :       '{'
 281                         { start_arglist (); }
 282         ;
 283
 284 arglist :
 285         ;
 286
 287 arglist :       exp
 288                         { arglist_len = 1; }
 289         ;
 290
 291 arglist :       arglist ',' exp   %prec ABOVE_COMMA
 292                         { arglist_len++; }
 293         ;
 294
 295 rcurly  :       '}'
 296                         { $$ = end_arglist () - 1; }
 297         ;
 298
 299 exp     :       lcurly type rcurly exp  %prec UNARY
 300                         { write_exp_elt_opcode (pstate, UNOP_MEMVAL);
 301                           write_exp_elt_type (pstate, $2);
 302                           write_exp_elt_opcode (pstate, UNOP_MEMVAL); }
 303         ;
 304
 305 exp     :       type '(' exp ')'  %prec UNARY
 306                         { write_exp_elt_opcode (pstate, UNOP_CAST);
 307                           write_exp_elt_type (pstate, $1);
 308                           write_exp_elt_opcode (pstate, UNOP_CAST); }
 309         ;
 310
 311 exp     :       '(' exp1 ')'
 312                         { }
 313         ;
 314
 315 /* Binary operators in order of decreasing precedence.  */
 316
 317 exp     :       exp '@' exp
 318                         { write_exp_elt_opcode (pstate, BINOP_REPEAT); }
 319         ;
 320
 321 exp     :       exp '*' exp
 322                         { write_exp_elt_opcode (pstate, BINOP_MUL); }
 323         ;
 324
 325 exp     :       exp '/' exp
 326                         { write_exp_elt_opcode (pstate, BINOP_DIV); }
 327         ;
 328
 329 exp     :       exp '%' exp
 330                         { write_exp_elt_opcode (pstate, BINOP_REM); }
 331         ;
 332
 333 exp     :       exp '+' exp
 334                         { write_exp_elt_opcode (pstate, BINOP_ADD); }
 335         ;
 336
 337 exp     :       exp '-' exp
 338                         { write_exp_elt_opcode (pstate, BINOP_SUB); }
 339         ;
 340
 341 exp     :       exp LSH exp
 342                         { write_exp_elt_opcode (pstate, BINOP_LSH); }
 343         ;
 344
 345 exp     :       exp RSH exp
 346                         { write_exp_elt_opcode (pstate, BINOP_RSH); }
 347         ;
 348
 349 exp     :       exp EQUAL exp
 350                         { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
 351         ;
 352
 353 exp     :       exp NOTEQUAL exp
 354                         { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
 355         ;
 356
 357 exp     :       exp LEQ exp
 358                         { write_exp_elt_opcode (pstate, BINOP_LEQ); }
 359         ;
 360
 361 exp     :       exp GEQ exp
 362                         { write_exp_elt_opcode (pstate, BINOP_GEQ); }
 363         ;
 364
 365 exp     :       exp '<' exp
 366                         { write_exp_elt_opcode (pstate, BINOP_LESS); }
 367         ;
 368
 369 exp     :       exp '>' exp
 370                         { write_exp_elt_opcode (pstate, BINOP_GTR); }
 371         ;
 372
 373 exp     :       exp '&' exp
 374                         { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
 375         ;
 376
 377 exp     :       exp '^' exp
 378                         { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
 379         ;
 380
 381 exp     :       exp '|' exp
 382                         { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
 383         ;
 384
 385 exp     :       exp ANDAND exp
 386                         { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
 387         ;
 388
 389 exp     :       exp OROR exp
 390                         { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
 391         ;
 392
 393 exp     :       exp '?' exp ':' exp     %prec '?'
 394                         { write_exp_elt_opcode (pstate, TERNOP_COND); }
 395         ;
 396
 397 exp     :       exp '=' exp
 398                         { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
 399         ;
 400
 401 exp     :       exp ASSIGN_MODIFY exp
 402                         { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
 403                           write_exp_elt_opcode (pstate, $2);
 404                           write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY); }
 405         ;
 406
 407 exp     :       INT
 408                         { write_exp_elt_opcode (pstate, OP_LONG);
 409                           write_exp_elt_type (pstate, $1.type);
 410                           write_exp_elt_longcst (pstate, (LONGEST)($1.val));
 411                           write_exp_elt_opcode (pstate, OP_LONG); }
 412         ;
 413
 414 exp     :       CHAR
 415                         {
 416                           struct stoken_vector vec;
 417                           vec.len = 1;
 418                           vec.tokens = &$1;
 419                           write_exp_string_vector (pstate, $1.type, &vec);
 420                         }
 421         ;
 422
 423 exp     :       NAME_OR_INT
 424                         { YYSTYPE val;
 425                           parse_number (pstate, $1.stoken.ptr,
 426                                         $1.stoken.length, 0, &val);
 427                           write_exp_elt_opcode (pstate, OP_LONG);
 428                           write_exp_elt_type (pstate, val.typed_val_int.type);
 429                           write_exp_elt_longcst (pstate, (LONGEST)
 430                                                  val.typed_val_int.val);
 431                           write_exp_elt_opcode (pstate, OP_LONG);
 432                         }
 433         ;
 434
 435
 436 exp     :       FLOAT
 437                         { write_exp_elt_opcode (pstate, OP_FLOAT);
 438                           write_exp_elt_type (pstate, $1.type);
 439                           write_exp_elt_floatcst (pstate, $1.val);
 440                           write_exp_elt_opcode (pstate, OP_FLOAT); }
 441         ;
 442
 443 exp     :       variable
 444         ;
 445
 446 exp     :       DOLLAR_VARIABLE
 447                         {
 448                           write_dollar_variable (pstate, $1);
 449                         }
 450         ;
 451
 452 exp     :       SIZEOF_KEYWORD '(' type ')'  %prec UNARY
 453                         {
 454                           /* TODO(dje): Go objects in structs.  */
 455                           write_exp_elt_opcode (pstate, OP_LONG);
 456                           /* TODO(dje): What's the right type here?  */
 457                           write_exp_elt_type
 458                             (pstate,
 459                              parse_type (pstate)->builtin_unsigned_int);
 460                           $3 = check_typedef ($3);
 461                           write_exp_elt_longcst (pstate,
 462                                                  (LONGEST) TYPE_LENGTH ($3));
 463                           write_exp_elt_opcode (pstate, OP_LONG);
 464                         }
 465         ;
 466
 467 exp     :       SIZEOF_KEYWORD  '(' exp ')'  %prec UNARY
 468                         {
 469                           /* TODO(dje): Go objects in structs.  */
 470                           write_exp_elt_opcode (pstate, UNOP_SIZEOF);
 471                         }
 472
 473 string_exp:
 474                 STRING
 475                         {
 476                           /* We copy the string here, and not in the
 477                              lexer, to guarantee that we do not leak a
 478                              string.  */
 479                           /* Note that we NUL-terminate here, but just
 480                              for convenience.  */
 481                           struct typed_stoken *vec = XNEW (struct typed_stoken);
 482                           $$.len = 1;
 483                           $$.tokens = vec;
 484
 485                           vec->type = $1.type;
 486                           vec->length = $1.length;
 487                           vec->ptr = (char *) malloc ($1.length + 1);
 488                           memcpy (vec->ptr, $1.ptr, $1.length + 1);
 489                         }
 490
 491         |       string_exp '+' STRING
 492                         {
 493                           /* Note that we NUL-terminate here, but just
 494                              for convenience.  */
 495                           char *p;
 496                           ++$$.len;
 497                           $$.tokens = XRESIZEVEC (struct typed_stoken,
 498                                                   $$.tokens, $$.len);
 499
 500                           p = (char *) malloc ($3.length + 1);
 501                           memcpy (p, $3.ptr, $3.length + 1);
 502
 503                           $$.tokens[$$.len - 1].type = $3.type;
 504                           $$.tokens[$$.len - 1].length = $3.length;
 505                           $$.tokens[$$.len - 1].ptr = p;
 506                         }
 507         ;
 508
 509 exp     :       string_exp  %prec ABOVE_COMMA
 510                         {
 511                           int i;
 512
 513                           write_exp_string_vector (pstate, 0 /*always utf8*/,
 514                                                    &$1);
 515                           for (i = 0; i < $1.len; ++i)
 516                             free ($1.tokens[i].ptr);
 517                           free ($1.tokens);
 518                         }
 519         ;
 520
 521 exp     :       TRUE_KEYWORD
 522                         { write_exp_elt_opcode (pstate, OP_BOOL);
 523                           write_exp_elt_longcst (pstate, (LONGEST) $1);
 524                           write_exp_elt_opcode (pstate, OP_BOOL); }
 525         ;
 526
 527 exp     :       FALSE_KEYWORD
 528                         { write_exp_elt_opcode (pstate, OP_BOOL);
 529                           write_exp_elt_longcst (pstate, (LONGEST) $1);
 530                           write_exp_elt_opcode (pstate, OP_BOOL); }
 531         ;
 532
 533 variable:       name_not_typename ENTRY
 534                         { struct symbol *sym = $1.sym.symbol;
 535
 536                           if (sym == NULL
 537                               || !SYMBOL_IS_ARGUMENT (sym)
 538                               || !symbol_read_needs_frame (sym))
 539                             error (_("@entry can be used only for function "
 540                                      "parameters, not for \"%s\""),
 541                                    copy_name ($1.stoken));
 542
 543                           write_exp_elt_opcode (pstate, OP_VAR_ENTRY_VALUE);
 544                           write_exp_elt_sym (pstate, sym);
 545                           write_exp_elt_opcode (pstate, OP_VAR_ENTRY_VALUE);
 546                         }
 547         ;
 548
 549 variable:       name_not_typename
 550                         { struct block_symbol sym = $1.sym;
 551
 552                           if (sym.symbol)
 553                             {
 554                               if (symbol_read_needs_frame (sym.symbol))
 555                                 innermost_block.update (sym);
 556
 557                               write_exp_elt_opcode (pstate, OP_VAR_VALUE);
 558                               write_exp_elt_block (pstate, sym.block);
 559                               write_exp_elt_sym (pstate, sym.symbol);
 560                               write_exp_elt_opcode (pstate, OP_VAR_VALUE);
 561                             }
 562                           else if ($1.is_a_field_of_this)
 563                             {
 564                               /* TODO(dje): Can we get here?
 565                                  E.g., via a mix of c++ and go?  */
 566                               gdb_assert_not_reached ("go with `this' field");
 567                             }
 568                           else
 569                             {
 570                               struct bound_minimal_symbol msymbol;
 571                               char *arg = copy_name ($1.stoken);
 572
 573                               msymbol =
 574                                 lookup_bound_minimal_symbol (arg);
 575                               if (msymbol.minsym != NULL)
 576                                 write_exp_msymbol (pstate, msymbol);
 577                               else if (!have_full_symbols ()
 578                                        && !have_partial_symbols ())
 579                                 error (_("No symbol table is loaded.  "
 580                                        "Use the \"file\" command."));
 581                               else
 582                                 error (_("No symbol \"%s\" in current context."),
 583                                        copy_name ($1.stoken));
 584                             }
 585                         }
 586         ;
 587
 588 /* TODO
 589 method_exp: PACKAGENAME '.' name '.' name
 590                         {
 591                         }
 592         ;
 593 */
 594
 595 type  /* Implements (approximately): [*] type-specifier */
 596         :       '*' type
 597                         { $$ = lookup_pointer_type ($2); }
 598         |       TYPENAME
 599                         { $$ = $1.type; }
 600 /*
 601         |       STRUCT_KEYWORD name
 602                         { $$ = lookup_struct (copy_name ($2),
 603                                               expression_context_block); }
 604 */
 605         |       BYTE_KEYWORD
 606                         { $$ = builtin_go_type (parse_gdbarch (pstate))
 607                             ->builtin_uint8; }
 608         ;
 609
 610 /* TODO
 611 name    :       NAME { $$ = $1.stoken; }
 612         |       TYPENAME { $$ = $1.stoken; }
 613         |       NAME_OR_INT  { $$ = $1.stoken; }
 614         ;
 615 */
 616
 617 name_not_typename
 618         :       NAME
 619 /* These would be useful if name_not_typename was useful, but it is just
 620    a fake for "variable", so these cause reduce/reduce conflicts because
 621    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
 622    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
 623    context where only a name could occur, this might be useful.
 624         |       NAME_OR_INT
 625 */
 626         ;
 627
 628 %%
 629
 630 /* Take care of parsing a number (anything that starts with a digit).
 631    Set yylval and return the token type; update lexptr.
 632    LEN is the number of characters in it.  */
 633
 634 /* FIXME: Needs some error checking for the float case.  */
 635 /* FIXME(dje): IWBN to use c-exp.y's parse_number if we could.
 636    That will require moving the guts into a function that we both call
 637    as our YYSTYPE is different than c-exp.y's  */
 638
 639 static int
 640 parse_number (struct parser_state *par_state,
 641               const char *p, int len, int parsed_float, YYSTYPE *putithere)
 642 {
 643   /* FIXME: Shouldn't these be unsigned?  We don't deal with negative values
 644      here, and we do kind of silly things like cast to unsigned.  */
 645   LONGEST n = 0;
 646   LONGEST prevn = 0;
 647   ULONGEST un;
 648
 649   int i = 0;
 650   int c;
 651   int base = input_radix;
 652   int unsigned_p = 0;
 653
 654   /* Number of "L" suffixes encountered.  */
 655   int long_p = 0;
 656
 657   /* We have found a "L" or "U" suffix.  */
 658   int found_suffix = 0;
 659
 660   ULONGEST high_bit;
 661   struct type *signed_type;
 662   struct type *unsigned_type;
 663
 664   if (parsed_float)
 665     {
 666       const struct builtin_go_type *builtin_go_types
 667         = builtin_go_type (parse_gdbarch (par_state));
 668
 669       /* Handle suffixes: 'f' for float32, 'l' for long double.
 670          FIXME: This appears to be an extension -- do we want this?  */
 671       if (len >= 1 && tolower (p[len - 1]) == 'f')
 672         {
 673           putithere->typed_val_float.type
 674             = builtin_go_types->builtin_float32;
 675           len--;
 676         }
 677       else if (len >= 1 && tolower (p[len - 1]) == 'l')
 678         {
 679           putithere->typed_val_float.type
 680             = parse_type (par_state)->builtin_long_double;
 681           len--;
 682         }
 683       /* Default type for floating-point literals is float64.  */
 684       else
 685         {
 686           putithere->typed_val_float.type
 687             = builtin_go_types->builtin_float64;
 688         }
 689
 690       if (!parse_float (p, len,
 691                         putithere->typed_val_float.type,
 692                         putithere->typed_val_float.val))
 693         return ERROR;
 694       return FLOAT;
 695     }
 696
 697   /* Handle base-switching prefixes 0x, 0t, 0d, 0.  */
 698   if (p[0] == '0')
 699     switch (p[1])
 700       {
 701       case 'x':
 702       case 'X':
 703         if (len >= 3)
 704           {
 705             p += 2;
 706             base = 16;
 707             len -= 2;
 708           }
 709         break;
 710
 711       case 'b':
 712       case 'B':
 713         if (len >= 3)
 714           {
 715             p += 2;
 716             base = 2;
 717             len -= 2;
 718           }
 719         break;
 720
 721       case 't':
 722       case 'T':
 723       case 'd':
 724       case 'D':
 725         if (len >= 3)
 726           {
 727             p += 2;
 728             base = 10;
 729             len -= 2;
 730           }
 731         break;
 732
 733       default:
 734         base = 8;
 735         break;
 736       }
 737
 738   while (len-- > 0)
 739     {
 740       c = *p++;
 741       if (c >= 'A' && c <= 'Z')
 742         c += 'a' - 'A';
 743       if (c != 'l' && c != 'u')
 744         n *= base;
 745       if (c >= '0' && c <= '9')
 746         {
 747           if (found_suffix)
 748             return ERROR;
 749           n += i = c - '0';
 750         }
 751       else
 752         {
 753           if (base > 10 && c >= 'a' && c <= 'f')
 754             {
 755               if (found_suffix)
 756                 return ERROR;
 757               n += i = c - 'a' + 10;
 758             }
 759           else if (c == 'l')
 760             {
 761               ++long_p;
 762               found_suffix = 1;
 763             }
 764           else if (c == 'u')
 765             {
 766               unsigned_p = 1;
 767               found_suffix = 1;
 768             }
 769           else
 770             return ERROR;       /* Char not a digit */
 771         }
 772       if (i >= base)
 773         return ERROR;           /* Invalid digit in this base.  */
 774
 775       /* Portably test for overflow (only works for nonzero values, so make
 776          a second check for zero).  FIXME: Can't we just make n and prevn
 777          unsigned and avoid this?  */
 778       if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
 779         unsigned_p = 1;         /* Try something unsigned.  */
 780
 781       /* Portably test for unsigned overflow.
 782          FIXME: This check is wrong; for example it doesn't find overflow
 783          on 0x123456789 when LONGEST is 32 bits.  */
 784       if (c != 'l' && c != 'u' && n != 0)
 785         {
 786           if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
 787             error (_("Numeric constant too large."));
 788         }
 789       prevn = n;
 790     }
 791
 792   /* An integer constant is an int, a long, or a long long.  An L
 793      suffix forces it to be long; an LL suffix forces it to be long
 794      long.  If not forced to a larger size, it gets the first type of
 795      the above that it fits in.  To figure out whether it fits, we
 796      shift it right and see whether anything remains.  Note that we
 797      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
 798      operation, because many compilers will warn about such a shift
 799      (which always produces a zero result).  Sometimes gdbarch_int_bit
 800      or gdbarch_long_bit will be that big, sometimes not.  To deal with
 801      the case where it is we just always shift the value more than
 802      once, with fewer bits each time.  */
 803
 804   un = (ULONGEST)n >> 2;
 805   if (long_p == 0
 806       && (un >> (gdbarch_int_bit (parse_gdbarch (par_state)) - 2)) == 0)
 807     {
 808       high_bit
 809         = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state)) - 1);
 810
 811       /* A large decimal (not hex or octal) constant (between INT_MAX
 812          and UINT_MAX) is a long or unsigned long, according to ANSI,
 813          never an unsigned int, but this code treats it as unsigned
 814          int.  This probably should be fixed.  GCC gives a warning on
 815          such constants.  */
 816
 817       unsigned_type = parse_type (par_state)->builtin_unsigned_int;
 818       signed_type = parse_type (par_state)->builtin_int;
 819     }
 820   else if (long_p <= 1
 821            && (un >> (gdbarch_long_bit (parse_gdbarch (par_state)) - 2)) == 0)
 822     {
 823       high_bit
 824         = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch (par_state)) - 1);
 825       unsigned_type = parse_type (par_state)->builtin_unsigned_long;
 826       signed_type = parse_type (par_state)->builtin_long;
 827     }
 828   else
 829     {
 830       int shift;
 831       if (sizeof (ULONGEST) * HOST_CHAR_BIT
 832           < gdbarch_long_long_bit (parse_gdbarch (par_state)))
 833         /* A long long does not fit in a LONGEST.  */
 834         shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
 835       else
 836         shift = (gdbarch_long_long_bit (parse_gdbarch (par_state)) - 1);
 837       high_bit = (ULONGEST) 1 << shift;
 838       unsigned_type = parse_type (par_state)->builtin_unsigned_long_long;
 839       signed_type = parse_type (par_state)->builtin_long_long;
 840     }
 841
 842    putithere->typed_val_int.val = n;
 843
 844    /* If the high bit of the worked out type is set then this number
 845       has to be unsigned.  */
 846
 847    if (unsigned_p || (n & high_bit))
 848      {
 849        putithere->typed_val_int.type = unsigned_type;
 850      }
 851    else
 852      {
 853        putithere->typed_val_int.type = signed_type;
 854      }
 855
 856    return INT;
 857 }
 858
 859 /* Temporary obstack used for holding strings.  */
 860 static struct obstack tempbuf;
 861 static int tempbuf_init;
 862
 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.  */
 869
 870 static int
 871 parse_string_or_char (const char *tokptr, const char **outptr,
 872                       struct typed_stoken *value, int *host_chars)
 873 {
 874   int quote;
 875
 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
 883      bytes */
 884
 885   if (!tempbuf_init)
 886     tempbuf_init = 1;
 887   else
 888     obstack_free (&tempbuf, NULL);
 889   obstack_init (&tempbuf);
 890
 891   /* Skip the quote.  */
 892   quote = *tokptr;
 893   ++tokptr;
 894
 895   *host_chars = 0;
 896
 897   while (*tokptr)
 898     {
 899       char c = *tokptr;
 900       if (c == '\\')
 901         {
 902           ++tokptr;
 903           *host_chars += c_parse_escape (&tokptr, &tempbuf);
 904         }
 905       else if (c == quote)
 906         break;
 907       else
 908         {
 909           obstack_1grow (&tempbuf, c);
 910           ++tokptr;
 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.  */
 914           ++*host_chars;
 915         }
 916     }
 917
 918   if (*tokptr != quote)
 919     {
 920       if (quote == '"')
 921         error (_("Unterminated string in expression."));
 922       else
 923         error (_("Unmatched single quote."));
 924     }
 925   ++tokptr;
 926
 927   value->type = C_STRING | (quote == '\'' ? C_CHAR : 0); /*FIXME*/
 928   value->ptr = (char *) obstack_base (&tempbuf);
 929   value->length = obstack_object_size (&tempbuf);
 930
 931   *outptr = tokptr;
 932
 933   return quote == '\'' ? CHAR : STRING;
 934 }
 935
 936 struct token
 937 {
 938   const char *oper;
 939   int token;
 940   enum exp_opcode opcode;
 941 };
 942
 943 static const struct token tokentab3[] =
 944   {
 945     {">>=", ASSIGN_MODIFY, BINOP_RSH},
 946     {"<<=", ASSIGN_MODIFY, BINOP_LSH},
 947     /*{"&^=", ASSIGN_MODIFY, BINOP_BITWISE_ANDNOT}, TODO */
 948     {"...", DOTDOTDOT, OP_NULL},
 949   };
 950
 951 static const struct token tokentab2[] =
 952   {
 953     {"+=", ASSIGN_MODIFY, BINOP_ADD},
 954     {"-=", ASSIGN_MODIFY, BINOP_SUB},
 955     {"*=", ASSIGN_MODIFY, BINOP_MUL},
 956     {"/=", ASSIGN_MODIFY, BINOP_DIV},
 957     {"%=", ASSIGN_MODIFY, BINOP_REM},
 958     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
 959     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
 960     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
 961     {"++", INCREMENT, BINOP_END},
 962     {"--", DECREMENT, BINOP_END},
 963     /*{"->", RIGHT_ARROW, BINOP_END}, Doesn't exist in Go.  */
 964     {"<-", LEFT_ARROW, BINOP_END},
 965     {"&&", ANDAND, BINOP_END},
 966     {"||", OROR, BINOP_END},
 967     {"<<", LSH, BINOP_END},
 968     {">>", RSH, BINOP_END},
 969     {"==", EQUAL, BINOP_END},
 970     {"!=", NOTEQUAL, BINOP_END},
 971     {"<=", LEQ, BINOP_END},
 972     {">=", GEQ, BINOP_END},
 973     /*{"&^", ANDNOT, BINOP_END}, TODO */
 974   };
 975
 976 /* Identifier-like tokens.  */
 977 static const struct token ident_tokens[] =
 978   {
 979     {"true", TRUE_KEYWORD, OP_NULL},
 980     {"false", FALSE_KEYWORD, OP_NULL},
 981     {"nil", NIL_KEYWORD, OP_NULL},
 982     {"const", CONST_KEYWORD, OP_NULL},
 983     {"struct", STRUCT_KEYWORD, OP_NULL},
 984     {"type", TYPE_KEYWORD, OP_NULL},
 985     {"interface", INTERFACE_KEYWORD, OP_NULL},
 986     {"chan", CHAN_KEYWORD, OP_NULL},
 987     {"byte", BYTE_KEYWORD, OP_NULL}, /* An alias of uint8.  */
 988     {"len", LEN_KEYWORD, OP_NULL},
 989     {"cap", CAP_KEYWORD, OP_NULL},
 990     {"new", NEW_KEYWORD, OP_NULL},
 991     {"iota", IOTA_KEYWORD, OP_NULL},
 992   };
 993
 994 /* This is set if a NAME token appeared at the very end of the input
 995    string, with no whitespace separating the name from the EOF.  This
 996    is used only when parsing to do field name completion.  */
 997 static int saw_name_at_eof;
 998
 999 /* This is set if the previously-returned token was a structure
1000    operator -- either '.' or ARROW.  This is used only when parsing to
1001    do field name completion.  */
1002 static int last_was_structop;
1003
1004 /* Read one token, getting characters through lexptr.  */
1005
1006 static int
1007 lex_one_token (struct parser_state *par_state)
1008 {
1009   int c;
1010   int namelen;
1011   unsigned int i;
1012   const char *tokstart;
1013   int saw_structop = last_was_structop;
1014   char *copy;
1015
1016   last_was_structop = 0;
1017
1018  retry:
1019
1020   prev_lexptr = lexptr;
1021
1022   tokstart = lexptr;
1023   /* See if it is a special token of length 3.  */
1024   for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
1025     if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
1026       {
1027         lexptr += 3;
1028         yylval.opcode = tokentab3[i].opcode;
1029         return tokentab3[i].token;
1030       }
1031
1032   /* See if it is a special token of length 2.  */
1033   for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
1034     if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
1035       {
1036         lexptr += 2;
1037         yylval.opcode = tokentab2[i].opcode;
1038         /* NOTE: -> doesn't exist in Go, so we don't need to watch for
1039            setting last_was_structop here.  */
1040         return tokentab2[i].token;
1041       }
1042
1043   switch (c = *tokstart)
1044     {
1045     case 0:
1046       if (saw_name_at_eof)
1047         {
1048           saw_name_at_eof = 0;
1049           return COMPLETE;
1050         }
1051       else if (saw_structop)
1052         return COMPLETE;
1053       else
1054         return 0;
1055
1056     case ' ':
1057     case '\t':
1058     case '\n':
1059       lexptr++;
1060       goto retry;
1061
1062     case '[':
1063     case '(':
1064       paren_depth++;
1065       lexptr++;
1066       return c;
1067
1068     case ']':
1069     case ')':
1070       if (paren_depth == 0)
1071         return 0;
1072       paren_depth--;
1073       lexptr++;
1074       return c;
1075
1076     case ',':
1077       if (comma_terminates
1078           && paren_depth == 0)
1079         return 0;
1080       lexptr++;
1081       return c;
1082
1083     case '.':
1084       /* Might be a floating point number.  */
1085       if (lexptr[1] < '0' || lexptr[1] > '9')
1086         {
1087           if (parse_completion)
1088             last_was_structop = 1;
1089           goto symbol;          /* Nope, must be a symbol. */
1090         }
1091       /* FALL THRU.  */
1092
1093     case '0':
1094     case '1':
1095     case '2':
1096     case '3':
1097     case '4':
1098     case '5':
1099     case '6':
1100     case '7':
1101     case '8':
1102     case '9':
1103       {
1104         /* It's a number.  */
1105         int got_dot = 0, got_e = 0, toktype;
1106         const char *p = tokstart;
1107         int hex = input_radix > 10;
1108
1109         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1110           {
1111             p += 2;
1112             hex = 1;
1113           }
1114
1115         for (;; ++p)
1116           {
1117             /* This test includes !hex because 'e' is a valid hex digit
1118                and thus does not indicate a floating point number when
1119                the radix is hex.  */
1120             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1121               got_dot = got_e = 1;
1122             /* This test does not include !hex, because a '.' always indicates
1123                a decimal floating point number regardless of the radix.  */
1124             else if (!got_dot && *p == '.')
1125               got_dot = 1;
1126             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1127                      && (*p == '-' || *p == '+'))
1128               /* This is the sign of the exponent, not the end of the
1129                  number.  */
1130               continue;
1131             /* We will take any letters or digits.  parse_number will
1132                complain if past the radix, or if L or U are not final.  */
1133             else if ((*p < '0' || *p > '9')
1134                      && ((*p < 'a' || *p > 'z')
1135                                   && (*p < 'A' || *p > 'Z')))
1136               break;
1137           }
1138         toktype = parse_number (par_state, tokstart, p - tokstart,
1139                                 got_dot|got_e, &yylval);
1140         if (toktype == ERROR)
1141           {
1142             char *err_copy = (char *) alloca (p - tokstart + 1);
1143
1144             memcpy (err_copy, tokstart, p - tokstart);
1145             err_copy[p - tokstart] = 0;
1146             error (_("Invalid number \"%s\"."), err_copy);
1147           }
1148         lexptr = p;
1149         return toktype;
1150       }
1151
1152     case '@':
1153       {
1154         const char *p = &tokstart[1];
1155         size_t len = strlen ("entry");
1156
1157         while (isspace (*p))
1158           p++;
1159         if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1160             && p[len] != '_')
1161           {
1162             lexptr = &p[len];
1163             return ENTRY;
1164           }
1165       }
1166       /* FALLTHRU */
1167     case '+':
1168     case '-':
1169     case '*':
1170     case '/':
1171     case '%':
1172     case '|':
1173     case '&':
1174     case '^':
1175     case '~':
1176     case '!':
1177     case '<':
1178     case '>':
1179     case '?':
1180     case ':':
1181     case '=':
1182     case '{':
1183     case '}':
1184     symbol:
1185       lexptr++;
1186       return c;
1187
1188     case '\'':
1189     case '"':
1190     case '`':
1191       {
1192         int host_len;
1193         int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
1194                                            &host_len);
1195         if (result == CHAR)
1196           {
1197             if (host_len == 0)
1198               error (_("Empty character constant."));
1199             else if (host_len > 2 && c == '\'')
1200               {
1201                 ++tokstart;
1202                 namelen = lexptr - tokstart - 1;
1203                 goto tryname;
1204               }
1205             else if (host_len > 1)
1206               error (_("Invalid character constant."));
1207           }
1208         return result;
1209       }
1210     }
1211
1212   if (!(c == '_' || c == '$'
1213         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1214     /* We must have come across a bad character (e.g. ';').  */
1215     error (_("Invalid character '%c' in expression."), c);
1216
1217   /* It's a name.  See how long it is.  */
1218   namelen = 0;
1219   for (c = tokstart[namelen];
1220        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1221         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1222     {
1223       c = tokstart[++namelen];
1224     }
1225
1226   /* The token "if" terminates the expression and is NOT removed from
1227      the input stream.  It doesn't count if it appears in the
1228      expansion of a macro.  */
1229   if (namelen == 2
1230       && tokstart[0] == 'i'
1231       && tokstart[1] == 'f')
1232     {
1233       return 0;
1234     }
1235
1236   /* For the same reason (breakpoint conditions), "thread N"
1237      terminates the expression.  "thread" could be an identifier, but
1238      an identifier is never followed by a number without intervening
1239      punctuation.
1240      Handle abbreviations of these, similarly to
1241      breakpoint.c:find_condition_and_thread.
1242      TODO: Watch for "goroutine" here?  */
1243   if (namelen >= 1
1244       && strncmp (tokstart, "thread", namelen) == 0
1245       && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1246     {
1247       const char *p = tokstart + namelen + 1;
1248
1249       while (*p == ' ' || *p == '\t')
1250         p++;
1251       if (*p >= '0' && *p <= '9')
1252         return 0;
1253     }
1254
1255   lexptr += namelen;
1256
1257   tryname:
1258
1259   yylval.sval.ptr = tokstart;
1260   yylval.sval.length = namelen;
1261
1262   /* Catch specific keywords.  */
1263   copy = copy_name (yylval.sval);
1264   for (i = 0; i < sizeof (ident_tokens) / sizeof (ident_tokens[0]); i++)
1265     if (strcmp (copy, ident_tokens[i].oper) == 0)
1266       {
1267         /* It is ok to always set this, even though we don't always
1268            strictly need to.  */
1269         yylval.opcode = ident_tokens[i].opcode;
1270         return ident_tokens[i].token;
1271       }
1272
1273   if (*tokstart == '$')
1274     return DOLLAR_VARIABLE;
1275
1276   if (parse_completion && *lexptr == '\0')
1277     saw_name_at_eof = 1;
1278   return NAME;
1279 }
1280
1281 /* An object of this type is pushed on a FIFO by the "outer" lexer.  */
1282 struct token_and_value
1283 {
1284   int token;
1285   YYSTYPE value;
1286 };
1287
1288 /* A FIFO of tokens that have been read but not yet returned to the
1289    parser.  */
1290 static std::vector<token_and_value> token_fifo;
1291
1292 /* Non-zero if the lexer should return tokens from the FIFO.  */
1293 static int popping;
1294
1295 /* Temporary storage for yylex; this holds symbol names as they are
1296    built up.  */
1297 static auto_obstack name_obstack;
1298
1299 /* Build "package.name" in name_obstack.
1300    For convenience of the caller, the name is NUL-terminated,
1301    but the NUL is not included in the recorded length.  */
1302
1303 static struct stoken
1304 build_packaged_name (const char *package, int package_len,
1305                      const char *name, int name_len)
1306 {
1307   struct stoken result;
1308
1309   name_obstack.clear ();
1310   obstack_grow (&name_obstack, package, package_len);
1311   obstack_grow_str (&name_obstack, ".");
1312   obstack_grow (&name_obstack, name, name_len);
1313   obstack_grow (&name_obstack, "", 1);
1314   result.ptr = (char *) obstack_base (&name_obstack);
1315   result.length = obstack_object_size (&name_obstack) - 1;
1316
1317   return result;
1318 }
1319
1320 /* Return non-zero if NAME is a package name.
1321    BLOCK is the scope in which to interpret NAME; this can be NULL
1322    to mean the global scope.  */
1323
1324 static int
1325 package_name_p (const char *name, const struct block *block)
1326 {
1327   struct symbol *sym;
1328   struct field_of_this_result is_a_field_of_this;
1329
1330   sym = lookup_symbol (name, block, STRUCT_DOMAIN, &is_a_field_of_this).symbol;
1331
1332   if (sym
1333       && SYMBOL_CLASS (sym) == LOC_TYPEDEF
1334       && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_MODULE)
1335     return 1;
1336
1337   return 0;
1338 }
1339
1340 /* Classify a (potential) function in the "unsafe" package.
1341    We fold these into "keywords" to keep things simple, at least until
1342    something more complex is warranted.  */
1343
1344 static int
1345 classify_unsafe_function (struct stoken function_name)
1346 {
1347   char *copy = copy_name (function_name);
1348
1349   if (strcmp (copy, "Sizeof") == 0)
1350     {
1351       yylval.sval = function_name;
1352       return SIZEOF_KEYWORD;
1353     }
1354
1355   error (_("Unknown function in `unsafe' package: %s"), copy);
1356 }
1357
1358 /* Classify token(s) "name1.name2" where name1 is known to be a package.
1359    The contents of the token are in `yylval'.
1360    Updates yylval and returns the new token type.
1361
1362    The result is one of NAME, NAME_OR_INT, or TYPENAME.  */
1363
1364 static int
1365 classify_packaged_name (const struct block *block)
1366 {
1367   char *copy;
1368   struct block_symbol sym;
1369   struct field_of_this_result is_a_field_of_this;
1370
1371   copy = copy_name (yylval.sval);
1372
1373   sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
1374
1375   if (sym.symbol)
1376     {
1377       yylval.ssym.sym = sym;
1378       yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
1379     }
1380
1381   return NAME;
1382 }
1383
1384 /* Classify a NAME token.
1385    The contents of the token are in `yylval'.
1386    Updates yylval and returns the new token type.
1387    BLOCK is the block in which lookups start; this can be NULL
1388    to mean the global scope.
1389
1390    The result is one of NAME, NAME_OR_INT, or TYPENAME.  */
1391
1392 static int
1393 classify_name (struct parser_state *par_state, const struct block *block)
1394 {
1395   struct type *type;
1396   struct block_symbol sym;
1397   char *copy;
1398   struct field_of_this_result is_a_field_of_this;
1399
1400   copy = copy_name (yylval.sval);
1401
1402   /* Try primitive types first so they win over bad/weird debug info.  */
1403   type = language_lookup_primitive_type (parse_language (par_state),
1404                                          parse_gdbarch (par_state),
1405                                          copy);
1406   if (type != NULL)
1407     {
1408       /* NOTE: We take advantage of the fact that yylval coming in was a
1409          NAME, and that struct ttype is a compatible extension of struct
1410          stoken, so yylval.tsym.stoken is already filled in.  */
1411       yylval.tsym.type = type;
1412       return TYPENAME;
1413     }
1414
1415   /* TODO: What about other types?  */
1416
1417   sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this);
1418
1419   if (sym.symbol)
1420     {
1421       yylval.ssym.sym = sym;
1422       yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
1423       return NAME;
1424     }
1425
1426   /* If we didn't find a symbol, look again in the current package.
1427      This is to, e.g., make "p global_var" work without having to specify
1428      the package name.  We intentionally only looks for objects in the
1429      current package.  */
1430
1431   {
1432     char *current_package_name = go_block_package_name (block);
1433
1434     if (current_package_name != NULL)
1435       {
1436         struct stoken sval =
1437           build_packaged_name (current_package_name,
1438                                strlen (current_package_name),
1439                                copy, strlen (copy));
1440
1441         xfree (current_package_name);
1442         sym = lookup_symbol (sval.ptr, block, VAR_DOMAIN,
1443                              &is_a_field_of_this);
1444         if (sym.symbol)
1445           {
1446             yylval.ssym.stoken = sval;
1447             yylval.ssym.sym = sym;
1448             yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
1449             return NAME;
1450           }
1451       }
1452   }
1453
1454   /* Input names that aren't symbols but ARE valid hex numbers, when
1455      the input radix permits them, can be names or numbers depending
1456      on the parse.  Note we support radixes > 16 here.  */
1457   if ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
1458       || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10))
1459     {
1460       YYSTYPE newlval;  /* Its value is ignored.  */
1461       int hextype = parse_number (par_state, copy, yylval.sval.length,
1462                                   0, &newlval);
1463       if (hextype == INT)
1464         {
1465           yylval.ssym.sym.symbol = NULL;
1466           yylval.ssym.sym.block = NULL;
1467           yylval.ssym.is_a_field_of_this = 0;
1468           return NAME_OR_INT;
1469         }
1470     }
1471
1472   yylval.ssym.sym.symbol = NULL;
1473   yylval.ssym.sym.block = NULL;
1474   yylval.ssym.is_a_field_of_this = 0;
1475   return NAME;
1476 }
1477
1478 /* This is taken from c-exp.y mostly to get something working.
1479    The basic structure has been kept because we may yet need some of it.  */
1480
1481 static int
1482 yylex (void)
1483 {
1484   token_and_value current, next;
1485
1486   if (popping && !token_fifo.empty ())
1487     {
1488       token_and_value tv = token_fifo[0];
1489       token_fifo.erase (token_fifo.begin ());
1490       yylval = tv.value;
1491       /* There's no need to fall through to handle package.name
1492          as that can never happen here.  In theory.  */
1493       return tv.token;
1494     }
1495   popping = 0;
1496
1497   current.token = lex_one_token (pstate);
1498
1499   /* TODO: Need a way to force specifying name1 as a package.
1500      .name1.name2 ?  */
1501
1502   if (current.token != NAME)
1503     return current.token;
1504
1505   /* See if we have "name1 . name2".  */
1506
1507   current.value = yylval;
1508   next.token = lex_one_token (pstate);
1509   next.value = yylval;
1510
1511   if (next.token == '.')
1512     {
1513       token_and_value name2;
1514
1515       name2.token = lex_one_token (pstate);
1516       name2.value = yylval;
1517
1518       if (name2.token == NAME)
1519         {
1520           /* Ok, we have "name1 . name2".  */
1521           char *copy;
1522
1523           copy = copy_name (current.value.sval);
1524
1525           if (strcmp (copy, "unsafe") == 0)
1526             {
1527               popping = 1;
1528               return classify_unsafe_function (name2.value.sval);
1529             }
1530
1531           if (package_name_p (copy, expression_context_block))
1532             {
1533               popping = 1;
1534               yylval.sval = build_packaged_name (current.value.sval.ptr,
1535                                                  current.value.sval.length,
1536                                                  name2.value.sval.ptr,
1537                                                  name2.value.sval.length);
1538               return classify_packaged_name (expression_context_block);
1539             }
1540         }
1541
1542       token_fifo.push_back (next);
1543       token_fifo.push_back (name2);
1544     }
1545   else
1546     token_fifo.push_back (next);
1547
1548   /* If we arrive here we don't have a package-qualified name.  */
1549
1550   popping = 1;
1551   yylval = current.value;
1552   return classify_name (pstate, expression_context_block);
1553 }
1554
1555 int
1556 go_parse (struct parser_state *par_state)
1557 {
1558   /* Setting up the parser state.  */
1559   scoped_restore pstate_restore = make_scoped_restore (&pstate);
1560   gdb_assert (par_state != NULL);
1561   pstate = par_state;
1562
1563   scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
1564                                                         parser_debug);
1565
1566   /* Initialize some state used by the lexer.  */
1567   last_was_structop = 0;
1568   saw_name_at_eof = 0;
1569
1570   token_fifo.clear ();
1571   popping = 0;
1572   name_obstack.clear ();
1573
1574   return yyparse ();
1575 }
1576
1577 static void
1578 yyerror (const char *msg)
1579 {
1580   if (prev_lexptr)
1581     lexptr = prev_lexptr;
1582
1583   error (_("A %s in expression, near `%s'."), msg, lexptr);
1584 }