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