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 (ps->gdbarch ())
  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                         { pstate->mark_struct_expression ();
 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                           pstate->mark_struct_expression ();
 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                         { pstate->start_arglist (); }
 273                 arglist ')'     %prec LEFT_ARROW
 274                         { write_exp_elt_opcode (pstate, OP_FUNCALL);
 275                           write_exp_elt_longcst (pstate,
 276                                                  pstate->end_arglist ());
 277                           write_exp_elt_opcode (pstate, OP_FUNCALL); }
 278         ;
 279
 280 lcurly  :       '{'
 281                         { pstate->start_arglist (); }
 282         ;
 283
 284 arglist :
 285         ;
 286
 287 arglist :       exp
 288                         { pstate->arglist_len = 1; }
 289         ;
 290
 291 arglist :       arglist ',' exp   %prec ABOVE_COMMA
 292                         { pstate->arglist_len++; }
 293         ;
 294
 295 rcurly  :       '}'
 296                         { $$ = pstate->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).c_str ());
 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                                 pstate->block_tracker->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                               std::string arg = copy_name ($1.stoken);
 572
 573                               msymbol =
 574                                 lookup_bound_minimal_symbol (arg.c_str ());
 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                                        arg.c_str ());
 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 (pstate->gdbarch ())
 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 (par_state->gdbarch ());
 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 (par_state->gdbarch ()) - 2)) == 0)
 807     {
 808       high_bit
 809         = ((ULONGEST)1) << (gdbarch_int_bit (par_state->gdbarch ()) - 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 (par_state->gdbarch ()) - 2)) == 0)
 822     {
 823       high_bit
 824         = ((ULONGEST)1) << (gdbarch_long_bit (par_state->gdbarch ()) - 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 (par_state->gdbarch ()))
 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 (par_state->gdbarch ()) - 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 /* Depth of parentheses.  */
1005 static int paren_depth;
1006
1007 /* Read one token, getting characters through lexptr.  */
1008
1009 static int
1010 lex_one_token (struct parser_state *par_state)
1011 {
1012   int c;
1013   int namelen;
1014   unsigned int i;
1015   const char *tokstart;
1016   int saw_structop = last_was_structop;
1017
1018   last_was_structop = 0;
1019
1020  retry:
1021
1022   par_state->prev_lexptr = par_state->lexptr;
1023
1024   tokstart = par_state->lexptr;
1025   /* See if it is a special token of length 3.  */
1026   for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
1027     if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
1028       {
1029         par_state->lexptr += 3;
1030         yylval.opcode = tokentab3[i].opcode;
1031         return tokentab3[i].token;
1032       }
1033
1034   /* See if it is a special token of length 2.  */
1035   for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
1036     if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
1037       {
1038         par_state->lexptr += 2;
1039         yylval.opcode = tokentab2[i].opcode;
1040         /* NOTE: -> doesn't exist in Go, so we don't need to watch for
1041            setting last_was_structop here.  */
1042         return tokentab2[i].token;
1043       }
1044
1045   switch (c = *tokstart)
1046     {
1047     case 0:
1048       if (saw_name_at_eof)
1049         {
1050           saw_name_at_eof = 0;
1051           return COMPLETE;
1052         }
1053       else if (saw_structop)
1054         return COMPLETE;
1055       else
1056         return 0;
1057
1058     case ' ':
1059     case '\t':
1060     case '\n':
1061       par_state->lexptr++;
1062       goto retry;
1063
1064     case '[':
1065     case '(':
1066       paren_depth++;
1067       par_state->lexptr++;
1068       return c;
1069
1070     case ']':
1071     case ')':
1072       if (paren_depth == 0)
1073         return 0;
1074       paren_depth--;
1075       par_state->lexptr++;
1076       return c;
1077
1078     case ',':
1079       if (pstate->comma_terminates
1080           && paren_depth == 0)
1081         return 0;
1082       par_state->lexptr++;
1083       return c;
1084
1085     case '.':
1086       /* Might be a floating point number.  */
1087       if (par_state->lexptr[1] < '0' || par_state->lexptr[1] > '9')
1088         {
1089           if (pstate->parse_completion)
1090             last_was_structop = 1;
1091           goto symbol;          /* Nope, must be a symbol. */
1092         }
1093       /* FALL THRU.  */
1094
1095     case '0':
1096     case '1':
1097     case '2':
1098     case '3':
1099     case '4':
1100     case '5':
1101     case '6':
1102     case '7':
1103     case '8':
1104     case '9':
1105       {
1106         /* It's a number.  */
1107         int got_dot = 0, got_e = 0, toktype;
1108         const char *p = tokstart;
1109         int hex = input_radix > 10;
1110
1111         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1112           {
1113             p += 2;
1114             hex = 1;
1115           }
1116
1117         for (;; ++p)
1118           {
1119             /* This test includes !hex because 'e' is a valid hex digit
1120                and thus does not indicate a floating point number when
1121                the radix is hex.  */
1122             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1123               got_dot = got_e = 1;
1124             /* This test does not include !hex, because a '.' always indicates
1125                a decimal floating point number regardless of the radix.  */
1126             else if (!got_dot && *p == '.')
1127               got_dot = 1;
1128             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1129                      && (*p == '-' || *p == '+'))
1130               /* This is the sign of the exponent, not the end of the
1131                  number.  */
1132               continue;
1133             /* We will take any letters or digits.  parse_number will
1134                complain if past the radix, or if L or U are not final.  */
1135             else if ((*p < '0' || *p > '9')
1136                      && ((*p < 'a' || *p > 'z')
1137                                   && (*p < 'A' || *p > 'Z')))
1138               break;
1139           }
1140         toktype = parse_number (par_state, tokstart, p - tokstart,
1141                                 got_dot|got_e, &yylval);
1142         if (toktype == ERROR)
1143           {
1144             char *err_copy = (char *) alloca (p - tokstart + 1);
1145
1146             memcpy (err_copy, tokstart, p - tokstart);
1147             err_copy[p - tokstart] = 0;
1148             error (_("Invalid number \"%s\"."), err_copy);
1149           }
1150         par_state->lexptr = p;
1151         return toktype;
1152       }
1153
1154     case '@':
1155       {
1156         const char *p = &tokstart[1];
1157         size_t len = strlen ("entry");
1158
1159         while (isspace (*p))
1160           p++;
1161         if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1162             && p[len] != '_')
1163           {
1164             par_state->lexptr = &p[len];
1165             return ENTRY;
1166           }
1167       }
1168       /* FALLTHRU */
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     case '{':
1185     case '}':
1186     symbol:
1187       par_state->lexptr++;
1188       return c;
1189
1190     case '\'':
1191     case '"':
1192     case '`':
1193       {
1194         int host_len;
1195         int result = parse_string_or_char (tokstart, &par_state->lexptr,
1196                                            &yylval.tsval, &host_len);
1197         if (result == CHAR)
1198           {
1199             if (host_len == 0)
1200               error (_("Empty character constant."));
1201             else if (host_len > 2 && c == '\'')
1202               {
1203                 ++tokstart;
1204                 namelen = par_state->lexptr - tokstart - 1;
1205                 goto tryname;
1206               }
1207             else if (host_len > 1)
1208               error (_("Invalid character constant."));
1209           }
1210         return result;
1211       }
1212     }
1213
1214   if (!(c == '_' || c == '$'
1215         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1216     /* We must have come across a bad character (e.g. ';').  */
1217     error (_("Invalid character '%c' in expression."), c);
1218
1219   /* It's a name.  See how long it is.  */
1220   namelen = 0;
1221   for (c = tokstart[namelen];
1222        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1223         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1224     {
1225       c = tokstart[++namelen];
1226     }
1227
1228   /* The token "if" terminates the expression and is NOT removed from
1229      the input stream.  It doesn't count if it appears in the
1230      expansion of a macro.  */
1231   if (namelen == 2
1232       && tokstart[0] == 'i'
1233       && tokstart[1] == 'f')
1234     {
1235       return 0;
1236     }
1237
1238   /* For the same reason (breakpoint conditions), "thread N"
1239      terminates the expression.  "thread" could be an identifier, but
1240      an identifier is never followed by a number without intervening
1241      punctuation.
1242      Handle abbreviations of these, similarly to
1243      breakpoint.c:find_condition_and_thread.
1244      TODO: Watch for "goroutine" here?  */
1245   if (namelen >= 1
1246       && strncmp (tokstart, "thread", namelen) == 0
1247       && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1248     {
1249       const char *p = tokstart + namelen + 1;
1250
1251       while (*p == ' ' || *p == '\t')
1252         p++;
1253       if (*p >= '0' && *p <= '9')
1254         return 0;
1255     }
1256
1257   par_state->lexptr += namelen;
1258
1259   tryname:
1260
1261   yylval.sval.ptr = tokstart;
1262   yylval.sval.length = namelen;
1263
1264   /* Catch specific keywords.  */
1265   std::string copy = copy_name (yylval.sval);
1266   for (i = 0; i < sizeof (ident_tokens) / sizeof (ident_tokens[0]); i++)
1267     if (copy == ident_tokens[i].oper)
1268       {
1269         /* It is ok to always set this, even though we don't always
1270            strictly need to.  */
1271         yylval.opcode = ident_tokens[i].opcode;
1272         return ident_tokens[i].token;
1273       }
1274
1275   if (*tokstart == '$')
1276     return DOLLAR_VARIABLE;
1277
1278   if (pstate->parse_completion && *par_state->lexptr == '\0')
1279     saw_name_at_eof = 1;
1280   return NAME;
1281 }
1282
1283 /* An object of this type is pushed on a FIFO by the "outer" lexer.  */
1284 struct token_and_value
1285 {
1286   int token;
1287   YYSTYPE value;
1288 };
1289
1290 /* A FIFO of tokens that have been read but not yet returned to the
1291    parser.  */
1292 static std::vector<token_and_value> token_fifo;
1293
1294 /* Non-zero if the lexer should return tokens from the FIFO.  */
1295 static int popping;
1296
1297 /* Temporary storage for yylex; this holds symbol names as they are
1298    built up.  */
1299 static auto_obstack name_obstack;
1300
1301 /* Build "package.name" in name_obstack.
1302    For convenience of the caller, the name is NUL-terminated,
1303    but the NUL is not included in the recorded length.  */
1304
1305 static struct stoken
1306 build_packaged_name (const char *package, int package_len,
1307                      const char *name, int name_len)
1308 {
1309   struct stoken result;
1310
1311   name_obstack.clear ();
1312   obstack_grow (&name_obstack, package, package_len);
1313   obstack_grow_str (&name_obstack, ".");
1314   obstack_grow (&name_obstack, name, name_len);
1315   obstack_grow (&name_obstack, "", 1);
1316   result.ptr = (char *) obstack_base (&name_obstack);
1317   result.length = obstack_object_size (&name_obstack) - 1;
1318
1319   return result;
1320 }
1321
1322 /* Return non-zero if NAME is a package name.
1323    BLOCK is the scope in which to interpret NAME; this can be NULL
1324    to mean the global scope.  */
1325
1326 static int
1327 package_name_p (const char *name, const struct block *block)
1328 {
1329   struct symbol *sym;
1330   struct field_of_this_result is_a_field_of_this;
1331
1332   sym = lookup_symbol (name, block, STRUCT_DOMAIN, &is_a_field_of_this).symbol;
1333
1334   if (sym
1335       && SYMBOL_CLASS (sym) == LOC_TYPEDEF
1336       && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_MODULE)
1337     return 1;
1338
1339   return 0;
1340 }
1341
1342 /* Classify a (potential) function in the "unsafe" package.
1343    We fold these into "keywords" to keep things simple, at least until
1344    something more complex is warranted.  */
1345
1346 static int
1347 classify_unsafe_function (struct stoken function_name)
1348 {
1349   std::string copy = copy_name (function_name);
1350
1351   if (copy == "Sizeof")
1352     {
1353       yylval.sval = function_name;
1354       return SIZEOF_KEYWORD;
1355     }
1356
1357   error (_("Unknown function in `unsafe' package: %s"), copy.c_str ());
1358 }
1359
1360 /* Classify token(s) "name1.name2" where name1 is known to be a package.
1361    The contents of the token are in `yylval'.
1362    Updates yylval and returns the new token type.
1363
1364    The result is one of NAME, NAME_OR_INT, or TYPENAME.  */
1365
1366 static int
1367 classify_packaged_name (const struct block *block)
1368 {
1369   struct block_symbol sym;
1370   struct field_of_this_result is_a_field_of_this;
1371
1372   std::string copy = copy_name (yylval.sval);
1373
1374   sym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN, &is_a_field_of_this);
1375
1376   if (sym.symbol)
1377     {
1378       yylval.ssym.sym = sym;
1379       yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
1380     }
1381
1382   return NAME;
1383 }
1384
1385 /* Classify a NAME token.
1386    The contents of the token are in `yylval'.
1387    Updates yylval and returns the new token type.
1388    BLOCK is the block in which lookups start; this can be NULL
1389    to mean the global scope.
1390
1391    The result is one of NAME, NAME_OR_INT, or TYPENAME.  */
1392
1393 static int
1394 classify_name (struct parser_state *par_state, const struct block *block)
1395 {
1396   struct type *type;
1397   struct block_symbol sym;
1398   struct field_of_this_result is_a_field_of_this;
1399
1400   std::string 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 (par_state->language (),
1404                                          par_state->gdbarch (),
1405                                          copy.c_str ());
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.c_str (), 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.c_str (), copy.size ());
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.c_str (),
1462                                   yylval.sval.length, 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           std::string copy = copy_name (current.value.sval);
1522
1523           if (copy == "unsafe")
1524             {
1525               popping = 1;
1526               return classify_unsafe_function (name2.value.sval);
1527             }
1528
1529           if (package_name_p (copy.c_str (), pstate->expression_context_block))
1530             {
1531               popping = 1;
1532               yylval.sval = build_packaged_name (current.value.sval.ptr,
1533                                                  current.value.sval.length,
1534                                                  name2.value.sval.ptr,
1535                                                  name2.value.sval.length);
1536               return classify_packaged_name (pstate->expression_context_block);
1537             }
1538         }
1539
1540       token_fifo.push_back (next);
1541       token_fifo.push_back (name2);
1542     }
1543   else
1544     token_fifo.push_back (next);
1545
1546   /* If we arrive here we don't have a package-qualified name.  */
1547
1548   popping = 1;
1549   yylval = current.value;
1550   return classify_name (pstate, pstate->expression_context_block);
1551 }
1552
1553 int
1554 go_parse (struct parser_state *par_state)
1555 {
1556   /* Setting up the parser state.  */
1557   scoped_restore pstate_restore = make_scoped_restore (&pstate);
1558   gdb_assert (par_state != NULL);
1559   pstate = par_state;
1560
1561   scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
1562                                                         parser_debug);
1563
1564   /* Initialize some state used by the lexer.  */
1565   last_was_structop = 0;
1566   saw_name_at_eof = 0;
1567   paren_depth = 0;
1568
1569   token_fifo.clear ();
1570   popping = 0;
1571   name_obstack.clear ();
1572
1573   return yyparse ();
1574 }
1575
1576 static void
1577 yyerror (const char *msg)
1578 {
1579   if (pstate->prev_lexptr)
1580     pstate->lexptr = pstate->prev_lexptr;
1581
1582   error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);
1583 }