gdb/d-exp.y

   1 /* YACC parser for D expressions, for GDB.
   2
   3    Copyright (C) 2014-2021 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, jv-exp.y.  */
  21
  22 /* Parse a D expression from text in a string,
  23    and return the result as a struct expression pointer.
  24    That structure contains arithmetic operations in reverse polish,
  25    with constants represented by operations that are followed by special data.
  26    See expression.h for the details of the format.
  27    What is important here is that it can be built up sequentially
  28    during the process of parsing; the lower levels of the tree always
  29    come first in the result.
  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 %{
  40
  41 #include "defs.h"
  42 #include <ctype.h>
  43 #include "expression.h"
  44 #include "value.h"
  45 #include "parser-defs.h"
  46 #include "language.h"
  47 #include "c-lang.h"
  48 #include "d-lang.h"
  49 #include "bfd.h" /* Required by objfiles.h.  */
  50 #include "symfile.h" /* Required by objfiles.h.  */
  51 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
  52 #include "charset.h"
  53 #include "block.h"
  54 #include "type-stack.h"
  55 #include "expop.h"
  56
  57 #define parse_type(ps) builtin_type (ps->gdbarch ())
  58 #define parse_d_type(ps) builtin_d_type (ps->gdbarch ())
  59
  60 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
  61    etc).  */
  62 #define GDB_YY_REMAP_PREFIX d_
  63 #include "yy-remap.h"
  64
  65 /* The state of the parser, used internally when we are parsing the
  66    expression.  */
  67
  68 static struct parser_state *pstate = NULL;
  69
  70 /* The current type stack.  */
  71 static struct type_stack *type_stack;
  72
  73 int yyparse (void);
  74
  75 static int yylex (void);
  76
  77 static void yyerror (const char *);
  78
  79 static int type_aggregate_p (struct type *);
  80
  81 using namespace expr;
  82
  83 %}
  84
  85 /* Although the yacc "value" of an expression is not used,
  86    since the result is stored in the structure being created,
  87    other node types do have values.  */
  88
  89 %union
  90   {
  91     struct {
  92       LONGEST val;
  93       struct type *type;
  94     } typed_val_int;
  95     struct {
  96       gdb_byte val[16];
  97       struct type *type;
  98     } typed_val_float;
  99     struct symbol *sym;
 100     struct type *tval;
 101     struct typed_stoken tsval;
 102     struct stoken sval;
 103     struct ttype tsym;
 104     struct symtoken ssym;
 105     int ival;
 106     int voidval;
 107     enum exp_opcode opcode;
 108     struct stoken_vector svec;
 109   }
 110
 111 %{
 112 /* YYSTYPE gets defined by %union */
 113 static int parse_number (struct parser_state *, const char *,
 114                          int, int, YYSTYPE *);
 115 %}
 116
 117 %token <sval> IDENTIFIER UNKNOWN_NAME
 118 %token <tsym> TYPENAME
 119 %token <voidval> COMPLETE
 120
 121 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
 122    but which would parse as a valid number in the current input radix.
 123    E.g. "c" when input_radix==16.  Depending on the parse, it will be
 124    turned into a name or into a number.  */
 125
 126 %token <sval> NAME_OR_INT
 127
 128 %token <typed_val_int> INTEGER_LITERAL
 129 %token <typed_val_float> FLOAT_LITERAL
 130 %token <tsval> CHARACTER_LITERAL
 131 %token <tsval> STRING_LITERAL
 132
 133 %type <svec> StringExp
 134 %type <tval> BasicType TypeExp
 135 %type <sval> IdentifierExp
 136 %type <ival> ArrayLiteral
 137
 138 %token ENTRY
 139 %token ERROR
 140
 141 /* Keywords that have a constant value.  */
 142 %token TRUE_KEYWORD FALSE_KEYWORD NULL_KEYWORD
 143 /* Class 'super' accessor.  */
 144 %token SUPER_KEYWORD
 145 /* Properties.  */
 146 %token CAST_KEYWORD SIZEOF_KEYWORD
 147 %token TYPEOF_KEYWORD TYPEID_KEYWORD
 148 %token INIT_KEYWORD
 149 /* Comparison keywords.  */
 150 /* Type storage classes.  */
 151 %token IMMUTABLE_KEYWORD CONST_KEYWORD SHARED_KEYWORD
 152 /* Non-scalar type keywords.  */
 153 %token STRUCT_KEYWORD UNION_KEYWORD
 154 %token CLASS_KEYWORD INTERFACE_KEYWORD
 155 %token ENUM_KEYWORD TEMPLATE_KEYWORD
 156 %token DELEGATE_KEYWORD FUNCTION_KEYWORD
 157
 158 %token <sval> DOLLAR_VARIABLE
 159
 160 %token <opcode> ASSIGN_MODIFY
 161
 162 %left ','
 163 %right '=' ASSIGN_MODIFY
 164 %right '?'
 165 %left OROR
 166 %left ANDAND
 167 %left '|'
 168 %left '^'
 169 %left '&'
 170 %left EQUAL NOTEQUAL '<' '>' LEQ GEQ
 171 %right LSH RSH
 172 %left '+' '-'
 173 %left '*' '/' '%'
 174 %right HATHAT
 175 %left IDENTITY NOTIDENTITY
 176 %right INCREMENT DECREMENT
 177 %right '.' '[' '('
 178 %token DOTDOT
 179
 180 \f
 181 %%
 182
 183 start   :
 184         Expression
 185 |       TypeExp
 186 ;
 187
 188 /* Expressions, including the comma operator.  */
 189
 190 Expression:
 191         CommaExpression
 192 ;
 193
 194 CommaExpression:
 195         AssignExpression
 196 |       AssignExpression ',' CommaExpression
 197                 { pstate->wrap2<comma_operation> (); }
 198 ;
 199
 200 AssignExpression:
 201         ConditionalExpression
 202 |       ConditionalExpression '=' AssignExpression
 203                 { pstate->wrap2<assign_operation> (); }
 204 |       ConditionalExpression ASSIGN_MODIFY AssignExpression
 205                 {
 206                   operation_up rhs = pstate->pop ();
 207                   operation_up lhs = pstate->pop ();
 208                   pstate->push_new<assign_modify_operation>
 209                     ($2, std::move (lhs), std::move (rhs));
 210                 }
 211 ;
 212
 213 ConditionalExpression:
 214         OrOrExpression
 215 |       OrOrExpression '?' Expression ':' ConditionalExpression
 216                 {
 217                   operation_up last = pstate->pop ();
 218                   operation_up mid = pstate->pop ();
 219                   operation_up first = pstate->pop ();
 220                   pstate->push_new<ternop_cond_operation>
 221                     (std::move (first), std::move (mid),
 222                      std::move (last));
 223                 }
 224 ;
 225
 226 OrOrExpression:
 227         AndAndExpression
 228 |       OrOrExpression OROR AndAndExpression
 229                 { pstate->wrap2<logical_or_operation> (); }
 230 ;
 231
 232 AndAndExpression:
 233         OrExpression
 234 |       AndAndExpression ANDAND OrExpression
 235                 { pstate->wrap2<logical_and_operation> (); }
 236 ;
 237
 238 OrExpression:
 239         XorExpression
 240 |       OrExpression '|' XorExpression
 241                 { pstate->wrap2<bitwise_ior_operation> (); }
 242 ;
 243
 244 XorExpression:
 245         AndExpression
 246 |       XorExpression '^' AndExpression
 247                 { pstate->wrap2<bitwise_xor_operation> (); }
 248 ;
 249
 250 AndExpression:
 251         CmpExpression
 252 |       AndExpression '&' CmpExpression
 253                 { pstate->wrap2<bitwise_and_operation> (); }
 254 ;
 255
 256 CmpExpression:
 257         ShiftExpression
 258 |       EqualExpression
 259 |       IdentityExpression
 260 |       RelExpression
 261 ;
 262
 263 EqualExpression:
 264         ShiftExpression EQUAL ShiftExpression
 265                 { pstate->wrap2<equal_operation> (); }
 266 |       ShiftExpression NOTEQUAL ShiftExpression
 267                 { pstate->wrap2<notequal_operation> (); }
 268 ;
 269
 270 IdentityExpression:
 271         ShiftExpression IDENTITY ShiftExpression
 272                 { pstate->wrap2<equal_operation> (); }
 273 |       ShiftExpression NOTIDENTITY ShiftExpression
 274                 { pstate->wrap2<notequal_operation> (); }
 275 ;
 276
 277 RelExpression:
 278         ShiftExpression '<' ShiftExpression
 279                 { pstate->wrap2<less_operation> (); }
 280 |       ShiftExpression LEQ ShiftExpression
 281                 { pstate->wrap2<leq_operation> (); }
 282 |       ShiftExpression '>' ShiftExpression
 283                 { pstate->wrap2<gtr_operation> (); }
 284 |       ShiftExpression GEQ ShiftExpression
 285                 { pstate->wrap2<geq_operation> (); }
 286 ;
 287
 288 ShiftExpression:
 289         AddExpression
 290 |       ShiftExpression LSH AddExpression
 291                 { pstate->wrap2<lsh_operation> (); }
 292 |       ShiftExpression RSH AddExpression
 293                 { pstate->wrap2<rsh_operation> (); }
 294 ;
 295
 296 AddExpression:
 297         MulExpression
 298 |       AddExpression '+' MulExpression
 299                 { pstate->wrap2<add_operation> (); }
 300 |       AddExpression '-' MulExpression
 301                 { pstate->wrap2<sub_operation> (); }
 302 |       AddExpression '~' MulExpression
 303                 { pstate->wrap2<concat_operation> (); }
 304 ;
 305
 306 MulExpression:
 307         UnaryExpression
 308 |       MulExpression '*' UnaryExpression
 309                 { pstate->wrap2<mul_operation> (); }
 310 |       MulExpression '/' UnaryExpression
 311                 { pstate->wrap2<div_operation> (); }
 312 |       MulExpression '%' UnaryExpression
 313                 { pstate->wrap2<rem_operation> (); }
 314
 315 UnaryExpression:
 316         '&' UnaryExpression
 317                 { pstate->wrap<unop_addr_operation> (); }
 318 |       INCREMENT UnaryExpression
 319                 { pstate->wrap<preinc_operation> (); }
 320 |       DECREMENT UnaryExpression
 321                 { pstate->wrap<predec_operation> (); }
 322 |       '*' UnaryExpression
 323                 { pstate->wrap<unop_ind_operation> (); }
 324 |       '-' UnaryExpression
 325                 { pstate->wrap<unary_neg_operation> (); }
 326 |       '+' UnaryExpression
 327                 { pstate->wrap<unary_plus_operation> (); }
 328 |       '!' UnaryExpression
 329                 { pstate->wrap<unary_logical_not_operation> (); }
 330 |       '~' UnaryExpression
 331                 { pstate->wrap<unary_complement_operation> (); }
 332 |       TypeExp '.' SIZEOF_KEYWORD
 333                 { pstate->wrap<unop_sizeof_operation> (); }
 334 |       CastExpression
 335 |       PowExpression
 336 ;
 337
 338 CastExpression:
 339         CAST_KEYWORD '(' TypeExp ')' UnaryExpression
 340                 { pstate->wrap2<unop_cast_type_operation> (); }
 341         /* C style cast is illegal D, but is still recognised in
 342            the grammar, so we keep this around for convenience.  */
 343 |       '(' TypeExp ')' UnaryExpression
 344                 { pstate->wrap2<unop_cast_type_operation> (); }
 345 ;
 346
 347 PowExpression:
 348         PostfixExpression
 349 |       PostfixExpression HATHAT UnaryExpression
 350                 { pstate->wrap2<exp_operation> (); }
 351 ;
 352
 353 PostfixExpression:
 354         PrimaryExpression
 355 |       PostfixExpression '.' COMPLETE
 356                 {
 357                   structop_base_operation *op
 358                     = new structop_ptr_operation (pstate->pop (), "");
 359                   pstate->mark_struct_expression (op);
 360                   pstate->push (operation_up (op));
 361                 }
 362 |       PostfixExpression '.' IDENTIFIER
 363                 {
 364                   pstate->push_new<structop_operation>
 365                     (pstate->pop (), copy_name ($3));
 366                 }
 367 |       PostfixExpression '.' IDENTIFIER COMPLETE
 368                 {
 369                   structop_base_operation *op
 370                     = new structop_operation (pstate->pop (), copy_name ($3));
 371                   pstate->mark_struct_expression (op);
 372                   pstate->push (operation_up (op));
 373                 }
 374 |       PostfixExpression '.' SIZEOF_KEYWORD
 375                 { pstate->wrap<unop_sizeof_operation> (); }
 376 |       PostfixExpression INCREMENT
 377                 { pstate->wrap<postinc_operation> (); }
 378 |       PostfixExpression DECREMENT
 379                 { pstate->wrap<postdec_operation> (); }
 380 |       CallExpression
 381 |       IndexExpression
 382 |       SliceExpression
 383 ;
 384
 385 ArgumentList:
 386         AssignExpression
 387                 { pstate->arglist_len = 1; }
 388 |       ArgumentList ',' AssignExpression
 389                 { pstate->arglist_len++; }
 390 ;
 391
 392 ArgumentList_opt:
 393         /* EMPTY */
 394                 { pstate->arglist_len = 0; }
 395 |       ArgumentList
 396 ;
 397
 398 CallExpression:
 399         PostfixExpression '('
 400                 { pstate->start_arglist (); }
 401         ArgumentList_opt ')'
 402                 {
 403                   std::vector<operation_up> args
 404                     = pstate->pop_vector (pstate->end_arglist ());
 405                   pstate->push_new<funcall_operation>
 406                     (pstate->pop (), std::move (args));
 407                 }
 408 ;
 409
 410 IndexExpression:
 411         PostfixExpression '[' ArgumentList ']'
 412                 { if (pstate->arglist_len > 0)
 413                     {
 414                       std::vector<operation_up> args
 415                         = pstate->pop_vector (pstate->arglist_len);
 416                       pstate->push_new<multi_subscript_operation>
 417                         (pstate->pop (), std::move (args));
 418                     }
 419                   else
 420                     pstate->wrap2<subscript_operation> ();
 421                 }
 422 ;
 423
 424 SliceExpression:
 425         PostfixExpression '[' ']'
 426                 { /* Do nothing.  */ }
 427 |       PostfixExpression '[' AssignExpression DOTDOT AssignExpression ']'
 428                 {
 429                   operation_up last = pstate->pop ();
 430                   operation_up mid = pstate->pop ();
 431                   operation_up first = pstate->pop ();
 432                   pstate->push_new<ternop_slice_operation>
 433                     (std::move (first), std::move (mid),
 434                      std::move (last));
 435                 }
 436 ;
 437
 438 PrimaryExpression:
 439         '(' Expression ')'
 440                 { /* Do nothing.  */ }
 441 |       IdentifierExp
 442                 { struct bound_minimal_symbol msymbol;
 443                   std::string copy = copy_name ($1);
 444                   struct field_of_this_result is_a_field_of_this;
 445                   struct block_symbol sym;
 446
 447                   /* Handle VAR, which could be local or global.  */
 448                   sym = lookup_symbol (copy.c_str (),
 449                                        pstate->expression_context_block,
 450                                        VAR_DOMAIN, &is_a_field_of_this);
 451                   if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF)
 452                     {
 453                       if (symbol_read_needs_frame (sym.symbol))
 454                         pstate->block_tracker->update (sym);
 455                       pstate->push_new<var_value_operation> (sym);
 456                     }
 457                   else if (is_a_field_of_this.type != NULL)
 458                      {
 459                       /* It hangs off of `this'.  Must not inadvertently convert from a
 460                          method call to data ref.  */
 461                       pstate->block_tracker->update (sym);
 462                       operation_up thisop
 463                         = make_operation<op_this_operation> ();
 464                       pstate->push_new<structop_ptr_operation>
 465                         (std::move (thisop), std::move (copy));
 466                     }
 467                   else
 468                     {
 469                       /* Lookup foreign name in global static symbols.  */
 470                       msymbol = lookup_bound_minimal_symbol (copy.c_str ());
 471                       if (msymbol.minsym != NULL)
 472                         pstate->push_new<var_msym_value_operation> (msymbol);
 473                       else if (!have_full_symbols () && !have_partial_symbols ())
 474                         error (_("No symbol table is loaded.  Use the \"file\" command"));
 475                       else
 476                         error (_("No symbol \"%s\" in current context."),
 477                                copy.c_str ());
 478                     }
 479                   }
 480 |       TypeExp '.' IdentifierExp
 481                         { struct type *type = check_typedef ($1);
 482
 483                           /* Check if the qualified name is in the global
 484                              context.  However if the symbol has not already
 485                              been resolved, it's not likely to be found.  */
 486                           if (type->code () == TYPE_CODE_MODULE)
 487                             {
 488                               struct block_symbol sym;
 489                               const char *type_name = TYPE_SAFE_NAME (type);
 490                               int type_name_len = strlen (type_name);
 491                               std::string name
 492                                 = string_printf ("%.*s.%.*s",
 493                                                  type_name_len, type_name,
 494                                                  $3.length, $3.ptr);
 495
 496                               sym =
 497                                 lookup_symbol (name.c_str (),
 498                                                (const struct block *) NULL,
 499                                                VAR_DOMAIN, NULL);
 500                               pstate->push_symbol (name.c_str (), sym);
 501                             }
 502                           else
 503                             {
 504                               /* Check if the qualified name resolves as a member
 505                                  of an aggregate or an enum type.  */
 506                               if (!type_aggregate_p (type))
 507                                 error (_("`%s' is not defined as an aggregate type."),
 508                                        TYPE_SAFE_NAME (type));
 509
 510                               pstate->push_new<scope_operation>
 511                                 (type, copy_name ($3));
 512                             }
 513                         }
 514 |       DOLLAR_VARIABLE
 515                 { pstate->push_dollar ($1); }
 516 |       NAME_OR_INT
 517                 { YYSTYPE val;
 518                   parse_number (pstate, $1.ptr, $1.length, 0, &val);
 519                   pstate->push_new<long_const_operation>
 520                     (val.typed_val_int.type, val.typed_val_int.val); }
 521 |       NULL_KEYWORD
 522                 { struct type *type = parse_d_type (pstate)->builtin_void;
 523                   type = lookup_pointer_type (type);
 524                   pstate->push_new<long_const_operation> (type, 0); }
 525 |       TRUE_KEYWORD
 526                 { pstate->push_new<bool_operation> (true); }
 527 |       FALSE_KEYWORD
 528                 { pstate->push_new<bool_operation> (false); }
 529 |       INTEGER_LITERAL
 530                 { pstate->push_new<long_const_operation> ($1.type, $1.val); }
 531 |       FLOAT_LITERAL
 532                 {
 533                   float_data data;
 534                   std::copy (std::begin ($1.val), std::end ($1.val),
 535                              std::begin (data));
 536                   pstate->push_new<float_const_operation> ($1.type, data);
 537                 }
 538 |       CHARACTER_LITERAL
 539                 { struct stoken_vector vec;
 540                   vec.len = 1;
 541                   vec.tokens = &$1;
 542                   pstate->push_c_string (0, &vec); }
 543 |       StringExp
 544                 { int i;
 545                   pstate->push_c_string (0, &$1);
 546                   for (i = 0; i < $1.len; ++i)
 547                     free ($1.tokens[i].ptr);
 548                   free ($1.tokens); }
 549 |       ArrayLiteral
 550                 {
 551                   std::vector<operation_up> args
 552                     = pstate->pop_vector ($1);
 553                   pstate->push_new<array_operation>
 554                     (0, $1 - 1, std::move (args));
 555                 }
 556 |       TYPEOF_KEYWORD '(' Expression ')'
 557                 { pstate->wrap<typeof_operation> (); }
 558 ;
 559
 560 ArrayLiteral:
 561         '[' ArgumentList_opt ']'
 562                 { $$ = pstate->arglist_len; }
 563 ;
 564
 565 IdentifierExp:
 566         IDENTIFIER
 567 ;
 568
 569 StringExp:
 570         STRING_LITERAL
 571                 { /* We copy the string here, and not in the
 572                      lexer, to guarantee that we do not leak a
 573                      string.  Note that we follow the
 574                      NUL-termination convention of the
 575                      lexer.  */
 576                   struct typed_stoken *vec = XNEW (struct typed_stoken);
 577                   $$.len = 1;
 578                   $$.tokens = vec;
 579
 580                   vec->type = $1.type;
 581                   vec->length = $1.length;
 582                   vec->ptr = (char *) malloc ($1.length + 1);
 583                   memcpy (vec->ptr, $1.ptr, $1.length + 1);
 584                 }
 585 |       StringExp STRING_LITERAL
 586                 { /* Note that we NUL-terminate here, but just
 587                      for convenience.  */
 588                   char *p;
 589                   ++$$.len;
 590                   $$.tokens
 591                     = XRESIZEVEC (struct typed_stoken, $$.tokens, $$.len);
 592
 593                   p = (char *) malloc ($2.length + 1);
 594                   memcpy (p, $2.ptr, $2.length + 1);
 595
 596                   $$.tokens[$$.len - 1].type = $2.type;
 597                   $$.tokens[$$.len - 1].length = $2.length;
 598                   $$.tokens[$$.len - 1].ptr = p;
 599                 }
 600 ;
 601
 602 TypeExp:
 603         '(' TypeExp ')'
 604                 { /* Do nothing.  */ }
 605 |       BasicType
 606                 { pstate->push_new<type_operation> ($1); }
 607 |       BasicType BasicType2
 608                 { $$ = type_stack->follow_types ($1);
 609                   pstate->push_new<type_operation> ($$);
 610                 }
 611 ;
 612
 613 BasicType2:
 614         '*'
 615                 { type_stack->push (tp_pointer); }
 616 |       '*' BasicType2
 617                 { type_stack->push (tp_pointer); }
 618 |       '[' INTEGER_LITERAL ']'
 619                 { type_stack->push ($2.val);
 620                   type_stack->push (tp_array); }
 621 |       '[' INTEGER_LITERAL ']' BasicType2
 622                 { type_stack->push ($2.val);
 623                   type_stack->push (tp_array); }
 624 ;
 625
 626 BasicType:
 627         TYPENAME
 628                 { $$ = $1.type; }
 629 ;
 630
 631 %%
 632
 633 /* Return true if the type is aggregate-like.  */
 634
 635 static int
 636 type_aggregate_p (struct type *type)
 637 {
 638   return (type->code () == TYPE_CODE_STRUCT
 639           || type->code () == TYPE_CODE_UNION
 640           || type->code () == TYPE_CODE_MODULE
 641           || (type->code () == TYPE_CODE_ENUM
 642               && type->is_declared_class ()));
 643 }
 644
 645 /* Take care of parsing a number (anything that starts with a digit).
 646    Set yylval and return the token type; update lexptr.
 647    LEN is the number of characters in it.  */
 648
 649 /*** Needs some error checking for the float case ***/
 650
 651 static int
 652 parse_number (struct parser_state *ps, const char *p,
 653               int len, int parsed_float, YYSTYPE *putithere)
 654 {
 655   ULONGEST n = 0;
 656   ULONGEST prevn = 0;
 657   ULONGEST un;
 658
 659   int i = 0;
 660   int c;
 661   int base = input_radix;
 662   int unsigned_p = 0;
 663   int long_p = 0;
 664
 665   /* We have found a "L" or "U" suffix.  */
 666   int found_suffix = 0;
 667
 668   ULONGEST high_bit;
 669   struct type *signed_type;
 670   struct type *unsigned_type;
 671
 672   if (parsed_float)
 673     {
 674       char *s, *sp;
 675
 676       /* Strip out all embedded '_' before passing to parse_float.  */
 677       s = (char *) alloca (len + 1);
 678       sp = s;
 679       while (len-- > 0)
 680         {
 681           if (*p != '_')
 682             *sp++ = *p;
 683           p++;
 684         }
 685       *sp = '\0';
 686       len = strlen (s);
 687
 688       /* Check suffix for `i' , `fi' or `li' (idouble, ifloat or ireal).  */
 689       if (len >= 1 && tolower (s[len - 1]) == 'i')
 690         {
 691           if (len >= 2 && tolower (s[len - 2]) == 'f')
 692             {
 693               putithere->typed_val_float.type
 694                 = parse_d_type (ps)->builtin_ifloat;
 695               len -= 2;
 696             }
 697           else if (len >= 2 && tolower (s[len - 2]) == 'l')
 698             {
 699               putithere->typed_val_float.type
 700                 = parse_d_type (ps)->builtin_ireal;
 701               len -= 2;
 702             }
 703           else
 704             {
 705               putithere->typed_val_float.type
 706                 = parse_d_type (ps)->builtin_idouble;
 707               len -= 1;
 708             }
 709         }
 710       /* Check suffix for `f' or `l'' (float or real).  */
 711       else if (len >= 1 && tolower (s[len - 1]) == 'f')
 712         {
 713           putithere->typed_val_float.type
 714             = parse_d_type (ps)->builtin_float;
 715           len -= 1;
 716         }
 717       else if (len >= 1 && tolower (s[len - 1]) == 'l')
 718         {
 719           putithere->typed_val_float.type
 720             = parse_d_type (ps)->builtin_real;
 721           len -= 1;
 722         }
 723       /* Default type if no suffix.  */
 724       else
 725         {
 726           putithere->typed_val_float.type
 727             = parse_d_type (ps)->builtin_double;
 728         }
 729
 730       if (!parse_float (s, len,
 731                         putithere->typed_val_float.type,
 732                         putithere->typed_val_float.val))
 733         return ERROR;
 734
 735       return FLOAT_LITERAL;
 736     }
 737
 738   /* Handle base-switching prefixes 0x, 0b, 0 */
 739   if (p[0] == '0')
 740     switch (p[1])
 741       {
 742       case 'x':
 743       case 'X':
 744         if (len >= 3)
 745           {
 746             p += 2;
 747             base = 16;
 748             len -= 2;
 749           }
 750         break;
 751
 752       case 'b':
 753       case 'B':
 754         if (len >= 3)
 755           {
 756             p += 2;
 757             base = 2;
 758             len -= 2;
 759           }
 760         break;
 761
 762       default:
 763         base = 8;
 764         break;
 765       }
 766
 767   while (len-- > 0)
 768     {
 769       c = *p++;
 770       if (c == '_')
 771         continue;       /* Ignore embedded '_'.  */
 772       if (c >= 'A' && c <= 'Z')
 773         c += 'a' - 'A';
 774       if (c != 'l' && c != 'u')
 775         n *= base;
 776       if (c >= '0' && c <= '9')
 777         {
 778           if (found_suffix)
 779             return ERROR;
 780           n += i = c - '0';
 781         }
 782       else
 783         {
 784           if (base > 10 && c >= 'a' && c <= 'f')
 785             {
 786               if (found_suffix)
 787                 return ERROR;
 788               n += i = c - 'a' + 10;
 789             }
 790           else if (c == 'l' && long_p == 0)
 791             {
 792               long_p = 1;
 793               found_suffix = 1;
 794             }
 795           else if (c == 'u' && unsigned_p == 0)
 796             {
 797               unsigned_p = 1;
 798               found_suffix = 1;
 799             }
 800           else
 801             return ERROR;       /* Char not a digit */
 802         }
 803       if (i >= base)
 804         return ERROR;           /* Invalid digit in this base.  */
 805       /* Portably test for integer overflow.  */
 806       if (c != 'l' && c != 'u')
 807         {
 808           ULONGEST n2 = prevn * base;
 809           if ((n2 / base != prevn) || (n2 + i < prevn))
 810             error (_("Numeric constant too large."));
 811         }
 812       prevn = n;
 813     }
 814
 815   /* An integer constant is an int or a long.  An L suffix forces it to
 816      be long, and a U suffix forces it to be unsigned.  To figure out
 817      whether it fits, we shift it right and see whether anything remains.
 818      Note that we can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or
 819      more in one operation, because many compilers will warn about such a
 820      shift (which always produces a zero result).  To deal with the case
 821      where it is we just always shift the value more than once, with fewer
 822      bits each time.  */
 823   un = (ULONGEST) n >> 2;
 824   if (long_p == 0 && (un >> 30) == 0)
 825     {
 826       high_bit = ((ULONGEST) 1) << 31;
 827       signed_type = parse_d_type (ps)->builtin_int;
 828       /* For decimal notation, keep the sign of the worked out type.  */
 829       if (base == 10 && !unsigned_p)
 830         unsigned_type = parse_d_type (ps)->builtin_long;
 831       else
 832         unsigned_type = parse_d_type (ps)->builtin_uint;
 833     }
 834   else
 835     {
 836       int shift;
 837       if (sizeof (ULONGEST) * HOST_CHAR_BIT < 64)
 838         /* A long long does not fit in a LONGEST.  */
 839         shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
 840       else
 841         shift = 63;
 842       high_bit = (ULONGEST) 1 << shift;
 843       signed_type = parse_d_type (ps)->builtin_long;
 844       unsigned_type = parse_d_type (ps)->builtin_ulong;
 845     }
 846
 847   putithere->typed_val_int.val = n;
 848
 849   /* If the high bit of the worked out type is set then this number
 850      has to be unsigned_type.  */
 851   if (unsigned_p || (n & high_bit))
 852     putithere->typed_val_int.type = unsigned_type;
 853   else
 854     putithere->typed_val_int.type = signed_type;
 855
 856   return INTEGER_LITERAL;
 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 == '"' || quote == '`')
 921         error (_("Unterminated string in expression."));
 922       else
 923         error (_("Unmatched single quote."));
 924     }
 925   ++tokptr;
 926
 927   /* FIXME: should instead use own language string_type enum
 928      and handle D-specific string suffixes here. */
 929   if (quote == '\'')
 930     value->type = C_CHAR;
 931   else
 932     value->type = C_STRING;
 933
 934   value->ptr = (char *) obstack_base (&tempbuf);
 935   value->length = obstack_object_size (&tempbuf);
 936
 937   *outptr = tokptr;
 938
 939   return quote == '\'' ? CHARACTER_LITERAL : STRING_LITERAL;
 940 }
 941
 942 struct token
 943 {
 944   const char *oper;
 945   int token;
 946   enum exp_opcode opcode;
 947 };
 948
 949 static const struct token tokentab3[] =
 950   {
 951     {"^^=", ASSIGN_MODIFY, BINOP_EXP},
 952     {"<<=", ASSIGN_MODIFY, BINOP_LSH},
 953     {">>=", ASSIGN_MODIFY, BINOP_RSH},
 954   };
 955
 956 static const struct token tokentab2[] =
 957   {
 958     {"+=", ASSIGN_MODIFY, BINOP_ADD},
 959     {"-=", ASSIGN_MODIFY, BINOP_SUB},
 960     {"*=", ASSIGN_MODIFY, BINOP_MUL},
 961     {"/=", ASSIGN_MODIFY, BINOP_DIV},
 962     {"%=", ASSIGN_MODIFY, BINOP_REM},
 963     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
 964     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
 965     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
 966     {"++", INCREMENT, OP_NULL},
 967     {"--", DECREMENT, OP_NULL},
 968     {"&&", ANDAND, OP_NULL},
 969     {"||", OROR, OP_NULL},
 970     {"^^", HATHAT, OP_NULL},
 971     {"<<", LSH, OP_NULL},
 972     {">>", RSH, OP_NULL},
 973     {"==", EQUAL, OP_NULL},
 974     {"!=", NOTEQUAL, OP_NULL},
 975     {"<=", LEQ, OP_NULL},
 976     {">=", GEQ, OP_NULL},
 977     {"..", DOTDOT, OP_NULL},
 978   };
 979
 980 /* Identifier-like tokens.  */
 981 static const struct token ident_tokens[] =
 982   {
 983     {"is", IDENTITY, OP_NULL},
 984     {"!is", NOTIDENTITY, OP_NULL},
 985
 986     {"cast", CAST_KEYWORD, OP_NULL},
 987     {"const", CONST_KEYWORD, OP_NULL},
 988     {"immutable", IMMUTABLE_KEYWORD, OP_NULL},
 989     {"shared", SHARED_KEYWORD, OP_NULL},
 990     {"super", SUPER_KEYWORD, OP_NULL},
 991
 992     {"null", NULL_KEYWORD, OP_NULL},
 993     {"true", TRUE_KEYWORD, OP_NULL},
 994     {"false", FALSE_KEYWORD, OP_NULL},
 995
 996     {"init", INIT_KEYWORD, OP_NULL},
 997     {"sizeof", SIZEOF_KEYWORD, OP_NULL},
 998     {"typeof", TYPEOF_KEYWORD, OP_NULL},
 999     {"typeid", TYPEID_KEYWORD, OP_NULL},
1000
1001     {"delegate", DELEGATE_KEYWORD, OP_NULL},
1002     {"function", FUNCTION_KEYWORD, OP_NULL},
1003     {"struct", STRUCT_KEYWORD, OP_NULL},
1004     {"union", UNION_KEYWORD, OP_NULL},
1005     {"class", CLASS_KEYWORD, OP_NULL},
1006     {"interface", INTERFACE_KEYWORD, OP_NULL},
1007     {"enum", ENUM_KEYWORD, OP_NULL},
1008     {"template", TEMPLATE_KEYWORD, OP_NULL},
1009   };
1010
1011 /* This is set if a NAME token appeared at the very end of the input
1012    string, with no whitespace separating the name from the EOF.  This
1013    is used only when parsing to do field name completion.  */
1014 static int saw_name_at_eof;
1015
1016 /* This is set if the previously-returned token was a structure operator.
1017    This is used only when parsing to do field name completion.  */
1018 static int last_was_structop;
1019
1020 /* Depth of parentheses.  */
1021 static int paren_depth;
1022
1023 /* Read one token, getting characters through lexptr.  */
1024
1025 static int
1026 lex_one_token (struct parser_state *par_state)
1027 {
1028   int c;
1029   int namelen;
1030   unsigned int i;
1031   const char *tokstart;
1032   int saw_structop = last_was_structop;
1033
1034   last_was_structop = 0;
1035
1036  retry:
1037
1038   pstate->prev_lexptr = pstate->lexptr;
1039
1040   tokstart = pstate->lexptr;
1041   /* See if it is a special token of length 3.  */
1042   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1043     if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
1044       {
1045         pstate->lexptr += 3;
1046         yylval.opcode = tokentab3[i].opcode;
1047         return tokentab3[i].token;
1048       }
1049
1050   /* See if it is a special token of length 2.  */
1051   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1052     if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
1053       {
1054         pstate->lexptr += 2;
1055         yylval.opcode = tokentab2[i].opcode;
1056         return tokentab2[i].token;
1057       }
1058
1059   switch (c = *tokstart)
1060     {
1061     case 0:
1062       /* If we're parsing for field name completion, and the previous
1063          token allows such completion, return a COMPLETE token.
1064          Otherwise, we were already scanning the original text, and
1065          we're really done.  */
1066       if (saw_name_at_eof)
1067         {
1068           saw_name_at_eof = 0;
1069           return COMPLETE;
1070         }
1071       else if (saw_structop)
1072         return COMPLETE;
1073       else
1074         return 0;
1075
1076     case ' ':
1077     case '\t':
1078     case '\n':
1079       pstate->lexptr++;
1080       goto retry;
1081
1082     case '[':
1083     case '(':
1084       paren_depth++;
1085       pstate->lexptr++;
1086       return c;
1087
1088     case ']':
1089     case ')':
1090       if (paren_depth == 0)
1091         return 0;
1092       paren_depth--;
1093       pstate->lexptr++;
1094       return c;
1095
1096     case ',':
1097       if (pstate->comma_terminates && paren_depth == 0)
1098         return 0;
1099       pstate->lexptr++;
1100       return c;
1101
1102     case '.':
1103       /* Might be a floating point number.  */
1104       if (pstate->lexptr[1] < '0' || pstate->lexptr[1] > '9')
1105         {
1106           if (pstate->parse_completion)
1107             last_was_structop = 1;
1108           goto symbol;          /* Nope, must be a symbol.  */
1109         }
1110       /* FALL THRU.  */
1111
1112     case '0':
1113     case '1':
1114     case '2':
1115     case '3':
1116     case '4':
1117     case '5':
1118     case '6':
1119     case '7':
1120     case '8':
1121     case '9':
1122       {
1123         /* It's a number.  */
1124         int got_dot = 0, got_e = 0, toktype;
1125         const char *p = tokstart;
1126         int hex = input_radix > 10;
1127
1128         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1129           {
1130             p += 2;
1131             hex = 1;
1132           }
1133
1134         for (;; ++p)
1135           {
1136             /* Hex exponents start with 'p', because 'e' is a valid hex
1137                digit and thus does not indicate a floating point number
1138                when the radix is hex.  */
1139             if ((!hex && !got_e && tolower (p[0]) == 'e')
1140                 || (hex && !got_e && tolower (p[0] == 'p')))
1141               got_dot = got_e = 1;
1142             /* A '.' always indicates a decimal floating point number
1143                regardless of the radix.  If we have a '..' then its the
1144                end of the number and the beginning of a slice.  */
1145             else if (!got_dot && (p[0] == '.' && p[1] != '.'))
1146                 got_dot = 1;
1147             /* This is the sign of the exponent, not the end of the number.  */
1148             else if (got_e && (tolower (p[-1]) == 'e' || tolower (p[-1]) == 'p')
1149                      && (*p == '-' || *p == '+'))
1150               continue;
1151             /* We will take any letters or digits, ignoring any embedded '_'.
1152                parse_number will complain if past the radix, or if L or U are
1153                not final.  */
1154             else if ((*p < '0' || *p > '9') && (*p != '_')
1155                      && ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z')))
1156               break;
1157           }
1158
1159         toktype = parse_number (par_state, tokstart, p - tokstart,
1160                                 got_dot|got_e, &yylval);
1161         if (toktype == ERROR)
1162           {
1163             char *err_copy = (char *) alloca (p - tokstart + 1);
1164
1165             memcpy (err_copy, tokstart, p - tokstart);
1166             err_copy[p - tokstart] = 0;
1167             error (_("Invalid number \"%s\"."), err_copy);
1168           }
1169         pstate->lexptr = p;
1170         return toktype;
1171       }
1172
1173     case '@':
1174       {
1175         const char *p = &tokstart[1];
1176         size_t len = strlen ("entry");
1177
1178         while (isspace (*p))
1179           p++;
1180         if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
1181             && p[len] != '_')
1182           {
1183             pstate->lexptr = &p[len];
1184             return ENTRY;
1185           }
1186       }
1187       /* FALLTHRU */
1188     case '+':
1189     case '-':
1190     case '*':
1191     case '/':
1192     case '%':
1193     case '|':
1194     case '&':
1195     case '^':
1196     case '~':
1197     case '!':
1198     case '<':
1199     case '>':
1200     case '?':
1201     case ':':
1202     case '=':
1203     case '{':
1204     case '}':
1205     symbol:
1206       pstate->lexptr++;
1207       return c;
1208
1209     case '\'':
1210     case '"':
1211     case '`':
1212       {
1213         int host_len;
1214         int result = parse_string_or_char (tokstart, &pstate->lexptr,
1215                                            &yylval.tsval, &host_len);
1216         if (result == CHARACTER_LITERAL)
1217           {
1218             if (host_len == 0)
1219               error (_("Empty character constant."));
1220             else if (host_len > 2 && c == '\'')
1221               {
1222                 ++tokstart;
1223                 namelen = pstate->lexptr - tokstart - 1;
1224                 goto tryname;
1225               }
1226             else if (host_len > 1)
1227               error (_("Invalid character constant."));
1228           }
1229         return result;
1230       }
1231     }
1232
1233   if (!(c == '_' || c == '$'
1234         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1235     /* We must have come across a bad character (e.g. ';').  */
1236     error (_("Invalid character '%c' in expression"), c);
1237
1238   /* It's a name.  See how long it is.  */
1239   namelen = 0;
1240   for (c = tokstart[namelen];
1241        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1242         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));)
1243     c = tokstart[++namelen];
1244
1245   /* The token "if" terminates the expression and is NOT
1246      removed from the input stream.  */
1247   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1248     return 0;
1249
1250   /* For the same reason (breakpoint conditions), "thread N"
1251      terminates the expression.  "thread" could be an identifier, but
1252      an identifier is never followed by a number without intervening
1253      punctuation.  "task" is similar.  Handle abbreviations of these,
1254      similarly to breakpoint.c:find_condition_and_thread.  */
1255   if (namelen >= 1
1256       && (strncmp (tokstart, "thread", namelen) == 0
1257           || strncmp (tokstart, "task", namelen) == 0)
1258       && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t'))
1259     {
1260       const char *p = tokstart + namelen + 1;
1261
1262       while (*p == ' ' || *p == '\t')
1263         p++;
1264       if (*p >= '0' && *p <= '9')
1265         return 0;
1266     }
1267
1268   pstate->lexptr += namelen;
1269
1270  tryname:
1271
1272   yylval.sval.ptr = tokstart;
1273   yylval.sval.length = namelen;
1274
1275   /* Catch specific keywords.  */
1276   std::string copy = copy_name (yylval.sval);
1277   for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
1278     if (copy == ident_tokens[i].oper)
1279       {
1280         /* It is ok to always set this, even though we don't always
1281            strictly need to.  */
1282         yylval.opcode = ident_tokens[i].opcode;
1283         return ident_tokens[i].token;
1284       }
1285
1286   if (*tokstart == '$')
1287     return DOLLAR_VARIABLE;
1288
1289   yylval.tsym.type
1290     = language_lookup_primitive_type (par_state->language (),
1291                                       par_state->gdbarch (), copy.c_str ());
1292   if (yylval.tsym.type != NULL)
1293     return TYPENAME;
1294
1295   /* Input names that aren't symbols but ARE valid hex numbers,
1296      when the input radix permits them, can be names or numbers
1297      depending on the parse.  Note we support radixes > 16 here.  */
1298   if ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1299       || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))
1300     {
1301       YYSTYPE newlval;  /* Its value is ignored.  */
1302       int hextype = parse_number (par_state, tokstart, namelen, 0, &newlval);
1303       if (hextype == INTEGER_LITERAL)
1304         return NAME_OR_INT;
1305     }
1306
1307   if (pstate->parse_completion && *pstate->lexptr == '\0')
1308     saw_name_at_eof = 1;
1309
1310   return IDENTIFIER;
1311 }
1312
1313 /* An object of this type is pushed on a FIFO by the "outer" lexer.  */
1314 struct token_and_value
1315 {
1316   int token;
1317   YYSTYPE value;
1318 };
1319
1320
1321 /* A FIFO of tokens that have been read but not yet returned to the
1322    parser.  */
1323 static std::vector<token_and_value> token_fifo;
1324
1325 /* Non-zero if the lexer should return tokens from the FIFO.  */
1326 static int popping;
1327
1328 /* Temporary storage for yylex; this holds symbol names as they are
1329    built up.  */
1330 static auto_obstack name_obstack;
1331
1332 /* Classify an IDENTIFIER token.  The contents of the token are in `yylval'.
1333    Updates yylval and returns the new token type.  BLOCK is the block
1334    in which lookups start; this can be NULL to mean the global scope.  */
1335
1336 static int
1337 classify_name (struct parser_state *par_state, const struct block *block)
1338 {
1339   struct block_symbol sym;
1340   struct field_of_this_result is_a_field_of_this;
1341
1342   std::string copy = copy_name (yylval.sval);
1343
1344   sym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN, &is_a_field_of_this);
1345   if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)
1346     {
1347       yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1348       return TYPENAME;
1349     }
1350   else if (sym.symbol == NULL)
1351     {
1352       /* Look-up first for a module name, then a type.  */
1353       sym = lookup_symbol (copy.c_str (), block, MODULE_DOMAIN, NULL);
1354       if (sym.symbol == NULL)
1355         sym = lookup_symbol (copy.c_str (), block, STRUCT_DOMAIN, NULL);
1356
1357       if (sym.symbol != NULL)
1358         {
1359           yylval.tsym.type = SYMBOL_TYPE (sym.symbol);
1360           return TYPENAME;
1361         }
1362
1363       return UNKNOWN_NAME;
1364     }
1365
1366   return IDENTIFIER;
1367 }
1368
1369 /* Like classify_name, but used by the inner loop of the lexer, when a
1370    name might have already been seen.  CONTEXT is the context type, or
1371    NULL if this is the first component of a name.  */
1372
1373 static int
1374 classify_inner_name (struct parser_state *par_state,
1375                      const struct block *block, struct type *context)
1376 {
1377   struct type *type;
1378
1379   if (context == NULL)
1380     return classify_name (par_state, block);
1381
1382   type = check_typedef (context);
1383   if (!type_aggregate_p (type))
1384     return ERROR;
1385
1386   std::string copy = copy_name (yylval.ssym.stoken);
1387   yylval.ssym.sym = d_lookup_nested_symbol (type, copy.c_str (), block);
1388
1389   if (yylval.ssym.sym.symbol == NULL)
1390     return ERROR;
1391
1392   if (SYMBOL_CLASS (yylval.ssym.sym.symbol) == LOC_TYPEDEF)
1393     {
1394       yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
1395       return TYPENAME;
1396     }
1397
1398   return IDENTIFIER;
1399 }
1400
1401 /* The outer level of a two-level lexer.  This calls the inner lexer
1402    to return tokens.  It then either returns these tokens, or
1403    aggregates them into a larger token.  This lets us work around a
1404    problem in our parsing approach, where the parser could not
1405    distinguish between qualified names and qualified types at the
1406    right point.  */
1407
1408 static int
1409 yylex (void)
1410 {
1411   token_and_value current;
1412   int last_was_dot;
1413   struct type *context_type = NULL;
1414   int last_to_examine, next_to_examine, checkpoint;
1415   const struct block *search_block;
1416
1417   if (popping && !token_fifo.empty ())
1418     goto do_pop;
1419   popping = 0;
1420
1421   /* Read the first token and decide what to do.  */
1422   current.token = lex_one_token (pstate);
1423   if (current.token != IDENTIFIER && current.token != '.')
1424     return current.token;
1425
1426   /* Read any sequence of alternating "." and identifier tokens into
1427      the token FIFO.  */
1428   current.value = yylval;
1429   token_fifo.push_back (current);
1430   last_was_dot = current.token == '.';
1431
1432   while (1)
1433     {
1434       current.token = lex_one_token (pstate);
1435       current.value = yylval;
1436       token_fifo.push_back (current);
1437
1438       if ((last_was_dot && current.token != IDENTIFIER)
1439           || (!last_was_dot && current.token != '.'))
1440         break;
1441
1442       last_was_dot = !last_was_dot;
1443     }
1444   popping = 1;
1445
1446   /* We always read one extra token, so compute the number of tokens
1447      to examine accordingly.  */
1448   last_to_examine = token_fifo.size () - 2;
1449   next_to_examine = 0;
1450
1451   current = token_fifo[next_to_examine];
1452   ++next_to_examine;
1453
1454   /* If we are not dealing with a typename, now is the time to find out.  */
1455   if (current.token == IDENTIFIER)
1456     {
1457       yylval = current.value;
1458       current.token = classify_name (pstate, pstate->expression_context_block);
1459       current.value = yylval;
1460     }
1461
1462   /* If the IDENTIFIER is not known, it could be a package symbol,
1463      first try building up a name until we find the qualified module.  */
1464   if (current.token == UNKNOWN_NAME)
1465     {
1466       name_obstack.clear ();
1467       obstack_grow (&name_obstack, current.value.sval.ptr,
1468                     current.value.sval.length);
1469
1470       last_was_dot = 0;
1471
1472       while (next_to_examine <= last_to_examine)
1473         {
1474           token_and_value next;
1475
1476           next = token_fifo[next_to_examine];
1477           ++next_to_examine;
1478
1479           if (next.token == IDENTIFIER && last_was_dot)
1480             {
1481               /* Update the partial name we are constructing.  */
1482               obstack_grow_str (&name_obstack, ".");
1483               obstack_grow (&name_obstack, next.value.sval.ptr,
1484                             next.value.sval.length);
1485
1486               yylval.sval.ptr = (char *) obstack_base (&name_obstack);
1487               yylval.sval.length = obstack_object_size (&name_obstack);
1488
1489               current.token = classify_name (pstate,
1490                                              pstate->expression_context_block);
1491               current.value = yylval;
1492
1493               /* We keep going until we find a TYPENAME.  */
1494               if (current.token == TYPENAME)
1495                 {
1496                   /* Install it as the first token in the FIFO.  */
1497                   token_fifo[0] = current;
1498                   token_fifo.erase (token_fifo.begin () + 1,
1499                                     token_fifo.begin () + next_to_examine);
1500                   break;
1501                 }
1502             }
1503           else if (next.token == '.' && !last_was_dot)
1504             last_was_dot = 1;
1505           else
1506             {
1507               /* We've reached the end of the name.  */
1508               break;
1509             }
1510         }
1511
1512       /* Reset our current token back to the start, if we found nothing
1513          this means that we will just jump to do pop.  */
1514       current = token_fifo[0];
1515       next_to_examine = 1;
1516     }
1517   if (current.token != TYPENAME && current.token != '.')
1518     goto do_pop;
1519
1520   name_obstack.clear ();
1521   checkpoint = 0;
1522   if (current.token == '.')
1523     search_block = NULL;
1524   else
1525     {
1526       gdb_assert (current.token == TYPENAME);
1527       search_block = pstate->expression_context_block;
1528       obstack_grow (&name_obstack, current.value.sval.ptr,
1529                     current.value.sval.length);
1530       context_type = current.value.tsym.type;
1531       checkpoint = 1;
1532     }
1533
1534   last_was_dot = current.token == '.';
1535
1536   while (next_to_examine <= last_to_examine)
1537     {
1538       token_and_value next;
1539
1540       next = token_fifo[next_to_examine];
1541       ++next_to_examine;
1542
1543       if (next.token == IDENTIFIER && last_was_dot)
1544         {
1545           int classification;
1546
1547           yylval = next.value;
1548           classification = classify_inner_name (pstate, search_block,
1549                                                 context_type);
1550           /* We keep going until we either run out of names, or until
1551              we have a qualified name which is not a type.  */
1552           if (classification != TYPENAME && classification != IDENTIFIER)
1553             break;
1554
1555           /* Accept up to this token.  */
1556           checkpoint = next_to_examine;
1557
1558           /* Update the partial name we are constructing.  */
1559           if (context_type != NULL)
1560             {
1561               /* We don't want to put a leading "." into the name.  */
1562               obstack_grow_str (&name_obstack, ".");
1563             }
1564           obstack_grow (&name_obstack, next.value.sval.ptr,
1565                         next.value.sval.length);
1566
1567           yylval.sval.ptr = (char *) obstack_base (&name_obstack);
1568           yylval.sval.length = obstack_object_size (&name_obstack);
1569           current.value = yylval;
1570           current.token = classification;
1571
1572           last_was_dot = 0;
1573
1574           if (classification == IDENTIFIER)
1575             break;
1576
1577           context_type = yylval.tsym.type;
1578         }
1579       else if (next.token == '.' && !last_was_dot)
1580         last_was_dot = 1;
1581       else
1582         {
1583           /* We've reached the end of the name.  */
1584           break;
1585         }
1586     }
1587
1588   /* If we have a replacement token, install it as the first token in
1589      the FIFO, and delete the other constituent tokens.  */
1590   if (checkpoint > 0)
1591     {
1592       token_fifo[0] = current;
1593       if (checkpoint > 1)
1594         token_fifo.erase (token_fifo.begin () + 1,
1595                           token_fifo.begin () + checkpoint);
1596     }
1597
1598  do_pop:
1599   current = token_fifo[0];
1600   token_fifo.erase (token_fifo.begin ());
1601   yylval = current.value;
1602   return current.token;
1603 }
1604
1605 int
1606 d_parse (struct parser_state *par_state)
1607 {
1608   /* Setting up the parser state.  */
1609   scoped_restore pstate_restore = make_scoped_restore (&pstate);
1610   gdb_assert (par_state != NULL);
1611   pstate = par_state;
1612
1613   scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
1614                                                         parser_debug);
1615
1616   struct type_stack stack;
1617   scoped_restore restore_type_stack = make_scoped_restore (&type_stack,
1618                                                            &stack);
1619
1620   /* Initialize some state used by the lexer.  */
1621   last_was_structop = 0;
1622   saw_name_at_eof = 0;
1623   paren_depth = 0;
1624
1625   token_fifo.clear ();
1626   popping = 0;
1627   name_obstack.clear ();
1628
1629   int result = yyparse ();
1630   if (!result)
1631     pstate->set_operation (pstate->pop ());
1632   return result;
1633 }
1634
1635 static void
1636 yyerror (const char *msg)
1637 {
1638   if (pstate->prev_lexptr)
1639     pstate->lexptr = pstate->prev_lexptr;
1640
1641   error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);
1642 }
1643