gdb/go-exp.y

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