gdb/c-exp.y

   1 /* YACC parser for C expressions, for GDB.
   2    Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* Parse a C expression from text in a string,
  21    and return the result as a  struct expression  pointer.
  22    That structure contains arithmetic operations in reverse polish,
  23    with constants represented by operations that are followed by special data.
  24    See expression.h for the details of the format.
  25    What is important here is that it can be built up sequentially
  26    during the process of parsing; the lower levels of the tree always
  27    come first in the result.
  28
  29    Note that malloc's and realloc's in this file are transformed to
  30    xmalloc and xrealloc respectively by the same sed command in the
  31    makefile that remaps any other malloc/realloc inserted by the parser
  32    generator.  Doing this with #defines and trying to control the interaction
  33    with include files (<malloc.h> and <stdlib.h> for example) just became
  34    too messy, particularly when such includes can be inserted at random
  35    times by the parser generator.  */
  36
  37 %{
  38
  39 #include "defs.h"
  40 #include "expression.h"
  41 #include "value.h"
  42 #include "parser-defs.h"
  43 #include "language.h"
  44 #include "c-lang.h"
  45 #include "bfd.h" /* Required by objfiles.h.  */
  46 #include "symfile.h" /* Required by objfiles.h.  */
  47 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
  48
  49 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
  50    as well as gratuitiously global symbol names, so we can have multiple
  51    yacc generated parsers in gdb.  Note that these are only the variables
  52    produced by yacc.  If other parser generators (bison, byacc, etc) produce
  53    additional global names that conflict at link time, then those parser
  54    generators need to be fixed instead of adding those names to this list. */
  55
  56 #define yymaxdepth c_maxdepth
  57 #define yyparse c_parse
  58 #define yylex   c_lex
  59 #define yyerror c_error
  60 #define yylval  c_lval
  61 #define yychar  c_char
  62 #define yydebug c_debug
  63 #define yypact  c_pact
  64 #define yyr1    c_r1
  65 #define yyr2    c_r2
  66 #define yydef   c_def
  67 #define yychk   c_chk
  68 #define yypgo   c_pgo
  69 #define yyact   c_act
  70 #define yyexca  c_exca
  71 #define yyerrflag c_errflag
  72 #define yynerrs c_nerrs
  73 #define yyps    c_ps
  74 #define yypv    c_pv
  75 #define yys     c_s
  76 #define yy_yys  c_yys
  77 #define yystate c_state
  78 #define yytmp   c_tmp
  79 #define yyv     c_v
  80 #define yy_yyv  c_yyv
  81 #define yyval   c_val
  82 #define yylloc  c_lloc
  83 #define yyreds  c_reds          /* With YYDEBUG defined */
  84 #define yytoks  c_toks          /* With YYDEBUG defined */
  85
  86 #ifndef YYDEBUG
  87 #define YYDEBUG 0               /* Default to no yydebug support */
  88 #endif
  89
  90 int
  91 yyparse PARAMS ((void));
  92
  93 static int
  94 yylex PARAMS ((void));
  95
  96 void
  97 yyerror PARAMS ((char *));
  98
  99 %}
 100
 101 /* Although the yacc "value" of an expression is not used,
 102    since the result is stored in the structure being created,
 103    other node types do have values.  */
 104
 105 %union
 106   {
 107     LONGEST lval;
 108     struct {
 109       LONGEST val;
 110       struct type *type;
 111     } typed_val;
 112     double dval;
 113     struct symbol *sym;
 114     struct type *tval;
 115     struct stoken sval;
 116     struct ttype tsym;
 117     struct symtoken ssym;
 118     int voidval;
 119     struct block *bval;
 120     enum exp_opcode opcode;
 121     struct internalvar *ivar;
 122
 123     struct type **tvec;
 124     int *ivec;
 125   }
 126
 127 %{
 128 /* YYSTYPE gets defined by %union */
 129 static int
 130 parse_number PARAMS ((char *, int, int, YYSTYPE *));
 131 %}
 132
 133 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
 134 %type <lval> rcurly
 135 %type <tval> type typebase
 136 %type <tvec> nonempty_typelist
 137 /* %type <bval> block */
 138
 139 /* Fancy type parsing.  */
 140 %type <voidval> func_mod direct_abs_decl abs_decl
 141 %type <tval> ptype
 142 %type <lval> array_mod
 143
 144 %token <typed_val> INT
 145 %token <dval> FLOAT
 146
 147 /* Both NAME and TYPENAME tokens represent symbols in the input,
 148    and both convey their data as strings.
 149    But a TYPENAME is a string that happens to be defined as a typedef
 150    or builtin type name (such as int or char)
 151    and a NAME is any other symbol.
 152    Contexts where this distinction is not important can use the
 153    nonterminal "name", which matches either NAME or TYPENAME.  */
 154
 155 %token <sval> STRING
 156 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
 157 %token <tsym> TYPENAME
 158 %type <sval> name
 159 %type <ssym> name_not_typename
 160 %type <tsym> typename
 161
 162 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
 163    but which would parse as a valid number in the current input radix.
 164    E.g. "c" when input_radix==16.  Depending on the parse, it will be
 165    turned into a name or into a number.  */
 166
 167 %token <ssym> NAME_OR_INT
 168
 169 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
 170 %token TEMPLATE
 171 %token ERROR
 172
 173 /* Special type cases, put in to allow the parser to distinguish different
 174    legal basetypes.  */
 175 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD
 176 %token <lval> LAST REGNAME
 177
 178 %token <ivar> VARIABLE
 179
 180 %token <opcode> ASSIGN_MODIFY
 181
 182 /* C++ */
 183 %token THIS
 184
 185 %left ','
 186 %left ABOVE_COMMA
 187 %right '=' ASSIGN_MODIFY
 188 %right '?'
 189 %left OROR
 190 %left ANDAND
 191 %left '|'
 192 %left '^'
 193 %left '&'
 194 %left EQUAL NOTEQUAL
 195 %left '<' '>' LEQ GEQ
 196 %left LSH RSH
 197 %left '@'
 198 %left '+' '-'
 199 %left '*' '/' '%'
 200 %right UNARY INCREMENT DECREMENT
 201 %right ARROW '.' '[' '('
 202 %token <ssym> BLOCKNAME
 203 %type <bval> block
 204 %left COLONCOLON
 205
 206 \f
 207 %%
 208
 209 start   :       exp1
 210         |       type_exp
 211         ;
 212
 213 type_exp:       type
 214                         { write_exp_elt_opcode(OP_TYPE);
 215                           write_exp_elt_type($1);
 216                           write_exp_elt_opcode(OP_TYPE);}
 217         ;
 218
 219 /* Expressions, including the comma operator.  */
 220 exp1    :       exp
 221         |       exp1 ',' exp
 222                         { write_exp_elt_opcode (BINOP_COMMA); }
 223         ;
 224
 225 /* Expressions, not including the comma operator.  */
 226 exp     :       '*' exp    %prec UNARY
 227                         { write_exp_elt_opcode (UNOP_IND); }
 228
 229 exp     :       '&' exp    %prec UNARY
 230                         { write_exp_elt_opcode (UNOP_ADDR); }
 231
 232 exp     :       '-' exp    %prec UNARY
 233                         { write_exp_elt_opcode (UNOP_NEG); }
 234         ;
 235
 236 exp     :       '!' exp    %prec UNARY
 237                         { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
 238         ;
 239
 240 exp     :       '~' exp    %prec UNARY
 241                         { write_exp_elt_opcode (UNOP_COMPLEMENT); }
 242         ;
 243
 244 exp     :       INCREMENT exp    %prec UNARY
 245                         { write_exp_elt_opcode (UNOP_PREINCREMENT); }
 246         ;
 247
 248 exp     :       DECREMENT exp    %prec UNARY
 249                         { write_exp_elt_opcode (UNOP_PREDECREMENT); }
 250         ;
 251
 252 exp     :       exp INCREMENT    %prec UNARY
 253                         { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
 254         ;
 255
 256 exp     :       exp DECREMENT    %prec UNARY
 257                         { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
 258         ;
 259
 260 exp     :       SIZEOF exp       %prec UNARY
 261                         { write_exp_elt_opcode (UNOP_SIZEOF); }
 262         ;
 263
 264 exp     :       exp ARROW name
 265                         { write_exp_elt_opcode (STRUCTOP_PTR);
 266                           write_exp_string ($3);
 267                           write_exp_elt_opcode (STRUCTOP_PTR); }
 268         ;
 269
 270 exp     :       exp ARROW qualified_name
 271                         { /* exp->type::name becomes exp->*(&type::name) */
 272                           /* Note: this doesn't work if name is a
 273                              static member!  FIXME */
 274                           write_exp_elt_opcode (UNOP_ADDR);
 275                           write_exp_elt_opcode (STRUCTOP_MPTR); }
 276         ;
 277 exp     :       exp ARROW '*' exp
 278                         { write_exp_elt_opcode (STRUCTOP_MPTR); }
 279         ;
 280
 281 exp     :       exp '.' name
 282                         { write_exp_elt_opcode (STRUCTOP_STRUCT);
 283                           write_exp_string ($3);
 284                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 285         ;
 286
 287 exp     :       exp '.' qualified_name
 288                         { /* exp.type::name becomes exp.*(&type::name) */
 289                           /* Note: this doesn't work if name is a
 290                              static member!  FIXME */
 291                           write_exp_elt_opcode (UNOP_ADDR);
 292                           write_exp_elt_opcode (STRUCTOP_MEMBER); }
 293         ;
 294
 295 exp     :       exp '.' '*' exp
 296                         { write_exp_elt_opcode (STRUCTOP_MEMBER); }
 297         ;
 298
 299 exp     :       exp '[' exp1 ']'
 300                         { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
 301         ;
 302
 303 exp     :       exp '('
 304                         /* This is to save the value of arglist_len
 305                            being accumulated by an outer function call.  */
 306                         { start_arglist (); }
 307                 arglist ')'     %prec ARROW
 308                         { write_exp_elt_opcode (OP_FUNCALL);
 309                           write_exp_elt_longcst ((LONGEST) end_arglist ());
 310                           write_exp_elt_opcode (OP_FUNCALL); }
 311         ;
 312
 313 lcurly  :       '{'
 314                         { start_arglist (); }
 315         ;
 316
 317 arglist :
 318         ;
 319
 320 arglist :       exp
 321                         { arglist_len = 1; }
 322         ;
 323
 324 arglist :       arglist ',' exp   %prec ABOVE_COMMA
 325                         { arglist_len++; }
 326         ;
 327
 328 rcurly  :       '}'
 329                         { $$ = end_arglist () - 1; }
 330         ;
 331 exp     :       lcurly arglist rcurly   %prec ARROW
 332                         { write_exp_elt_opcode (OP_ARRAY);
 333                           write_exp_elt_longcst ((LONGEST) 0);
 334                           write_exp_elt_longcst ((LONGEST) $3);
 335                           write_exp_elt_opcode (OP_ARRAY); }
 336         ;
 337
 338 exp     :       lcurly type rcurly exp  %prec UNARY
 339                         { write_exp_elt_opcode (UNOP_MEMVAL);
 340                           write_exp_elt_type ($2);
 341                           write_exp_elt_opcode (UNOP_MEMVAL); }
 342         ;
 343
 344 exp     :       '(' type ')' exp  %prec UNARY
 345                         { write_exp_elt_opcode (UNOP_CAST);
 346                           write_exp_elt_type ($2);
 347                           write_exp_elt_opcode (UNOP_CAST); }
 348         ;
 349
 350 exp     :       '(' exp1 ')'
 351                         { }
 352         ;
 353
 354 /* Binary operators in order of decreasing precedence.  */
 355
 356 exp     :       exp '@' exp
 357                         { write_exp_elt_opcode (BINOP_REPEAT); }
 358         ;
 359
 360 exp     :       exp '*' exp
 361                         { write_exp_elt_opcode (BINOP_MUL); }
 362         ;
 363
 364 exp     :       exp '/' exp
 365                         { write_exp_elt_opcode (BINOP_DIV); }
 366         ;
 367
 368 exp     :       exp '%' exp
 369                         { write_exp_elt_opcode (BINOP_REM); }
 370         ;
 371
 372 exp     :       exp '+' exp
 373                         { write_exp_elt_opcode (BINOP_ADD); }
 374         ;
 375
 376 exp     :       exp '-' exp
 377                         { write_exp_elt_opcode (BINOP_SUB); }
 378         ;
 379
 380 exp     :       exp LSH exp
 381                         { write_exp_elt_opcode (BINOP_LSH); }
 382         ;
 383
 384 exp     :       exp RSH exp
 385                         { write_exp_elt_opcode (BINOP_RSH); }
 386         ;
 387
 388 exp     :       exp EQUAL exp
 389                         { write_exp_elt_opcode (BINOP_EQUAL); }
 390         ;
 391
 392 exp     :       exp NOTEQUAL exp
 393                         { write_exp_elt_opcode (BINOP_NOTEQUAL); }
 394         ;
 395
 396 exp     :       exp LEQ exp
 397                         { write_exp_elt_opcode (BINOP_LEQ); }
 398         ;
 399
 400 exp     :       exp GEQ exp
 401                         { write_exp_elt_opcode (BINOP_GEQ); }
 402         ;
 403
 404 exp     :       exp '<' exp
 405                         { write_exp_elt_opcode (BINOP_LESS); }
 406         ;
 407
 408 exp     :       exp '>' exp
 409                         { write_exp_elt_opcode (BINOP_GTR); }
 410         ;
 411
 412 exp     :       exp '&' exp
 413                         { write_exp_elt_opcode (BINOP_BITWISE_AND); }
 414         ;
 415
 416 exp     :       exp '^' exp
 417                         { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
 418         ;
 419
 420 exp     :       exp '|' exp
 421                         { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
 422         ;
 423
 424 exp     :       exp ANDAND exp
 425                         { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
 426         ;
 427
 428 exp     :       exp OROR exp
 429                         { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
 430         ;
 431
 432 exp     :       exp '?' exp ':' exp     %prec '?'
 433                         { write_exp_elt_opcode (TERNOP_COND); }
 434         ;
 435
 436 exp     :       exp '=' exp
 437                         { write_exp_elt_opcode (BINOP_ASSIGN); }
 438         ;
 439
 440 exp     :       exp ASSIGN_MODIFY exp
 441                         { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
 442                           write_exp_elt_opcode ($2);
 443                           write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
 444         ;
 445
 446 exp     :       INT
 447                         { write_exp_elt_opcode (OP_LONG);
 448                           write_exp_elt_type ($1.type);
 449                           write_exp_elt_longcst ((LONGEST)($1.val));
 450                           write_exp_elt_opcode (OP_LONG); }
 451         ;
 452
 453 exp     :       NAME_OR_INT
 454                         { YYSTYPE val;
 455                           parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
 456                           write_exp_elt_opcode (OP_LONG);
 457                           write_exp_elt_type (val.typed_val.type);
 458                           write_exp_elt_longcst ((LONGEST)val.typed_val.val);
 459                           write_exp_elt_opcode (OP_LONG);
 460                         }
 461         ;
 462
 463
 464 exp     :       FLOAT
 465                         { write_exp_elt_opcode (OP_DOUBLE);
 466                           write_exp_elt_type (builtin_type_double);
 467                           write_exp_elt_dblcst ($1);
 468                           write_exp_elt_opcode (OP_DOUBLE); }
 469         ;
 470
 471 exp     :       variable
 472         ;
 473
 474 exp     :       LAST
 475                         { write_exp_elt_opcode (OP_LAST);
 476                           write_exp_elt_longcst ((LONGEST) $1);
 477                           write_exp_elt_opcode (OP_LAST); }
 478         ;
 479
 480 exp     :       REGNAME
 481                         { write_exp_elt_opcode (OP_REGISTER);
 482                           write_exp_elt_longcst ((LONGEST) $1);
 483                           write_exp_elt_opcode (OP_REGISTER); }
 484         ;
 485
 486 exp     :       VARIABLE
 487                         { write_exp_elt_opcode (OP_INTERNALVAR);
 488                           write_exp_elt_intern ($1);
 489                           write_exp_elt_opcode (OP_INTERNALVAR); }
 490         ;
 491
 492 exp     :       SIZEOF '(' type ')'     %prec UNARY
 493                         { write_exp_elt_opcode (OP_LONG);
 494                           write_exp_elt_type (builtin_type_int);
 495                           write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
 496                           write_exp_elt_opcode (OP_LONG); }
 497         ;
 498
 499 exp     :       STRING
 500                         { /* C strings are converted into array constants with
 501                              an explicit null byte added at the end.  Thus
 502                              the array upper bound is the string length.
 503                              There is no such thing in C as a completely empty
 504                              string. */
 505                           char *sp = $1.ptr; int count = $1.length;
 506                           while (count-- > 0)
 507                             {
 508                               write_exp_elt_opcode (OP_LONG);
 509                               write_exp_elt_type (builtin_type_char);
 510                               write_exp_elt_longcst ((LONGEST)(*sp++));
 511                               write_exp_elt_opcode (OP_LONG);
 512                             }
 513                           write_exp_elt_opcode (OP_LONG);
 514                           write_exp_elt_type (builtin_type_char);
 515                           write_exp_elt_longcst ((LONGEST)'\0');
 516                           write_exp_elt_opcode (OP_LONG);
 517                           write_exp_elt_opcode (OP_ARRAY);
 518                           write_exp_elt_longcst ((LONGEST) 0);
 519                           write_exp_elt_longcst ((LONGEST) ($1.length));
 520                           write_exp_elt_opcode (OP_ARRAY); }
 521         ;
 522
 523 /* C++.  */
 524 exp     :       THIS
 525                         { write_exp_elt_opcode (OP_THIS);
 526                           write_exp_elt_opcode (OP_THIS); }
 527         ;
 528
 529 /* end of C++.  */
 530
 531 block   :       BLOCKNAME
 532                         {
 533                           if ($1.sym != 0)
 534                               $$ = SYMBOL_BLOCK_VALUE ($1.sym);
 535                           else
 536                             {
 537                               struct symtab *tem =
 538                                   lookup_symtab (copy_name ($1.stoken));
 539                               if (tem)
 540                                 $$ = BLOCKVECTOR_BLOCK
 541                                          (BLOCKVECTOR (tem), STATIC_BLOCK);
 542                               else
 543                                 error ("No file or function \"%s\".",
 544                                        copy_name ($1.stoken));
 545                             }
 546                         }
 547         ;
 548
 549 block   :       block COLONCOLON name
 550                         { struct symbol *tem
 551                             = lookup_symbol (copy_name ($3), $1,
 552                                              VAR_NAMESPACE, (int *) NULL,
 553                                              (struct symtab **) NULL);
 554                           if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
 555                             error ("No function \"%s\" in specified context.",
 556                                    copy_name ($3));
 557                           $$ = SYMBOL_BLOCK_VALUE (tem); }
 558         ;
 559
 560 variable:       block COLONCOLON name
 561                         { struct symbol *sym;
 562                           sym = lookup_symbol (copy_name ($3), $1,
 563                                                VAR_NAMESPACE, (int *) NULL,
 564                                                (struct symtab **) NULL);
 565                           if (sym == 0)
 566                             error ("No symbol \"%s\" in specified context.",
 567                                    copy_name ($3));
 568
 569                           write_exp_elt_opcode (OP_VAR_VALUE);
 570                           /* block_found is set by lookup_symbol.  */
 571                           write_exp_elt_block (block_found);
 572                           write_exp_elt_sym (sym);
 573                           write_exp_elt_opcode (OP_VAR_VALUE); }
 574         ;
 575
 576 qualified_name: typebase COLONCOLON name
 577                         {
 578                           struct type *type = $1;
 579                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 580                               && TYPE_CODE (type) != TYPE_CODE_UNION)
 581                             error ("`%s' is not defined as an aggregate type.",
 582                                    TYPE_NAME (type));
 583
 584                           write_exp_elt_opcode (OP_SCOPE);
 585                           write_exp_elt_type (type);
 586                           write_exp_string ($3);
 587                           write_exp_elt_opcode (OP_SCOPE);
 588                         }
 589         |       typebase COLONCOLON '~' name
 590                         {
 591                           struct type *type = $1;
 592                           struct stoken tmp_token;
 593                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 594                               && TYPE_CODE (type) != TYPE_CODE_UNION)
 595                             error ("`%s' is not defined as an aggregate type.",
 596                                    TYPE_NAME (type));
 597
 598                           if (!STREQ (type_name_no_tag (type), $4.ptr))
 599                             error ("invalid destructor `%s::~%s'",
 600                                    type_name_no_tag (type), $4.ptr);
 601
 602                           tmp_token.ptr = (char*) alloca ($4.length + 2);
 603                           tmp_token.length = $4.length + 1;
 604                           tmp_token.ptr[0] = '~';
 605                           memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
 606                           tmp_token.ptr[tmp_token.length] = 0;
 607                           write_exp_elt_opcode (OP_SCOPE);
 608                           write_exp_elt_type (type);
 609                           write_exp_string (tmp_token);
 610                           write_exp_elt_opcode (OP_SCOPE);
 611                         }
 612         ;
 613
 614 variable:       qualified_name
 615         |       COLONCOLON name
 616                         {
 617                           char *name = copy_name ($2);
 618                           struct symbol *sym;
 619                           struct minimal_symbol *msymbol;
 620
 621                           sym =
 622                             lookup_symbol (name, (const struct block *) NULL,
 623                                            VAR_NAMESPACE, (int *) NULL,
 624                                            (struct symtab **) NULL);
 625                           if (sym)
 626                             {
 627                               write_exp_elt_opcode (OP_VAR_VALUE);
 628                               write_exp_elt_block (NULL);
 629                               write_exp_elt_sym (sym);
 630                               write_exp_elt_opcode (OP_VAR_VALUE);
 631                               break;
 632                             }
 633
 634                           msymbol = lookup_minimal_symbol (name,
 635                                       (struct objfile *) NULL);
 636                           if (msymbol != NULL)
 637                             {
 638                               write_exp_msymbol (msymbol,
 639                                                  lookup_function_type (builtin_type_int),
 640                                                  builtin_type_int);
 641                             }
 642                           else
 643                             if (!have_full_symbols () && !have_partial_symbols ())
 644                               error ("No symbol table is loaded.  Use the \"file\" command.");
 645                             else
 646                               error ("No symbol \"%s\" in current context.", name);
 647                         }
 648         ;
 649
 650 variable:       name_not_typename
 651                         { struct symbol *sym = $1.sym;
 652
 653                           if (sym)
 654                             {
 655                               if (symbol_read_needs_frame (sym))
 656                                 {
 657                                   if (innermost_block == 0 ||
 658                                       contained_in (block_found,
 659                                                     innermost_block))
 660                                     innermost_block = block_found;
 661                                 }
 662
 663                               write_exp_elt_opcode (OP_VAR_VALUE);
 664                               /* We want to use the selected frame, not
 665                                  another more inner frame which happens to
 666                                  be in the same block.  */
 667                               write_exp_elt_block (NULL);
 668                               write_exp_elt_sym (sym);
 669                               write_exp_elt_opcode (OP_VAR_VALUE);
 670                             }
 671                           else if ($1.is_a_field_of_this)
 672                             {
 673                               /* C++: it hangs off of `this'.  Must
 674                                  not inadvertently convert from a method call
 675                                  to data ref.  */
 676                               if (innermost_block == 0 ||
 677                                   contained_in (block_found, innermost_block))
 678                                 innermost_block = block_found;
 679                               write_exp_elt_opcode (OP_THIS);
 680                               write_exp_elt_opcode (OP_THIS);
 681                               write_exp_elt_opcode (STRUCTOP_PTR);
 682                               write_exp_string ($1.stoken);
 683                               write_exp_elt_opcode (STRUCTOP_PTR);
 684                             }
 685                           else
 686                             {
 687                               struct minimal_symbol *msymbol;
 688                               register char *arg = copy_name ($1.stoken);
 689
 690                               msymbol = lookup_minimal_symbol (arg,
 691                                           (struct objfile *) NULL);
 692                               if (msymbol != NULL)
 693                                 {
 694                                   write_exp_msymbol (msymbol,
 695                                                      lookup_function_type (builtin_type_int),
 696                                                      builtin_type_int);
 697                                 }
 698                               else if (!have_full_symbols () && !have_partial_symbols ())
 699                                 error ("No symbol table is loaded.  Use the \"file\" command.");
 700                               else
 701                                 error ("No symbol \"%s\" in current context.",
 702                                        copy_name ($1.stoken));
 703                             }
 704                         }
 705         ;
 706
 707
 708 ptype   :       typebase
 709         /* "const" and "volatile" are curently ignored.  A type qualifier
 710            before the type is currently handled in the typebase rule.
 711            The reason for recognizing these here (shift/reduce conflicts)
 712            might be obsolete now that some pointer to member rules have
 713            been deleted.  */
 714         |       typebase CONST_KEYWORD
 715         |       typebase VOLATILE_KEYWORD
 716         |       typebase abs_decl
 717                 { $$ = follow_types ($1); }
 718         |       typebase CONST_KEYWORD abs_decl
 719                 { $$ = follow_types ($1); }
 720         |       typebase VOLATILE_KEYWORD abs_decl
 721                 { $$ = follow_types ($1); }
 722         ;
 723
 724 abs_decl:       '*'
 725                         { push_type (tp_pointer); $$ = 0; }
 726         |       '*' abs_decl
 727                         { push_type (tp_pointer); $$ = $2; }
 728         |       '&'
 729                         { push_type (tp_reference); $$ = 0; }
 730         |       '&' abs_decl
 731                         { push_type (tp_reference); $$ = $2; }
 732         |       direct_abs_decl
 733         ;
 734
 735 direct_abs_decl: '(' abs_decl ')'
 736                         { $$ = $2; }
 737         |       direct_abs_decl array_mod
 738                         {
 739                           push_type_int ($2);
 740                           push_type (tp_array);
 741                         }
 742         |       array_mod
 743                         {
 744                           push_type_int ($1);
 745                           push_type (tp_array);
 746                           $$ = 0;
 747                         }
 748
 749         |       direct_abs_decl func_mod
 750                         { push_type (tp_function); }
 751         |       func_mod
 752                         { push_type (tp_function); }
 753         ;
 754
 755 array_mod:      '[' ']'
 756                         { $$ = -1; }
 757         |       '[' INT ']'
 758                         { $$ = $2.val; }
 759         ;
 760
 761 func_mod:       '(' ')'
 762                         { $$ = 0; }
 763         |       '(' nonempty_typelist ')'
 764                         { free ((PTR)$2); $$ = 0; }
 765         ;
 766
 767 /* We used to try to recognize more pointer to member types here, but
 768    that didn't work (shift/reduce conflicts meant that these rules never
 769    got executed).  The problem is that
 770      int (foo::bar::baz::bizzle)
 771    is a function type but
 772      int (foo::bar::baz::bizzle::*)
 773    is a pointer to member type.  Stroustrup loses again!  */
 774
 775 type    :       ptype
 776         |       typebase COLONCOLON '*'
 777                         { $$ = lookup_member_type (builtin_type_int, $1); }
 778         ;
 779
 780 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
 781         :       TYPENAME
 782                         { $$ = $1.type; }
 783         |       INT_KEYWORD
 784                         { $$ = builtin_type_int; }
 785         |       LONG
 786                         { $$ = builtin_type_long; }
 787         |       SHORT
 788                         { $$ = builtin_type_short; }
 789         |       LONG INT_KEYWORD
 790                         { $$ = builtin_type_long; }
 791         |       UNSIGNED LONG INT_KEYWORD
 792                         { $$ = builtin_type_unsigned_long; }
 793         |       LONG LONG
 794                         { $$ = builtin_type_long_long; }
 795         |       LONG LONG INT_KEYWORD
 796                         { $$ = builtin_type_long_long; }
 797         |       UNSIGNED LONG LONG
 798                         { $$ = builtin_type_unsigned_long_long; }
 799         |       UNSIGNED LONG LONG INT_KEYWORD
 800                         { $$ = builtin_type_unsigned_long_long; }
 801         |       SHORT INT_KEYWORD
 802                         { $$ = builtin_type_short; }
 803         |       UNSIGNED SHORT INT_KEYWORD
 804                         { $$ = builtin_type_unsigned_short; }
 805         |       STRUCT name
 806                         { $$ = lookup_struct (copy_name ($2),
 807                                               expression_context_block); }
 808         |       CLASS name
 809                         { $$ = lookup_struct (copy_name ($2),
 810                                               expression_context_block); }
 811         |       UNION name
 812                         { $$ = lookup_union (copy_name ($2),
 813                                              expression_context_block); }
 814         |       ENUM name
 815                         { $$ = lookup_enum (copy_name ($2),
 816                                             expression_context_block); }
 817         |       UNSIGNED typename
 818                         { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
 819         |       UNSIGNED
 820                         { $$ = builtin_type_unsigned_int; }
 821         |       SIGNED_KEYWORD typename
 822                         { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
 823         |       SIGNED_KEYWORD
 824                         { $$ = builtin_type_int; }
 825         |       TEMPLATE name '<' type '>'
 826                         { $$ = lookup_template_type(copy_name($2), $4,
 827                                                     expression_context_block);
 828                         }
 829         /* "const" and "volatile" are curently ignored.  A type qualifier
 830            after the type is handled in the ptype rule.  I think these could
 831            be too.  */
 832         |       CONST_KEYWORD typebase { $$ = $2; }
 833         |       VOLATILE_KEYWORD typebase { $$ = $2; }
 834         ;
 835
 836 typename:       TYPENAME
 837         |       INT_KEYWORD
 838                 {
 839                   $$.stoken.ptr = "int";
 840                   $$.stoken.length = 3;
 841                   $$.type = builtin_type_int;
 842                 }
 843         |       LONG
 844                 {
 845                   $$.stoken.ptr = "long";
 846                   $$.stoken.length = 4;
 847                   $$.type = builtin_type_long;
 848                 }
 849         |       SHORT
 850                 {
 851                   $$.stoken.ptr = "short";
 852                   $$.stoken.length = 5;
 853                   $$.type = builtin_type_short;
 854                 }
 855         ;
 856
 857 nonempty_typelist
 858         :       type
 859                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
 860                   $<ivec>$[0] = 1;      /* Number of types in vector */
 861                   $$[1] = $1;
 862                 }
 863         |       nonempty_typelist ',' type
 864                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
 865                   $$ = (struct type **) realloc ((char *) $1, len);
 866                   $$[$<ivec>$[0]] = $3;
 867                 }
 868         ;
 869
 870 name    :       NAME { $$ = $1.stoken; }
 871         |       BLOCKNAME { $$ = $1.stoken; }
 872         |       TYPENAME { $$ = $1.stoken; }
 873         |       NAME_OR_INT  { $$ = $1.stoken; }
 874         ;
 875
 876 name_not_typename :     NAME
 877         |       BLOCKNAME
 878 /* These would be useful if name_not_typename was useful, but it is just
 879    a fake for "variable", so these cause reduce/reduce conflicts because
 880    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
 881    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
 882    context where only a name could occur, this might be useful.
 883         |       NAME_OR_INT
 884  */
 885         ;
 886
 887 %%
 888
 889 /* Take care of parsing a number (anything that starts with a digit).
 890    Set yylval and return the token type; update lexptr.
 891    LEN is the number of characters in it.  */
 892
 893 /*** Needs some error checking for the float case ***/
 894
 895 static int
 896 parse_number (p, len, parsed_float, putithere)
 897      register char *p;
 898      register int len;
 899      int parsed_float;
 900      YYSTYPE *putithere;
 901 {
 902   register LONGEST n = 0;
 903   register LONGEST prevn = 0;
 904   register int i = 0;
 905   register int c;
 906   register int base = input_radix;
 907   int unsigned_p = 0;
 908   int long_p = 0;
 909   unsigned LONGEST high_bit;
 910   struct type *signed_type;
 911   struct type *unsigned_type;
 912
 913   if (parsed_float)
 914     {
 915       /* It's a float since it contains a point or an exponent.  */
 916       putithere->dval = atof (p);
 917       return FLOAT;
 918     }
 919
 920   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
 921   if (p[0] == '0')
 922     switch (p[1])
 923       {
 924       case 'x':
 925       case 'X':
 926         if (len >= 3)
 927           {
 928             p += 2;
 929             base = 16;
 930             len -= 2;
 931           }
 932         break;
 933
 934       case 't':
 935       case 'T':
 936       case 'd':
 937       case 'D':
 938         if (len >= 3)
 939           {
 940             p += 2;
 941             base = 10;
 942             len -= 2;
 943           }
 944         break;
 945
 946       default:
 947         base = 8;
 948         break;
 949       }
 950
 951   while (len-- > 0)
 952     {
 953       c = *p++;
 954       if (c >= 'A' && c <= 'Z')
 955         c += 'a' - 'A';
 956       if (c != 'l' && c != 'u')
 957         n *= base;
 958       if (c >= '0' && c <= '9')
 959         n += i = c - '0';
 960       else
 961         {
 962           if (base > 10 && c >= 'a' && c <= 'f')
 963             n += i = c - 'a' + 10;
 964           else if (len == 0 && c == 'l')
 965             long_p = 1;
 966           else if (len == 0 && c == 'u')
 967             unsigned_p = 1;
 968           else
 969             return ERROR;       /* Char not a digit */
 970         }
 971       if (i >= base)
 972         return ERROR;           /* Invalid digit in this base */
 973
 974       /* Portably test for overflow (only works for nonzero values, so make
 975          a second check for zero).  */
 976       if((prevn >= n) && n != 0)
 977          unsigned_p=1;          /* Try something unsigned */
 978       /* If range checking enabled, portably test for unsigned overflow.  */
 979       if(RANGE_CHECK && n!=0)
 980       {
 981          if((unsigned_p && (unsigned)prevn >= (unsigned)n))
 982             range_error("Overflow on numeric constant.");
 983       }
 984       prevn=n;
 985     }
 986
 987      /* If the number is too big to be an int, or it's got an l suffix
 988         then it's a long.  Work out if this has to be a long by
 989         shifting right and and seeing if anything remains, and the
 990         target int size is different to the target long size.
 991
 992         In the expression below, we could have tested
 993                 (n >> TARGET_INT_BIT)
 994         to see if it was zero,
 995         but too many compilers warn about that, when ints and longs
 996         are the same size.  So we shift it twice, with fewer bits
 997         each time, for the same result.  */
 998
 999     if (   (TARGET_INT_BIT != TARGET_LONG_BIT
1000             && ((n >> 2) >> (TARGET_INT_BIT-2)))   /* Avoid shift warning */
1001         || long_p)
1002       {
1003          high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1);
1004          unsigned_type = builtin_type_unsigned_long;
1005          signed_type = builtin_type_long;
1006       }
1007     else
1008       {
1009          high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1);
1010          unsigned_type = builtin_type_unsigned_int;
1011          signed_type = builtin_type_int;
1012       }
1013
1014    putithere->typed_val.val = n;
1015
1016    /* If the high bit of the worked out type is set then this number
1017       has to be unsigned. */
1018
1019    if (unsigned_p || (n & high_bit))
1020      {
1021         putithere->typed_val.type = unsigned_type;
1022      }
1023    else
1024      {
1025         putithere->typed_val.type = signed_type;
1026      }
1027
1028    return INT;
1029 }
1030
1031 struct token
1032 {
1033   char *operator;
1034   int token;
1035   enum exp_opcode opcode;
1036 };
1037
1038 static const struct token tokentab3[] =
1039   {
1040     {">>=", ASSIGN_MODIFY, BINOP_RSH},
1041     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1042   };
1043
1044 static const struct token tokentab2[] =
1045   {
1046     {"+=", ASSIGN_MODIFY, BINOP_ADD},
1047     {"-=", ASSIGN_MODIFY, BINOP_SUB},
1048     {"*=", ASSIGN_MODIFY, BINOP_MUL},
1049     {"/=", ASSIGN_MODIFY, BINOP_DIV},
1050     {"%=", ASSIGN_MODIFY, BINOP_REM},
1051     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1052     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1053     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1054     {"++", INCREMENT, BINOP_END},
1055     {"--", DECREMENT, BINOP_END},
1056     {"->", ARROW, BINOP_END},
1057     {"&&", ANDAND, BINOP_END},
1058     {"||", OROR, BINOP_END},
1059     {"::", COLONCOLON, BINOP_END},
1060     {"<<", LSH, BINOP_END},
1061     {">>", RSH, BINOP_END},
1062     {"==", EQUAL, BINOP_END},
1063     {"!=", NOTEQUAL, BINOP_END},
1064     {"<=", LEQ, BINOP_END},
1065     {">=", GEQ, BINOP_END}
1066   };
1067
1068 /* Read one token, getting characters through lexptr.  */
1069
1070 static int
1071 yylex ()
1072 {
1073   int c;
1074   int namelen;
1075   unsigned int i;
1076   char *tokstart;
1077   char *tokptr;
1078   int tempbufindex;
1079   static char *tempbuf;
1080   static int tempbufsize;
1081
1082  retry:
1083
1084   tokstart = lexptr;
1085   /* See if it is a special token of length 3.  */
1086   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1087     if (STREQN (tokstart, tokentab3[i].operator, 3))
1088       {
1089         lexptr += 3;
1090         yylval.opcode = tokentab3[i].opcode;
1091         return tokentab3[i].token;
1092       }
1093
1094   /* See if it is a special token of length 2.  */
1095   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1096     if (STREQN (tokstart, tokentab2[i].operator, 2))
1097       {
1098         lexptr += 2;
1099         yylval.opcode = tokentab2[i].opcode;
1100         return tokentab2[i].token;
1101       }
1102
1103   switch (c = *tokstart)
1104     {
1105     case 0:
1106       return 0;
1107
1108     case ' ':
1109     case '\t':
1110     case '\n':
1111       lexptr++;
1112       goto retry;
1113
1114     case '\'':
1115       /* We either have a character constant ('0' or '\177' for example)
1116          or we have a quoted symbol reference ('foo(int,int)' in C++
1117          for example). */
1118       lexptr++;
1119       c = *lexptr++;
1120       if (c == '\\')
1121         c = parse_escape (&lexptr);
1122
1123       yylval.typed_val.val = c;
1124       yylval.typed_val.type = builtin_type_char;
1125
1126       c = *lexptr++;
1127       if (c != '\'')
1128         {
1129           namelen = skip_quoted (tokstart) - tokstart;
1130           if (namelen > 2)
1131             {
1132               lexptr = tokstart + namelen;
1133               if (lexptr[-1] != '\'')
1134                 error ("Unmatched single quote.");
1135               namelen -= 2;
1136               tokstart++;
1137               goto tryname;
1138             }
1139           error ("Invalid character constant.");
1140         }
1141       return INT;
1142
1143     case '(':
1144       paren_depth++;
1145       lexptr++;
1146       return c;
1147
1148     case ')':
1149       if (paren_depth == 0)
1150         return 0;
1151       paren_depth--;
1152       lexptr++;
1153       return c;
1154
1155     case ',':
1156       if (comma_terminates && paren_depth == 0)
1157         return 0;
1158       lexptr++;
1159       return c;
1160
1161     case '.':
1162       /* Might be a floating point number.  */
1163       if (lexptr[1] < '0' || lexptr[1] > '9')
1164         goto symbol;            /* Nope, must be a symbol. */
1165       /* FALL THRU into number case.  */
1166
1167     case '0':
1168     case '1':
1169     case '2':
1170     case '3':
1171     case '4':
1172     case '5':
1173     case '6':
1174     case '7':
1175     case '8':
1176     case '9':
1177       {
1178         /* It's a number.  */
1179         int got_dot = 0, got_e = 0, toktype;
1180         register char *p = tokstart;
1181         int hex = input_radix > 10;
1182
1183         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1184           {
1185             p += 2;
1186             hex = 1;
1187           }
1188         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1189           {
1190             p += 2;
1191             hex = 0;
1192           }
1193
1194         for (;; ++p)
1195           {
1196             /* This test includes !hex because 'e' is a valid hex digit
1197                and thus does not indicate a floating point number when
1198                the radix is hex.  */
1199             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1200               got_dot = got_e = 1;
1201             /* This test does not include !hex, because a '.' always indicates
1202                a decimal floating point number regardless of the radix.  */
1203             else if (!got_dot && *p == '.')
1204               got_dot = 1;
1205             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1206                      && (*p == '-' || *p == '+'))
1207               /* This is the sign of the exponent, not the end of the
1208                  number.  */
1209               continue;
1210             /* We will take any letters or digits.  parse_number will
1211                complain if past the radix, or if L or U are not final.  */
1212             else if ((*p < '0' || *p > '9')
1213                      && ((*p < 'a' || *p > 'z')
1214                                   && (*p < 'A' || *p > 'Z')))
1215               break;
1216           }
1217         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1218         if (toktype == ERROR)
1219           {
1220             char *err_copy = (char *) alloca (p - tokstart + 1);
1221
1222             memcpy (err_copy, tokstart, p - tokstart);
1223             err_copy[p - tokstart] = 0;
1224             error ("Invalid number \"%s\".", err_copy);
1225           }
1226         lexptr = p;
1227         return toktype;
1228       }
1229
1230     case '+':
1231     case '-':
1232     case '*':
1233     case '/':
1234     case '%':
1235     case '|':
1236     case '&':
1237     case '^':
1238     case '~':
1239     case '!':
1240     case '@':
1241     case '<':
1242     case '>':
1243     case '[':
1244     case ']':
1245     case '?':
1246     case ':':
1247     case '=':
1248     case '{':
1249     case '}':
1250     symbol:
1251       lexptr++;
1252       return c;
1253
1254     case '"':
1255
1256       /* Build the gdb internal form of the input string in tempbuf,
1257          translating any standard C escape forms seen.  Note that the
1258          buffer is null byte terminated *only* for the convenience of
1259          debugging gdb itself and printing the buffer contents when
1260          the buffer contains no embedded nulls.  Gdb does not depend
1261          upon the buffer being null byte terminated, it uses the length
1262          string instead.  This allows gdb to handle C strings (as well
1263          as strings in other languages) with embedded null bytes */
1264
1265       tokptr = ++tokstart;
1266       tempbufindex = 0;
1267
1268       do {
1269         /* Grow the static temp buffer if necessary, including allocating
1270            the first one on demand. */
1271         if (tempbufindex + 1 >= tempbufsize)
1272           {
1273             tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1274           }
1275         switch (*tokptr)
1276           {
1277           case '\0':
1278           case '"':
1279             /* Do nothing, loop will terminate. */
1280             break;
1281           case '\\':
1282             tokptr++;
1283             c = parse_escape (&tokptr);
1284             if (c == -1)
1285               {
1286                 continue;
1287               }
1288             tempbuf[tempbufindex++] = c;
1289             break;
1290           default:
1291             tempbuf[tempbufindex++] = *tokptr++;
1292             break;
1293           }
1294       } while ((*tokptr != '"') && (*tokptr != '\0'));
1295       if (*tokptr++ != '"')
1296         {
1297           error ("Unterminated string in expression.");
1298         }
1299       tempbuf[tempbufindex] = '\0';     /* See note above */
1300       yylval.sval.ptr = tempbuf;
1301       yylval.sval.length = tempbufindex;
1302       lexptr = tokptr;
1303       return (STRING);
1304     }
1305
1306   if (!(c == '_' || c == '$'
1307         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1308     /* We must have come across a bad character (e.g. ';').  */
1309     error ("Invalid character '%c' in expression.", c);
1310
1311   /* It's a name.  See how long it is.  */
1312   namelen = 0;
1313   for (c = tokstart[namelen];
1314        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1315         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1316        c = tokstart[++namelen])
1317     ;
1318
1319   /* The token "if" terminates the expression and is NOT
1320      removed from the input stream.  */
1321   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1322     {
1323       return 0;
1324     }
1325
1326   lexptr += namelen;
1327
1328   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1329      and $$digits (equivalent to $<-digits> if you could type that).
1330      Make token type LAST, and put the number (the digits) in yylval.  */
1331
1332   tryname:
1333   if (*tokstart == '$')
1334     {
1335       register int negate = 0;
1336       c = 1;
1337       /* Double dollar means negate the number and add -1 as well.
1338          Thus $$ alone means -1.  */
1339       if (namelen >= 2 && tokstart[1] == '$')
1340         {
1341           negate = 1;
1342           c = 2;
1343         }
1344       if (c == namelen)
1345         {
1346           /* Just dollars (one or two) */
1347           yylval.lval = - negate;
1348           return LAST;
1349         }
1350       /* Is the rest of the token digits?  */
1351       for (; c < namelen; c++)
1352         if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1353           break;
1354       if (c == namelen)
1355         {
1356           yylval.lval = atoi (tokstart + 1 + negate);
1357           if (negate)
1358             yylval.lval = - yylval.lval;
1359           return LAST;
1360         }
1361     }
1362
1363   /* Handle tokens that refer to machine registers:
1364      $ followed by a register name.  */
1365
1366   if (*tokstart == '$') {
1367     for (c = 0; c < NUM_REGS; c++)
1368       if (namelen - 1 == strlen (reg_names[c])
1369           && STREQN (tokstart + 1, reg_names[c], namelen - 1))
1370         {
1371           yylval.lval = c;
1372           return REGNAME;
1373         }
1374     for (c = 0; c < num_std_regs; c++)
1375      if (namelen - 1 == strlen (std_regs[c].name)
1376          && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
1377        {
1378          yylval.lval = std_regs[c].regnum;
1379          return REGNAME;
1380        }
1381   }
1382   /* Catch specific keywords.  Should be done with a data structure.  */
1383   switch (namelen)
1384     {
1385     case 8:
1386       if (STREQN (tokstart, "unsigned", 8))
1387         return UNSIGNED;
1388       if (current_language->la_language == language_cplus
1389           && STREQN (tokstart, "template", 8))
1390         return TEMPLATE;
1391       if (STREQN (tokstart, "volatile", 8))
1392         return VOLATILE_KEYWORD;
1393       break;
1394     case 6:
1395       if (STREQN (tokstart, "struct", 6))
1396         return STRUCT;
1397       if (STREQN (tokstart, "signed", 6))
1398         return SIGNED_KEYWORD;
1399       if (STREQN (tokstart, "sizeof", 6))
1400         return SIZEOF;
1401       break;
1402     case 5:
1403       if (current_language->la_language == language_cplus
1404           && STREQN (tokstart, "class", 5))
1405         return CLASS;
1406       if (STREQN (tokstart, "union", 5))
1407         return UNION;
1408       if (STREQN (tokstart, "short", 5))
1409         return SHORT;
1410       if (STREQN (tokstart, "const", 5))
1411         return CONST_KEYWORD;
1412       break;
1413     case 4:
1414       if (STREQN (tokstart, "enum", 4))
1415         return ENUM;
1416       if (STREQN (tokstart, "long", 4))
1417         return LONG;
1418       if (current_language->la_language == language_cplus
1419           && STREQN (tokstart, "this", 4))
1420         {
1421           static const char this_name[] =
1422                                  { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1423
1424           if (lookup_symbol (this_name, expression_context_block,
1425                              VAR_NAMESPACE, (int *) NULL,
1426                              (struct symtab **) NULL))
1427             return THIS;
1428         }
1429       break;
1430     case 3:
1431       if (STREQN (tokstart, "int", 3))
1432         return INT_KEYWORD;
1433       break;
1434     default:
1435       break;
1436     }
1437
1438   yylval.sval.ptr = tokstart;
1439   yylval.sval.length = namelen;
1440
1441   /* Any other names starting in $ are debugger internal variables.  */
1442
1443   if (*tokstart == '$')
1444     {
1445       yylval.ivar =  lookup_internalvar (copy_name (yylval.sval) + 1);
1446       return VARIABLE;
1447     }
1448
1449   /* Use token-type BLOCKNAME for symbols that happen to be defined as
1450      functions or symtabs.  If this is not so, then ...
1451      Use token-type TYPENAME for symbols that happen to be defined
1452      currently as names of types; NAME for other symbols.
1453      The caller is not constrained to care about the distinction.  */
1454   {
1455     char *tmp = copy_name (yylval.sval);
1456     struct symbol *sym;
1457     int is_a_field_of_this = 0;
1458     int hextype;
1459
1460     sym = lookup_symbol (tmp, expression_context_block,
1461                          VAR_NAMESPACE,
1462                          current_language->la_language == language_cplus
1463                          ? &is_a_field_of_this : (int *) NULL,
1464                          (struct symtab **) NULL);
1465     /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1466        no psymtabs (coff, xcoff, or some future change to blow away the
1467        psymtabs once once symbols are read).  */
1468     if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1469         lookup_symtab (tmp))
1470       {
1471         yylval.ssym.sym = sym;
1472         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1473         return BLOCKNAME;
1474       }
1475     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1476         {
1477 #if 0
1478           /* In "A::x", if x is a member function of A and there happens
1479              to be a type (nested or not, since the stabs don't make that
1480              distinction) named x, then this code incorrectly thinks we
1481              are dealing with nested types rather than a member function.  */
1482
1483           char *p;
1484           char *namestart;
1485           struct symbol *best_sym;
1486
1487           /* Look ahead to detect nested types.  This probably should be
1488              done in the grammar, but trying seemed to introduce a lot
1489              of shift/reduce and reduce/reduce conflicts.  It's possible
1490              that it could be done, though.  Or perhaps a non-grammar, but
1491              less ad hoc, approach would work well.  */
1492
1493           /* Since we do not currently have any way of distinguishing
1494              a nested type from a non-nested one (the stabs don't tell
1495              us whether a type is nested), we just ignore the
1496              containing type.  */
1497
1498           p = lexptr;
1499           best_sym = sym;
1500           while (1)
1501             {
1502               /* Skip whitespace.  */
1503               while (*p == ' ' || *p == '\t' || *p == '\n')
1504                 ++p;
1505               if (*p == ':' && p[1] == ':')
1506                 {
1507                   /* Skip the `::'.  */
1508                   p += 2;
1509                   /* Skip whitespace.  */
1510                   while (*p == ' ' || *p == '\t' || *p == '\n')
1511                     ++p;
1512                   namestart = p;
1513                   while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1514                          || (*p >= 'a' && *p <= 'z')
1515                          || (*p >= 'A' && *p <= 'Z'))
1516                     ++p;
1517                   if (p != namestart)
1518                     {
1519                       struct symbol *cur_sym;
1520                       /* As big as the whole rest of the expression, which is
1521                          at least big enough.  */
1522                       char *tmp = alloca (strlen (namestart));
1523
1524                       memcpy (tmp, namestart, p - namestart);
1525                       tmp[p - namestart] = '\0';
1526                       cur_sym = lookup_symbol (tmp, expression_context_block,
1527                                                VAR_NAMESPACE, (int *) NULL,
1528                                                (struct symtab **) NULL);
1529                       if (cur_sym)
1530                         {
1531                           if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1532                             {
1533                               best_sym = cur_sym;
1534                               lexptr = p;
1535                             }
1536                           else
1537                             break;
1538                         }
1539                       else
1540                         break;
1541                     }
1542                   else
1543                     break;
1544                 }
1545               else
1546                 break;
1547             }
1548
1549           yylval.tsym.type = SYMBOL_TYPE (best_sym);
1550 #else /* not 0 */
1551           yylval.tsym.type = SYMBOL_TYPE (sym);
1552 #endif /* not 0 */
1553           return TYPENAME;
1554         }
1555     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1556         return TYPENAME;
1557
1558     /* Input names that aren't symbols but ARE valid hex numbers,
1559        when the input radix permits them, can be names or numbers
1560        depending on the parse.  Note we support radixes > 16 here.  */
1561     if (!sym &&
1562         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1563          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1564       {
1565         YYSTYPE newlval;        /* Its value is ignored.  */
1566         hextype = parse_number (tokstart, namelen, 0, &newlval);
1567         if (hextype == INT)
1568           {
1569             yylval.ssym.sym = sym;
1570             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1571             return NAME_OR_INT;
1572           }
1573       }
1574
1575     /* Any other kind of symbol */
1576     yylval.ssym.sym = sym;
1577     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1578     return NAME;
1579   }
1580 }
1581
1582 void
1583 yyerror (msg)
1584      char *msg;
1585 {
1586   error (msg ? msg : "Invalid syntax in expression.");
1587 }