gdb/c-exp.y

   1 /* YACC parser for C expressions, for GDB.
   2    Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2003, 2004, 2006, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 /* Parse a C expression from text in a string,
  22    and return the result as a  struct expression  pointer.
  23    That structure contains arithmetic operations in reverse polish,
  24    with constants represented by operations that are followed by special data.
  25    See expression.h for the details of the format.
  26    What is important here is that it can be built up sequentially
  27    during the process of parsing; the lower levels of the tree always
  28    come first in the result.
  29
  30    Note that malloc's and realloc's in this file are transformed to
  31    xmalloc and xrealloc respectively by the same sed command in the
  32    makefile that remaps any other malloc/realloc inserted by the parser
  33    generator.  Doing this with #defines and trying to control the interaction
  34    with include files (<malloc.h> and <stdlib.h> for example) just became
  35    too messy, particularly when such includes can be inserted at random
  36    times by the parser generator.  */
  37
  38 %{
  39
  40 #include "defs.h"
  41 #include "gdb_string.h"
  42 #include <ctype.h>
  43 #include "expression.h"
  44 #include "value.h"
  45 #include "parser-defs.h"
  46 #include "language.h"
  47 #include "c-lang.h"
  48 #include "bfd.h" /* Required by objfiles.h.  */
  49 #include "symfile.h" /* Required by objfiles.h.  */
  50 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
  51 #include "charset.h"
  52 #include "block.h"
  53 #include "cp-support.h"
  54 #include "dfp.h"
  55 #include "gdb_assert.h"
  56 #include "macroscope.h"
  57
  58 #define parse_type builtin_type (parse_gdbarch)
  59
  60 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
  61    as well as gratuitiously global symbol names, so we can have multiple
  62    yacc generated parsers in gdb.  Note that these are only the variables
  63    produced by yacc.  If other parser generators (bison, byacc, etc) produce
  64    additional global names that conflict at link time, then those parser
  65    generators need to be fixed instead of adding those names to this list. */
  66
  67 #define yymaxdepth c_maxdepth
  68 #define yyparse c_parse_internal
  69 #define yylex   c_lex
  70 #define yyerror c_error
  71 #define yylval  c_lval
  72 #define yychar  c_char
  73 #define yydebug c_debug
  74 #define yypact  c_pact
  75 #define yyr1    c_r1
  76 #define yyr2    c_r2
  77 #define yydef   c_def
  78 #define yychk   c_chk
  79 #define yypgo   c_pgo
  80 #define yyact   c_act
  81 #define yyexca  c_exca
  82 #define yyerrflag c_errflag
  83 #define yynerrs c_nerrs
  84 #define yyps    c_ps
  85 #define yypv    c_pv
  86 #define yys     c_s
  87 #define yy_yys  c_yys
  88 #define yystate c_state
  89 #define yytmp   c_tmp
  90 #define yyv     c_v
  91 #define yy_yyv  c_yyv
  92 #define yyval   c_val
  93 #define yylloc  c_lloc
  94 #define yyreds  c_reds          /* With YYDEBUG defined */
  95 #define yytoks  c_toks          /* With YYDEBUG defined */
  96 #define yyname  c_name          /* With YYDEBUG defined */
  97 #define yyrule  c_rule          /* With YYDEBUG defined */
  98 #define yylhs   c_yylhs
  99 #define yylen   c_yylen
 100 #define yydefred c_yydefred
 101 #define yydgoto c_yydgoto
 102 #define yysindex c_yysindex
 103 #define yyrindex c_yyrindex
 104 #define yygindex c_yygindex
 105 #define yytable  c_yytable
 106 #define yycheck  c_yycheck
 107
 108 #ifndef YYDEBUG
 109 #define YYDEBUG 1               /* Default to yydebug support */
 110 #endif
 111
 112 #define YYFPRINTF parser_fprintf
 113
 114 int yyparse (void);
 115
 116 static int yylex (void);
 117
 118 void yyerror (char *);
 119
 120 %}
 121
 122 /* Although the yacc "value" of an expression is not used,
 123    since the result is stored in the structure being created,
 124    other node types do have values.  */
 125
 126 %union
 127   {
 128     LONGEST lval;
 129     struct {
 130       LONGEST val;
 131       struct type *type;
 132     } typed_val_int;
 133     struct {
 134       DOUBLEST dval;
 135       struct type *type;
 136     } typed_val_float;
 137     struct {
 138       gdb_byte val[16];
 139       struct type *type;
 140     } typed_val_decfloat;
 141     struct symbol *sym;
 142     struct type *tval;
 143     struct stoken sval;
 144     struct typed_stoken tsval;
 145     struct ttype tsym;
 146     struct symtoken ssym;
 147     int voidval;
 148     struct block *bval;
 149     enum exp_opcode opcode;
 150     struct internalvar *ivar;
 151
 152     struct stoken_vector svec;
 153     struct type **tvec;
 154     int *ivec;
 155   }
 156
 157 %{
 158 /* YYSTYPE gets defined by %union */
 159 static int parse_number (char *, int, int, YYSTYPE *);
 160 %}
 161
 162 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
 163 %type <lval> rcurly
 164 %type <tval> type typebase qualified_type
 165 %type <tvec> nonempty_typelist
 166 /* %type <bval> block */
 167
 168 /* Fancy type parsing.  */
 169 %type <voidval> func_mod direct_abs_decl abs_decl
 170 %type <tval> ptype
 171 %type <lval> array_mod
 172
 173 %token <typed_val_int> INT
 174 %token <typed_val_float> FLOAT
 175 %token <typed_val_decfloat> DECFLOAT
 176
 177 /* Both NAME and TYPENAME tokens represent symbols in the input,
 178    and both convey their data as strings.
 179    But a TYPENAME is a string that happens to be defined as a typedef
 180    or builtin type name (such as int or char)
 181    and a NAME is any other symbol.
 182    Contexts where this distinction is not important can use the
 183    nonterminal "name", which matches either NAME or TYPENAME.  */
 184
 185 %token <tsval> STRING
 186 %token <tsval> CHAR
 187 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
 188 %token <voidval> COMPLETE
 189 %token <tsym> TYPENAME
 190 %type <sval> name
 191 %type <svec> string_exp
 192 %type <ssym> name_not_typename
 193 %type <tsym> typename
 194
 195 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
 196    but which would parse as a valid number in the current input radix.
 197    E.g. "c" when input_radix==16.  Depending on the parse, it will be
 198    turned into a name or into a number.  */
 199
 200 %token <ssym> NAME_OR_INT
 201
 202 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
 203 %token TEMPLATE
 204 %token ERROR
 205
 206 /* Special type cases, put in to allow the parser to distinguish different
 207    legal basetypes.  */
 208 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
 209
 210 %token <voidval> VARIABLE
 211
 212 %token <opcode> ASSIGN_MODIFY
 213
 214 /* C++ */
 215 %token TRUEKEYWORD
 216 %token FALSEKEYWORD
 217
 218
 219 %left ','
 220 %left ABOVE_COMMA
 221 %right '=' ASSIGN_MODIFY
 222 %right '?'
 223 %left OROR
 224 %left ANDAND
 225 %left '|'
 226 %left '^'
 227 %left '&'
 228 %left EQUAL NOTEQUAL
 229 %left '<' '>' LEQ GEQ
 230 %left LSH RSH
 231 %left '@'
 232 %left '+' '-'
 233 %left '*' '/' '%'
 234 %right UNARY INCREMENT DECREMENT
 235 %right ARROW '.' '[' '('
 236 %token <ssym> BLOCKNAME
 237 %token <bval> FILENAME
 238 %type <bval> block
 239 %left COLONCOLON
 240
 241 \f
 242 %%
 243
 244 start   :       exp1
 245         |       type_exp
 246         ;
 247
 248 type_exp:       type
 249                         { write_exp_elt_opcode(OP_TYPE);
 250                           write_exp_elt_type($1);
 251                           write_exp_elt_opcode(OP_TYPE);}
 252         ;
 253
 254 /* Expressions, including the comma operator.  */
 255 exp1    :       exp
 256         |       exp1 ',' exp
 257                         { write_exp_elt_opcode (BINOP_COMMA); }
 258         ;
 259
 260 /* Expressions, not including the comma operator.  */
 261 exp     :       '*' exp    %prec UNARY
 262                         { write_exp_elt_opcode (UNOP_IND); }
 263         ;
 264
 265 exp     :       '&' exp    %prec UNARY
 266                         { write_exp_elt_opcode (UNOP_ADDR); }
 267         ;
 268
 269 exp     :       '-' exp    %prec UNARY
 270                         { write_exp_elt_opcode (UNOP_NEG); }
 271         ;
 272
 273 exp     :       '+' exp    %prec UNARY
 274                         { write_exp_elt_opcode (UNOP_PLUS); }
 275         ;
 276
 277 exp     :       '!' exp    %prec UNARY
 278                         { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
 279         ;
 280
 281 exp     :       '~' exp    %prec UNARY
 282                         { write_exp_elt_opcode (UNOP_COMPLEMENT); }
 283         ;
 284
 285 exp     :       INCREMENT exp    %prec UNARY
 286                         { write_exp_elt_opcode (UNOP_PREINCREMENT); }
 287         ;
 288
 289 exp     :       DECREMENT exp    %prec UNARY
 290                         { write_exp_elt_opcode (UNOP_PREDECREMENT); }
 291         ;
 292
 293 exp     :       exp INCREMENT    %prec UNARY
 294                         { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
 295         ;
 296
 297 exp     :       exp DECREMENT    %prec UNARY
 298                         { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
 299         ;
 300
 301 exp     :       SIZEOF exp       %prec UNARY
 302                         { write_exp_elt_opcode (UNOP_SIZEOF); }
 303         ;
 304
 305 exp     :       exp ARROW name
 306                         { write_exp_elt_opcode (STRUCTOP_PTR);
 307                           write_exp_string ($3);
 308                           write_exp_elt_opcode (STRUCTOP_PTR); }
 309         ;
 310
 311 exp     :       exp ARROW name COMPLETE
 312                         { mark_struct_expression ();
 313                           write_exp_elt_opcode (STRUCTOP_PTR);
 314                           write_exp_string ($3);
 315                           write_exp_elt_opcode (STRUCTOP_PTR); }
 316         ;
 317
 318 exp     :       exp ARROW COMPLETE
 319                         { struct stoken s;
 320                           mark_struct_expression ();
 321                           write_exp_elt_opcode (STRUCTOP_PTR);
 322                           s.ptr = "";
 323                           s.length = 0;
 324                           write_exp_string (s);
 325                           write_exp_elt_opcode (STRUCTOP_PTR); }
 326         ;
 327
 328 exp     :       exp ARROW qualified_name
 329                         { /* exp->type::name becomes exp->*(&type::name) */
 330                           /* Note: this doesn't work if name is a
 331                              static member!  FIXME */
 332                           write_exp_elt_opcode (UNOP_ADDR);
 333                           write_exp_elt_opcode (STRUCTOP_MPTR); }
 334         ;
 335
 336 exp     :       exp ARROW '*' exp
 337                         { write_exp_elt_opcode (STRUCTOP_MPTR); }
 338         ;
 339
 340 exp     :       exp '.' name
 341                         { write_exp_elt_opcode (STRUCTOP_STRUCT);
 342                           write_exp_string ($3);
 343                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 344         ;
 345
 346 exp     :       exp '.' name COMPLETE
 347                         { mark_struct_expression ();
 348                           write_exp_elt_opcode (STRUCTOP_STRUCT);
 349                           write_exp_string ($3);
 350                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 351         ;
 352
 353 exp     :       exp '.' COMPLETE
 354                         { struct stoken s;
 355                           mark_struct_expression ();
 356                           write_exp_elt_opcode (STRUCTOP_STRUCT);
 357                           s.ptr = "";
 358                           s.length = 0;
 359                           write_exp_string (s);
 360                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 361         ;
 362
 363 exp     :       exp '.' qualified_name
 364                         { /* exp.type::name becomes exp.*(&type::name) */
 365                           /* Note: this doesn't work if name is a
 366                              static member!  FIXME */
 367                           write_exp_elt_opcode (UNOP_ADDR);
 368                           write_exp_elt_opcode (STRUCTOP_MEMBER); }
 369         ;
 370
 371 exp     :       exp '.' '*' exp
 372                         { write_exp_elt_opcode (STRUCTOP_MEMBER); }
 373         ;
 374
 375 exp     :       exp '[' exp1 ']'
 376                         { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
 377         ;
 378
 379 exp     :       exp '('
 380                         /* This is to save the value of arglist_len
 381                            being accumulated by an outer function call.  */
 382                         { start_arglist (); }
 383                 arglist ')'     %prec ARROW
 384                         { write_exp_elt_opcode (OP_FUNCALL);
 385                           write_exp_elt_longcst ((LONGEST) end_arglist ());
 386                           write_exp_elt_opcode (OP_FUNCALL); }
 387         ;
 388
 389 lcurly  :       '{'
 390                         { start_arglist (); }
 391         ;
 392
 393 arglist :
 394         ;
 395
 396 arglist :       exp
 397                         { arglist_len = 1; }
 398         ;
 399
 400 arglist :       arglist ',' exp   %prec ABOVE_COMMA
 401                         { arglist_len++; }
 402         ;
 403
 404 rcurly  :       '}'
 405                         { $$ = end_arglist () - 1; }
 406         ;
 407 exp     :       lcurly arglist rcurly   %prec ARROW
 408                         { write_exp_elt_opcode (OP_ARRAY);
 409                           write_exp_elt_longcst ((LONGEST) 0);
 410                           write_exp_elt_longcst ((LONGEST) $3);
 411                           write_exp_elt_opcode (OP_ARRAY); }
 412         ;
 413
 414 exp     :       lcurly type rcurly exp  %prec UNARY
 415                         { write_exp_elt_opcode (UNOP_MEMVAL);
 416                           write_exp_elt_type ($2);
 417                           write_exp_elt_opcode (UNOP_MEMVAL); }
 418         ;
 419
 420 exp     :       '(' type ')' exp  %prec UNARY
 421                         { write_exp_elt_opcode (UNOP_CAST);
 422                           write_exp_elt_type ($2);
 423                           write_exp_elt_opcode (UNOP_CAST); }
 424         ;
 425
 426 exp     :       '(' exp1 ')'
 427                         { }
 428         ;
 429
 430 /* Binary operators in order of decreasing precedence.  */
 431
 432 exp     :       exp '@' exp
 433                         { write_exp_elt_opcode (BINOP_REPEAT); }
 434         ;
 435
 436 exp     :       exp '*' exp
 437                         { write_exp_elt_opcode (BINOP_MUL); }
 438         ;
 439
 440 exp     :       exp '/' exp
 441                         { write_exp_elt_opcode (BINOP_DIV); }
 442         ;
 443
 444 exp     :       exp '%' exp
 445                         { write_exp_elt_opcode (BINOP_REM); }
 446         ;
 447
 448 exp     :       exp '+' exp
 449                         { write_exp_elt_opcode (BINOP_ADD); }
 450         ;
 451
 452 exp     :       exp '-' exp
 453                         { write_exp_elt_opcode (BINOP_SUB); }
 454         ;
 455
 456 exp     :       exp LSH exp
 457                         { write_exp_elt_opcode (BINOP_LSH); }
 458         ;
 459
 460 exp     :       exp RSH exp
 461                         { write_exp_elt_opcode (BINOP_RSH); }
 462         ;
 463
 464 exp     :       exp EQUAL exp
 465                         { write_exp_elt_opcode (BINOP_EQUAL); }
 466         ;
 467
 468 exp     :       exp NOTEQUAL exp
 469                         { write_exp_elt_opcode (BINOP_NOTEQUAL); }
 470         ;
 471
 472 exp     :       exp LEQ exp
 473                         { write_exp_elt_opcode (BINOP_LEQ); }
 474         ;
 475
 476 exp     :       exp GEQ exp
 477                         { write_exp_elt_opcode (BINOP_GEQ); }
 478         ;
 479
 480 exp     :       exp '<' exp
 481                         { write_exp_elt_opcode (BINOP_LESS); }
 482         ;
 483
 484 exp     :       exp '>' exp
 485                         { write_exp_elt_opcode (BINOP_GTR); }
 486         ;
 487
 488 exp     :       exp '&' exp
 489                         { write_exp_elt_opcode (BINOP_BITWISE_AND); }
 490         ;
 491
 492 exp     :       exp '^' exp
 493                         { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
 494         ;
 495
 496 exp     :       exp '|' exp
 497                         { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
 498         ;
 499
 500 exp     :       exp ANDAND exp
 501                         { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
 502         ;
 503
 504 exp     :       exp OROR exp
 505                         { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
 506         ;
 507
 508 exp     :       exp '?' exp ':' exp     %prec '?'
 509                         { write_exp_elt_opcode (TERNOP_COND); }
 510         ;
 511
 512 exp     :       exp '=' exp
 513                         { write_exp_elt_opcode (BINOP_ASSIGN); }
 514         ;
 515
 516 exp     :       exp ASSIGN_MODIFY exp
 517                         { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
 518                           write_exp_elt_opcode ($2);
 519                           write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
 520         ;
 521
 522 exp     :       INT
 523                         { write_exp_elt_opcode (OP_LONG);
 524                           write_exp_elt_type ($1.type);
 525                           write_exp_elt_longcst ((LONGEST)($1.val));
 526                           write_exp_elt_opcode (OP_LONG); }
 527         ;
 528
 529 exp     :       CHAR
 530                         {
 531                           struct stoken_vector vec;
 532                           vec.len = 1;
 533                           vec.tokens = &$1;
 534                           write_exp_string_vector ($1.type, &vec);
 535                         }
 536         ;
 537
 538 exp     :       NAME_OR_INT
 539                         { YYSTYPE val;
 540                           parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
 541                           write_exp_elt_opcode (OP_LONG);
 542                           write_exp_elt_type (val.typed_val_int.type);
 543                           write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
 544                           write_exp_elt_opcode (OP_LONG);
 545                         }
 546         ;
 547
 548
 549 exp     :       FLOAT
 550                         { write_exp_elt_opcode (OP_DOUBLE);
 551                           write_exp_elt_type ($1.type);
 552                           write_exp_elt_dblcst ($1.dval);
 553                           write_exp_elt_opcode (OP_DOUBLE); }
 554         ;
 555
 556 exp     :       DECFLOAT
 557                         { write_exp_elt_opcode (OP_DECFLOAT);
 558                           write_exp_elt_type ($1.type);
 559                           write_exp_elt_decfloatcst ($1.val);
 560                           write_exp_elt_opcode (OP_DECFLOAT); }
 561         ;
 562
 563 exp     :       variable
 564         ;
 565
 566 exp     :       VARIABLE
 567                         /* Already written by write_dollar_variable. */
 568         ;
 569
 570 exp     :       SIZEOF '(' type ')'     %prec UNARY
 571                         { write_exp_elt_opcode (OP_LONG);
 572                           write_exp_elt_type (parse_type->builtin_int);
 573                           CHECK_TYPEDEF ($3);
 574                           write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
 575                           write_exp_elt_opcode (OP_LONG); }
 576         ;
 577
 578 string_exp:
 579                 STRING
 580                         {
 581                           /* We copy the string here, and not in the
 582                              lexer, to guarantee that we do not leak a
 583                              string.  Note that we follow the
 584                              NUL-termination convention of the
 585                              lexer.  */
 586                           struct typed_stoken *vec = XNEW (struct typed_stoken);
 587                           $$.len = 1;
 588                           $$.tokens = vec;
 589
 590                           vec->type = $1.type;
 591                           vec->length = $1.length;
 592                           vec->ptr = malloc ($1.length + 1);
 593                           memcpy (vec->ptr, $1.ptr, $1.length + 1);
 594                         }
 595
 596         |       string_exp STRING
 597                         {
 598                           /* Note that we NUL-terminate here, but just
 599                              for convenience.  */
 600                           char *p;
 601                           ++$$.len;
 602                           $$.tokens = realloc ($$.tokens,
 603                                                $$.len * sizeof (struct typed_stoken));
 604
 605                           p = malloc ($2.length + 1);
 606                           memcpy (p, $2.ptr, $2.length + 1);
 607
 608                           $$.tokens[$$.len - 1].type = $2.type;
 609                           $$.tokens[$$.len - 1].length = $2.length;
 610                           $$.tokens[$$.len - 1].ptr = p;
 611                         }
 612                 ;
 613
 614 exp     :       string_exp
 615                         {
 616                           int i;
 617                           enum c_string_type type = C_STRING;
 618
 619                           for (i = 0; i < $1.len; ++i)
 620                             {
 621                               switch ($1.tokens[i].type)
 622                                 {
 623                                 case C_STRING:
 624                                   break;
 625                                 case C_WIDE_STRING:
 626                                 case C_STRING_16:
 627                                 case C_STRING_32:
 628                                   if (type != C_STRING
 629                                       && type != $1.tokens[i].type)
 630                                     error ("Undefined string concatenation.");
 631                                   type = $1.tokens[i].type;
 632                                   break;
 633                                 default:
 634                                   /* internal error */
 635                                   internal_error (__FILE__, __LINE__,
 636                                                   "unrecognized type in string concatenation");
 637                                 }
 638                             }
 639
 640                           write_exp_string_vector (type, &$1);
 641                           for (i = 0; i < $1.len; ++i)
 642                             free ($1.tokens[i].ptr);
 643                           free ($1.tokens);
 644                         }
 645         ;
 646
 647 /* C++.  */
 648 exp     :       TRUEKEYWORD
 649                         { write_exp_elt_opcode (OP_LONG);
 650                           write_exp_elt_type (parse_type->builtin_bool);
 651                           write_exp_elt_longcst ((LONGEST) 1);
 652                           write_exp_elt_opcode (OP_LONG); }
 653         ;
 654
 655 exp     :       FALSEKEYWORD
 656                         { write_exp_elt_opcode (OP_LONG);
 657                           write_exp_elt_type (parse_type->builtin_bool);
 658                           write_exp_elt_longcst ((LONGEST) 0);
 659                           write_exp_elt_opcode (OP_LONG); }
 660         ;
 661
 662 /* end of C++.  */
 663
 664 block   :       BLOCKNAME
 665                         {
 666                           if ($1.sym)
 667                             $$ = SYMBOL_BLOCK_VALUE ($1.sym);
 668                           else
 669                             error ("No file or function \"%s\".",
 670                                    copy_name ($1.stoken));
 671                         }
 672         |       FILENAME
 673                         {
 674                           $$ = $1;
 675                         }
 676         ;
 677
 678 block   :       block COLONCOLON name
 679                         { struct symbol *tem
 680                             = lookup_symbol (copy_name ($3), $1,
 681                                              VAR_DOMAIN, (int *) NULL);
 682                           if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
 683                             error ("No function \"%s\" in specified context.",
 684                                    copy_name ($3));
 685                           $$ = SYMBOL_BLOCK_VALUE (tem); }
 686         ;
 687
 688 variable:       block COLONCOLON name
 689                         { struct symbol *sym;
 690                           sym = lookup_symbol (copy_name ($3), $1,
 691                                                VAR_DOMAIN, (int *) NULL);
 692                           if (sym == 0)
 693                             error ("No symbol \"%s\" in specified context.",
 694                                    copy_name ($3));
 695
 696                           write_exp_elt_opcode (OP_VAR_VALUE);
 697                           /* block_found is set by lookup_symbol.  */
 698                           write_exp_elt_block (block_found);
 699                           write_exp_elt_sym (sym);
 700                           write_exp_elt_opcode (OP_VAR_VALUE); }
 701         ;
 702
 703 qualified_name: typebase COLONCOLON name
 704                         {
 705                           struct type *type = $1;
 706                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 707                               && TYPE_CODE (type) != TYPE_CODE_UNION
 708                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
 709                             error ("`%s' is not defined as an aggregate type.",
 710                                    TYPE_NAME (type));
 711
 712                           write_exp_elt_opcode (OP_SCOPE);
 713                           write_exp_elt_type (type);
 714                           write_exp_string ($3);
 715                           write_exp_elt_opcode (OP_SCOPE);
 716                         }
 717         |       typebase COLONCOLON '~' name
 718                         {
 719                           struct type *type = $1;
 720                           struct stoken tmp_token;
 721                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 722                               && TYPE_CODE (type) != TYPE_CODE_UNION
 723                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
 724                             error ("`%s' is not defined as an aggregate type.",
 725                                    TYPE_NAME (type));
 726
 727                           tmp_token.ptr = (char*) alloca ($4.length + 2);
 728                           tmp_token.length = $4.length + 1;
 729                           tmp_token.ptr[0] = '~';
 730                           memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
 731                           tmp_token.ptr[tmp_token.length] = 0;
 732
 733                           /* Check for valid destructor name.  */
 734                           destructor_name_p (tmp_token.ptr, type);
 735                           write_exp_elt_opcode (OP_SCOPE);
 736                           write_exp_elt_type (type);
 737                           write_exp_string (tmp_token);
 738                           write_exp_elt_opcode (OP_SCOPE);
 739                         }
 740         ;
 741
 742 variable:       qualified_name
 743         |       COLONCOLON name
 744                         {
 745                           char *name = copy_name ($2);
 746                           struct symbol *sym;
 747                           struct minimal_symbol *msymbol;
 748
 749                           sym =
 750                             lookup_symbol (name, (const struct block *) NULL,
 751                                            VAR_DOMAIN, (int *) NULL);
 752                           if (sym)
 753                             {
 754                               write_exp_elt_opcode (OP_VAR_VALUE);
 755                               write_exp_elt_block (NULL);
 756                               write_exp_elt_sym (sym);
 757                               write_exp_elt_opcode (OP_VAR_VALUE);
 758                               break;
 759                             }
 760
 761                           msymbol = lookup_minimal_symbol (name, NULL, NULL);
 762                           if (msymbol != NULL)
 763                             write_exp_msymbol (msymbol);
 764                           else if (!have_full_symbols () && !have_partial_symbols ())
 765                             error ("No symbol table is loaded.  Use the \"file\" command.");
 766                           else
 767                             error ("No symbol \"%s\" in current context.", name);
 768                         }
 769         ;
 770
 771 variable:       name_not_typename
 772                         { struct symbol *sym = $1.sym;
 773
 774                           if (sym)
 775                             {
 776                               if (symbol_read_needs_frame (sym))
 777                                 {
 778                                   if (innermost_block == 0 ||
 779                                       contained_in (block_found,
 780                                                     innermost_block))
 781                                     innermost_block = block_found;
 782                                 }
 783
 784                               write_exp_elt_opcode (OP_VAR_VALUE);
 785                               /* We want to use the selected frame, not
 786                                  another more inner frame which happens to
 787                                  be in the same block.  */
 788                               write_exp_elt_block (NULL);
 789                               write_exp_elt_sym (sym);
 790                               write_exp_elt_opcode (OP_VAR_VALUE);
 791                             }
 792                           else if ($1.is_a_field_of_this)
 793                             {
 794                               /* C++: it hangs off of `this'.  Must
 795                                  not inadvertently convert from a method call
 796                                  to data ref.  */
 797                               if (innermost_block == 0 ||
 798                                   contained_in (block_found, innermost_block))
 799                                 innermost_block = block_found;
 800                               write_exp_elt_opcode (OP_THIS);
 801                               write_exp_elt_opcode (OP_THIS);
 802                               write_exp_elt_opcode (STRUCTOP_PTR);
 803                               write_exp_string ($1.stoken);
 804                               write_exp_elt_opcode (STRUCTOP_PTR);
 805                             }
 806                           else
 807                             {
 808                               struct minimal_symbol *msymbol;
 809                               char *arg = copy_name ($1.stoken);
 810
 811                               msymbol =
 812                                 lookup_minimal_symbol (arg, NULL, NULL);
 813                               if (msymbol != NULL)
 814                                 write_exp_msymbol (msymbol);
 815                               else if (!have_full_symbols () && !have_partial_symbols ())
 816                                 error ("No symbol table is loaded.  Use the \"file\" command.");
 817                               else
 818                                 error ("No symbol \"%s\" in current context.",
 819                                        copy_name ($1.stoken));
 820                             }
 821                         }
 822         ;
 823
 824 space_identifier : '@' NAME
 825                 { push_type_address_space (copy_name ($2.stoken));
 826                   push_type (tp_space_identifier);
 827                 }
 828         ;
 829
 830 const_or_volatile: const_or_volatile_noopt
 831         |
 832         ;
 833
 834 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
 835         ;
 836
 837 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
 838         | const_or_volatile_noopt
 839         ;
 840
 841 const_or_volatile_or_space_identifier:
 842                 const_or_volatile_or_space_identifier_noopt
 843         |
 844         ;
 845
 846 abs_decl:       '*'
 847                         { push_type (tp_pointer); $$ = 0; }
 848         |       '*' abs_decl
 849                         { push_type (tp_pointer); $$ = $2; }
 850         |       '&'
 851                         { push_type (tp_reference); $$ = 0; }
 852         |       '&' abs_decl
 853                         { push_type (tp_reference); $$ = $2; }
 854         |       direct_abs_decl
 855         ;
 856
 857 direct_abs_decl: '(' abs_decl ')'
 858                         { $$ = $2; }
 859         |       direct_abs_decl array_mod
 860                         {
 861                           push_type_int ($2);
 862                           push_type (tp_array);
 863                         }
 864         |       array_mod
 865                         {
 866                           push_type_int ($1);
 867                           push_type (tp_array);
 868                           $$ = 0;
 869                         }
 870
 871         |       direct_abs_decl func_mod
 872                         { push_type (tp_function); }
 873         |       func_mod
 874                         { push_type (tp_function); }
 875         ;
 876
 877 array_mod:      '[' ']'
 878                         { $$ = -1; }
 879         |       '[' INT ']'
 880                         { $$ = $2.val; }
 881         ;
 882
 883 func_mod:       '(' ')'
 884                         { $$ = 0; }
 885         |       '(' nonempty_typelist ')'
 886                         { free ($2); $$ = 0; }
 887         ;
 888
 889 /* We used to try to recognize pointer to member types here, but
 890    that didn't work (shift/reduce conflicts meant that these rules never
 891    got executed).  The problem is that
 892      int (foo::bar::baz::bizzle)
 893    is a function type but
 894      int (foo::bar::baz::bizzle::*)
 895    is a pointer to member type.  Stroustrup loses again!  */
 896
 897 type    :       ptype
 898         ;
 899
 900 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
 901         :       TYPENAME
 902                         { $$ = $1.type; }
 903         |       INT_KEYWORD
 904                         { $$ = parse_type->builtin_int; }
 905         |       LONG
 906                         { $$ = parse_type->builtin_long; }
 907         |       SHORT
 908                         { $$ = parse_type->builtin_short; }
 909         |       LONG INT_KEYWORD
 910                         { $$ = parse_type->builtin_long; }
 911         |       LONG SIGNED_KEYWORD INT_KEYWORD
 912                         { $$ = parse_type->builtin_long; }
 913         |       LONG SIGNED_KEYWORD
 914                         { $$ = parse_type->builtin_long; }
 915         |       SIGNED_KEYWORD LONG INT_KEYWORD
 916                         { $$ = parse_type->builtin_long; }
 917         |       UNSIGNED LONG INT_KEYWORD
 918                         { $$ = parse_type->builtin_unsigned_long; }
 919         |       LONG UNSIGNED INT_KEYWORD
 920                         { $$ = parse_type->builtin_unsigned_long; }
 921         |       LONG UNSIGNED
 922                         { $$ = parse_type->builtin_unsigned_long; }
 923         |       LONG LONG
 924                         { $$ = parse_type->builtin_long_long; }
 925         |       LONG LONG INT_KEYWORD
 926                         { $$ = parse_type->builtin_long_long; }
 927         |       LONG LONG SIGNED_KEYWORD INT_KEYWORD
 928                         { $$ = parse_type->builtin_long_long; }
 929         |       LONG LONG SIGNED_KEYWORD
 930                         { $$ = parse_type->builtin_long_long; }
 931         |       SIGNED_KEYWORD LONG LONG
 932                         { $$ = parse_type->builtin_long_long; }
 933         |       SIGNED_KEYWORD LONG LONG INT_KEYWORD
 934                         { $$ = parse_type->builtin_long_long; }
 935         |       UNSIGNED LONG LONG
 936                         { $$ = parse_type->builtin_unsigned_long_long; }
 937         |       UNSIGNED LONG LONG INT_KEYWORD
 938                         { $$ = parse_type->builtin_unsigned_long_long; }
 939         |       LONG LONG UNSIGNED
 940                         { $$ = parse_type->builtin_unsigned_long_long; }
 941         |       LONG LONG UNSIGNED INT_KEYWORD
 942                         { $$ = parse_type->builtin_unsigned_long_long; }
 943         |       SHORT INT_KEYWORD
 944                         { $$ = parse_type->builtin_short; }
 945         |       SHORT SIGNED_KEYWORD INT_KEYWORD
 946                         { $$ = parse_type->builtin_short; }
 947         |       SHORT SIGNED_KEYWORD
 948                         { $$ = parse_type->builtin_short; }
 949         |       UNSIGNED SHORT INT_KEYWORD
 950                         { $$ = parse_type->builtin_unsigned_short; }
 951         |       SHORT UNSIGNED
 952                         { $$ = parse_type->builtin_unsigned_short; }
 953         |       SHORT UNSIGNED INT_KEYWORD
 954                         { $$ = parse_type->builtin_unsigned_short; }
 955         |       DOUBLE_KEYWORD
 956                         { $$ = parse_type->builtin_double; }
 957         |       LONG DOUBLE_KEYWORD
 958                         { $$ = parse_type->builtin_long_double; }
 959         |       STRUCT name
 960                         { $$ = lookup_struct (copy_name ($2),
 961                                               expression_context_block); }
 962         |       CLASS name
 963                         { $$ = lookup_struct (copy_name ($2),
 964                                               expression_context_block); }
 965         |       UNION name
 966                         { $$ = lookup_union (copy_name ($2),
 967                                              expression_context_block); }
 968         |       ENUM name
 969                         { $$ = lookup_enum (copy_name ($2),
 970                                             expression_context_block); }
 971         |       UNSIGNED typename
 972                         { $$ = lookup_unsigned_typename (parse_language,
 973                                                          parse_gdbarch,
 974                                                          TYPE_NAME($2.type)); }
 975         |       UNSIGNED
 976                         { $$ = parse_type->builtin_unsigned_int; }
 977         |       SIGNED_KEYWORD typename
 978                         { $$ = lookup_signed_typename (parse_language,
 979                                                        parse_gdbarch,
 980                                                        TYPE_NAME($2.type)); }
 981         |       SIGNED_KEYWORD
 982                         { $$ = parse_type->builtin_int; }
 983                 /* It appears that this rule for templates is never
 984                    reduced; template recognition happens by lookahead
 985                    in the token processing code in yylex. */
 986         |       TEMPLATE name '<' type '>'
 987                         { $$ = lookup_template_type(copy_name($2), $4,
 988                                                     expression_context_block);
 989                         }
 990         | const_or_volatile_or_space_identifier_noopt typebase
 991                         { $$ = follow_types ($2); }
 992         | typebase const_or_volatile_or_space_identifier_noopt
 993                         { $$ = follow_types ($1); }
 994         | qualified_type
 995         ;
 996
 997 /* FIXME: carlton/2003-09-25: This next bit leads to lots of
 998    reduce-reduce conflicts, because the parser doesn't know whether or
 999    not to use qualified_name or qualified_type: the rules are
1000    identical.  If the parser is parsing 'A::B::x', then, when it sees
1001    the second '::', it knows that the expression to the left of it has
1002    to be a type, so it uses qualified_type.  But if it is parsing just
1003    'A::B', then it doesn't have any way of knowing which rule to use,
1004    so there's a reduce-reduce conflict; it picks qualified_name, since
1005    that occurs earlier in this file than qualified_type.
1006
1007    There's no good way to fix this with the grammar as it stands; as
1008    far as I can tell, some of the problems arise from ambiguities that
1009    GDB introduces ('start' can be either an expression or a type), but
1010    some of it is inherent to the nature of C++ (you want to treat the
1011    input "(FOO)" fairly differently depending on whether FOO is an
1012    expression or a type, and if FOO is a complex expression, this can
1013    be hard to determine at the right time).  Fortunately, it works
1014    pretty well in most cases.  For example, if you do 'ptype A::B',
1015    where A::B is a nested type, then the parser will mistakenly
1016    misidentify it as an expression; but evaluate_subexp will get
1017    called with 'noside' set to EVAL_AVOID_SIDE_EFFECTS, and everything
1018    will work out anyways.  But there are situations where the parser
1019    will get confused: the most common one that I've run into is when
1020    you want to do
1021
1022      print *((A::B *) x)"
1023
1024    where the parser doesn't realize that A::B has to be a type until
1025    it hits the first right paren, at which point it's too late.  (The
1026    workaround is to type "print *(('A::B' *) x)" instead.)  (And
1027    another solution is to fix our symbol-handling code so that the
1028    user never wants to type something like that in the first place,
1029    because we get all the types right without the user's help!)
1030
1031    Perhaps we could fix this by making the lexer smarter.  Some of
1032    this functionality used to be in the lexer, but in a way that
1033    worked even less well than the current solution: that attempt
1034    involved having the parser sometimes handle '::' and having the
1035    lexer sometimes handle it, and without a clear division of
1036    responsibility, it quickly degenerated into a big mess.  Probably
1037    the eventual correct solution will give more of a role to the lexer
1038    (ideally via code that is shared between the lexer and
1039    decode_line_1), but I'm not holding my breath waiting for somebody
1040    to get around to cleaning this up...  */
1041
1042 qualified_type: typebase COLONCOLON name
1043                 {
1044                   struct type *type = $1;
1045                   struct type *new_type;
1046                   char *ncopy = alloca ($3.length + 1);
1047
1048                   memcpy (ncopy, $3.ptr, $3.length);
1049                   ncopy[$3.length] = '\0';
1050
1051                   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1052                       && TYPE_CODE (type) != TYPE_CODE_UNION
1053                       && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
1054                     error ("`%s' is not defined as an aggregate type.",
1055                            TYPE_NAME (type));
1056
1057                   new_type = cp_lookup_nested_type (type, ncopy,
1058                                                     expression_context_block);
1059                   if (new_type == NULL)
1060                     error ("No type \"%s\" within class or namespace \"%s\".",
1061                            ncopy, TYPE_NAME (type));
1062
1063                   $$ = new_type;
1064                 }
1065         ;
1066
1067 typename:       TYPENAME
1068         |       INT_KEYWORD
1069                 {
1070                   $$.stoken.ptr = "int";
1071                   $$.stoken.length = 3;
1072                   $$.type = parse_type->builtin_int;
1073                 }
1074         |       LONG
1075                 {
1076                   $$.stoken.ptr = "long";
1077                   $$.stoken.length = 4;
1078                   $$.type = parse_type->builtin_long;
1079                 }
1080         |       SHORT
1081                 {
1082                   $$.stoken.ptr = "short";
1083                   $$.stoken.length = 5;
1084                   $$.type = parse_type->builtin_short;
1085                 }
1086         ;
1087
1088 nonempty_typelist
1089         :       type
1090                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
1091                   $<ivec>$[0] = 1;      /* Number of types in vector */
1092                   $$[1] = $1;
1093                 }
1094         |       nonempty_typelist ',' type
1095                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
1096                   $$ = (struct type **) realloc ((char *) $1, len);
1097                   $$[$<ivec>$[0]] = $3;
1098                 }
1099         ;
1100
1101 ptype   :       typebase
1102         |       ptype const_or_volatile_or_space_identifier abs_decl const_or_volatile_or_space_identifier
1103                 { $$ = follow_types ($1); }
1104         ;
1105
1106 const_and_volatile:     CONST_KEYWORD VOLATILE_KEYWORD
1107         |               VOLATILE_KEYWORD CONST_KEYWORD
1108         ;
1109
1110 const_or_volatile_noopt:        const_and_volatile
1111                         { push_type (tp_const);
1112                           push_type (tp_volatile);
1113                         }
1114         |               CONST_KEYWORD
1115                         { push_type (tp_const); }
1116         |               VOLATILE_KEYWORD
1117                         { push_type (tp_volatile); }
1118         ;
1119
1120 name    :       NAME { $$ = $1.stoken; }
1121         |       BLOCKNAME { $$ = $1.stoken; }
1122         |       TYPENAME { $$ = $1.stoken; }
1123         |       NAME_OR_INT  { $$ = $1.stoken; }
1124         ;
1125
1126 name_not_typename :     NAME
1127         |       BLOCKNAME
1128 /* These would be useful if name_not_typename was useful, but it is just
1129    a fake for "variable", so these cause reduce/reduce conflicts because
1130    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1131    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
1132    context where only a name could occur, this might be useful.
1133         |       NAME_OR_INT
1134  */
1135         ;
1136
1137 %%
1138
1139 /* Take care of parsing a number (anything that starts with a digit).
1140    Set yylval and return the token type; update lexptr.
1141    LEN is the number of characters in it.  */
1142
1143 /*** Needs some error checking for the float case ***/
1144
1145 static int
1146 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
1147 {
1148   /* FIXME: Shouldn't these be unsigned?  We don't deal with negative values
1149      here, and we do kind of silly things like cast to unsigned.  */
1150   LONGEST n = 0;
1151   LONGEST prevn = 0;
1152   ULONGEST un;
1153
1154   int i = 0;
1155   int c;
1156   int base = input_radix;
1157   int unsigned_p = 0;
1158
1159   /* Number of "L" suffixes encountered.  */
1160   int long_p = 0;
1161
1162   /* We have found a "L" or "U" suffix.  */
1163   int found_suffix = 0;
1164
1165   ULONGEST high_bit;
1166   struct type *signed_type;
1167   struct type *unsigned_type;
1168
1169   if (parsed_float)
1170     {
1171       /* It's a float since it contains a point or an exponent.  */
1172       char *s;
1173       int num;  /* number of tokens scanned by scanf */
1174       char saved_char;
1175
1176       /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
1177          point.  Return DECFLOAT.  */
1178
1179       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1180         {
1181           p[len - 2] = '\0';
1182           putithere->typed_val_decfloat.type
1183             = parse_type->builtin_decfloat;
1184           decimal_from_string (putithere->typed_val_decfloat.val, 4, p);
1185           p[len - 2] = 'd';
1186           return DECFLOAT;
1187         }
1188
1189       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1190         {
1191           p[len - 2] = '\0';
1192           putithere->typed_val_decfloat.type
1193             = parse_type->builtin_decdouble;
1194           decimal_from_string (putithere->typed_val_decfloat.val, 8, p);
1195           p[len - 2] = 'd';
1196           return DECFLOAT;
1197         }
1198
1199       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1200         {
1201           p[len - 2] = '\0';
1202           putithere->typed_val_decfloat.type
1203             = parse_type->builtin_declong;
1204           decimal_from_string (putithere->typed_val_decfloat.val, 16, p);
1205           p[len - 2] = 'd';
1206           return DECFLOAT;
1207         }
1208
1209       s = malloc (len);
1210       saved_char = p[len];
1211       p[len] = 0;       /* null-terminate the token */
1212       num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%s",
1213                     &putithere->typed_val_float.dval, s);
1214       p[len] = saved_char;      /* restore the input stream */
1215
1216       if (num == 1)
1217         putithere->typed_val_float.type =
1218           parse_type->builtin_double;
1219
1220       if (num == 2 )
1221         {
1222           /* See if it has any float suffix: 'f' for float, 'l' for long
1223              double.  */
1224           if (!strcasecmp (s, "f"))
1225             putithere->typed_val_float.type =
1226               parse_type->builtin_float;
1227           else if (!strcasecmp (s, "l"))
1228             putithere->typed_val_float.type =
1229               parse_type->builtin_long_double;
1230           else
1231             {
1232               free (s);
1233               return ERROR;
1234             }
1235         }
1236
1237       free (s);
1238       return FLOAT;
1239     }
1240
1241   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1242   if (p[0] == '0')
1243     switch (p[1])
1244       {
1245       case 'x':
1246       case 'X':
1247         if (len >= 3)
1248           {
1249             p += 2;
1250             base = 16;
1251             len -= 2;
1252           }
1253         break;
1254
1255       case 't':
1256       case 'T':
1257       case 'd':
1258       case 'D':
1259         if (len >= 3)
1260           {
1261             p += 2;
1262             base = 10;
1263             len -= 2;
1264           }
1265         break;
1266
1267       default:
1268         base = 8;
1269         break;
1270       }
1271
1272   while (len-- > 0)
1273     {
1274       c = *p++;
1275       if (c >= 'A' && c <= 'Z')
1276         c += 'a' - 'A';
1277       if (c != 'l' && c != 'u')
1278         n *= base;
1279       if (c >= '0' && c <= '9')
1280         {
1281           if (found_suffix)
1282             return ERROR;
1283           n += i = c - '0';
1284         }
1285       else
1286         {
1287           if (base > 10 && c >= 'a' && c <= 'f')
1288             {
1289               if (found_suffix)
1290                 return ERROR;
1291               n += i = c - 'a' + 10;
1292             }
1293           else if (c == 'l')
1294             {
1295               ++long_p;
1296               found_suffix = 1;
1297             }
1298           else if (c == 'u')
1299             {
1300               unsigned_p = 1;
1301               found_suffix = 1;
1302             }
1303           else
1304             return ERROR;       /* Char not a digit */
1305         }
1306       if (i >= base)
1307         return ERROR;           /* Invalid digit in this base */
1308
1309       /* Portably test for overflow (only works for nonzero values, so make
1310          a second check for zero).  FIXME: Can't we just make n and prevn
1311          unsigned and avoid this?  */
1312       if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1313         unsigned_p = 1;         /* Try something unsigned */
1314
1315       /* Portably test for unsigned overflow.
1316          FIXME: This check is wrong; for example it doesn't find overflow
1317          on 0x123456789 when LONGEST is 32 bits.  */
1318       if (c != 'l' && c != 'u' && n != 0)
1319         {
1320           if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1321             error ("Numeric constant too large.");
1322         }
1323       prevn = n;
1324     }
1325
1326   /* An integer constant is an int, a long, or a long long.  An L
1327      suffix forces it to be long; an LL suffix forces it to be long
1328      long.  If not forced to a larger size, it gets the first type of
1329      the above that it fits in.  To figure out whether it fits, we
1330      shift it right and see whether anything remains.  Note that we
1331      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1332      operation, because many compilers will warn about such a shift
1333      (which always produces a zero result).  Sometimes gdbarch_int_bit
1334      or gdbarch_long_bit will be that big, sometimes not.  To deal with
1335      the case where it is we just always shift the value more than
1336      once, with fewer bits each time.  */
1337
1338   un = (ULONGEST)n >> 2;
1339   if (long_p == 0
1340       && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
1341     {
1342       high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
1343
1344       /* A large decimal (not hex or octal) constant (between INT_MAX
1345          and UINT_MAX) is a long or unsigned long, according to ANSI,
1346          never an unsigned int, but this code treats it as unsigned
1347          int.  This probably should be fixed.  GCC gives a warning on
1348          such constants.  */
1349
1350       unsigned_type = parse_type->builtin_unsigned_int;
1351       signed_type = parse_type->builtin_int;
1352     }
1353   else if (long_p <= 1
1354            && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
1355     {
1356       high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
1357       unsigned_type = parse_type->builtin_unsigned_long;
1358       signed_type = parse_type->builtin_long;
1359     }
1360   else
1361     {
1362       int shift;
1363       if (sizeof (ULONGEST) * HOST_CHAR_BIT
1364           < gdbarch_long_long_bit (parse_gdbarch))
1365         /* A long long does not fit in a LONGEST.  */
1366         shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1367       else
1368         shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
1369       high_bit = (ULONGEST) 1 << shift;
1370       unsigned_type = parse_type->builtin_unsigned_long_long;
1371       signed_type = parse_type->builtin_long_long;
1372     }
1373
1374    putithere->typed_val_int.val = n;
1375
1376    /* If the high bit of the worked out type is set then this number
1377       has to be unsigned. */
1378
1379    if (unsigned_p || (n & high_bit))
1380      {
1381        putithere->typed_val_int.type = unsigned_type;
1382      }
1383    else
1384      {
1385        putithere->typed_val_int.type = signed_type;
1386      }
1387
1388    return INT;
1389 }
1390
1391 /* Temporary obstack used for holding strings.  */
1392 static struct obstack tempbuf;
1393 static int tempbuf_init;
1394
1395 /* Parse a C escape sequence.  The initial backslash of the sequence
1396    is at (*PTR)[-1].  *PTR will be updated to point to just after the
1397    last character of the sequence.  If OUTPUT is not NULL, the
1398    translated form of the escape sequence will be written there.  If
1399    OUTPUT is NULL, no output is written and the call will only affect
1400    *PTR.  If an escape sequence is expressed in target bytes, then the
1401    entire sequence will simply be copied to OUTPUT.  Return 1 if any
1402    character was emitted, 0 otherwise.  */
1403
1404 int
1405 c_parse_escape (char **ptr, struct obstack *output)
1406 {
1407   char *tokptr = *ptr;
1408   int result = 1;
1409
1410   /* Some escape sequences undergo character set conversion.  Those we
1411      translate here.  */
1412   switch (*tokptr)
1413     {
1414       /* Hex escapes do not undergo character set conversion, so keep
1415          the escape sequence for later.  */
1416     case 'x':
1417       if (output)
1418         obstack_grow_str (output, "\\x");
1419       ++tokptr;
1420       if (!isxdigit (*tokptr))
1421         error (_("\\x escape without a following hex digit"));
1422       while (isxdigit (*tokptr))
1423         {
1424           if (output)
1425             obstack_1grow (output, *tokptr);
1426           ++tokptr;
1427         }
1428       break;
1429
1430       /* Octal escapes do not undergo character set conversion, so
1431          keep the escape sequence for later.  */
1432     case '0':
1433     case '1':
1434     case '2':
1435     case '3':
1436     case '4':
1437     case '5':
1438     case '6':
1439     case '7':
1440       if (output)
1441         obstack_grow_str (output, "\\");
1442       while (isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9')
1443         {
1444           if (output)
1445             obstack_1grow (output, *tokptr);
1446           ++tokptr;
1447         }
1448       break;
1449
1450       /* We handle UCNs later.  We could handle them here, but that
1451          would mean a spurious error in the case where the UCN could
1452          be converted to the target charset but not the host
1453          charset.  */
1454     case 'u':
1455     case 'U':
1456       {
1457         char c = *tokptr;
1458         int i, len = c == 'U' ? 8 : 4;
1459         if (output)
1460           {
1461             obstack_1grow (output, '\\');
1462             obstack_1grow (output, *tokptr);
1463           }
1464         ++tokptr;
1465         if (!isxdigit (*tokptr))
1466           error (_("\\%c escape without a following hex digit"), c);
1467         for (i = 0; i < len && isxdigit (*tokptr); ++i)
1468           {
1469             if (output)
1470               obstack_1grow (output, *tokptr);
1471             ++tokptr;
1472           }
1473       }
1474       break;
1475
1476       /* We must pass backslash through so that it does not
1477          cause quoting during the second expansion.  */
1478     case '\\':
1479       if (output)
1480         obstack_grow_str (output, "\\\\");
1481       ++tokptr;
1482       break;
1483
1484       /* Escapes which undergo conversion.  */
1485     case 'a':
1486       if (output)
1487         obstack_1grow (output, '\a');
1488       ++tokptr;
1489       break;
1490     case 'b':
1491       if (output)
1492         obstack_1grow (output, '\b');
1493       ++tokptr;
1494       break;
1495     case 'f':
1496       if (output)
1497         obstack_1grow (output, '\f');
1498       ++tokptr;
1499       break;
1500     case 'n':
1501       if (output)
1502         obstack_1grow (output, '\n');
1503       ++tokptr;
1504       break;
1505     case 'r':
1506       if (output)
1507         obstack_1grow (output, '\r');
1508       ++tokptr;
1509       break;
1510     case 't':
1511       if (output)
1512         obstack_1grow (output, '\t');
1513       ++tokptr;
1514       break;
1515     case 'v':
1516       if (output)
1517         obstack_1grow (output, '\v');
1518       ++tokptr;
1519       break;
1520
1521       /* GCC extension.  */
1522     case 'e':
1523       if (output)
1524         obstack_1grow (output, HOST_ESCAPE_CHAR);
1525       ++tokptr;
1526       break;
1527
1528       /* Backslash-newline expands to nothing at all.  */
1529     case '\n':
1530       ++tokptr;
1531       result = 0;
1532       break;
1533
1534       /* A few escapes just expand to the character itself.  */
1535     case '\'':
1536     case '\"':
1537     case '?':
1538       /* GCC extensions.  */
1539     case '(':
1540     case '{':
1541     case '[':
1542     case '%':
1543       /* Unrecognized escapes turn into the character itself.  */
1544     default:
1545       if (output)
1546         obstack_1grow (output, *tokptr);
1547       ++tokptr;
1548       break;
1549     }
1550   *ptr = tokptr;
1551   return result;
1552 }
1553
1554 /* Parse a string or character literal from TOKPTR.  The string or
1555    character may be wide or unicode.  *OUTPTR is set to just after the
1556    end of the literal in the input string.  The resulting token is
1557    stored in VALUE.  This returns a token value, either STRING or
1558    CHAR, depending on what was parsed.  *HOST_CHARS is set to the
1559    number of host characters in the literal.  */
1560 static int
1561 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
1562                       int *host_chars)
1563 {
1564   int quote, i;
1565   enum c_string_type type;
1566
1567   /* Build the gdb internal form of the input string in tempbuf.  Note
1568      that the buffer is null byte terminated *only* for the
1569      convenience of debugging gdb itself and printing the buffer
1570      contents when the buffer contains no embedded nulls.  Gdb does
1571      not depend upon the buffer being null byte terminated, it uses
1572      the length string instead.  This allows gdb to handle C strings
1573      (as well as strings in other languages) with embedded null
1574      bytes */
1575
1576   if (!tempbuf_init)
1577     tempbuf_init = 1;
1578   else
1579     obstack_free (&tempbuf, NULL);
1580   obstack_init (&tempbuf);
1581
1582   /* Record the string type.  */
1583   if (*tokptr == 'L')
1584     {
1585       type = C_WIDE_STRING;
1586       ++tokptr;
1587     }
1588   else if (*tokptr == 'u')
1589     {
1590       type = C_STRING_16;
1591       ++tokptr;
1592     }
1593   else if (*tokptr == 'U')
1594     {
1595       type = C_STRING_32;
1596       ++tokptr;
1597     }
1598   else
1599     type = C_STRING;
1600
1601   /* Skip the quote.  */
1602   quote = *tokptr;
1603   if (quote == '\'')
1604     type |= C_CHAR;
1605   ++tokptr;
1606
1607   *host_chars = 0;
1608
1609   while (*tokptr)
1610     {
1611       char c = *tokptr;
1612       if (c == '\\')
1613         {
1614           ++tokptr;
1615           *host_chars += c_parse_escape (&tokptr, &tempbuf);
1616         }
1617       else if (c == quote)
1618         break;
1619       else
1620         {
1621           obstack_1grow (&tempbuf, c);
1622           ++tokptr;
1623           /* FIXME: this does the wrong thing with multi-byte host
1624              characters.  We could use mbrlen here, but that would
1625              make "set host-charset" a bit less useful.  */
1626           ++*host_chars;
1627         }
1628     }
1629
1630   if (*tokptr != quote)
1631     {
1632       if (quote == '"')
1633         error ("Unterminated string in expression.");
1634       else
1635         error ("Unmatched single quote.");
1636     }
1637   ++tokptr;
1638
1639   value->type = type;
1640   value->ptr = obstack_base (&tempbuf);
1641   value->length = obstack_object_size (&tempbuf);
1642
1643   *outptr = tokptr;
1644
1645   return quote == '"' ? STRING : CHAR;
1646 }
1647
1648 struct token
1649 {
1650   char *operator;
1651   int token;
1652   enum exp_opcode opcode;
1653   int cxx_only;
1654 };
1655
1656 static const struct token tokentab3[] =
1657   {
1658     {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
1659     {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0}
1660   };
1661
1662 static const struct token tokentab2[] =
1663   {
1664     {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
1665     {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
1666     {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
1667     {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
1668     {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
1669     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
1670     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
1671     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
1672     {"++", INCREMENT, BINOP_END, 0},
1673     {"--", DECREMENT, BINOP_END, 0},
1674     {"->", ARROW, BINOP_END, 0},
1675     {"&&", ANDAND, BINOP_END, 0},
1676     {"||", OROR, BINOP_END, 0},
1677     {"::", COLONCOLON, BINOP_END, 0},
1678     {"<<", LSH, BINOP_END, 0},
1679     {">>", RSH, BINOP_END, 0},
1680     {"==", EQUAL, BINOP_END, 0},
1681     {"!=", NOTEQUAL, BINOP_END, 0},
1682     {"<=", LEQ, BINOP_END, 0},
1683     {">=", GEQ, BINOP_END, 0}
1684   };
1685
1686 /* Identifier-like tokens.  */
1687 static const struct token ident_tokens[] =
1688   {
1689     {"unsigned", UNSIGNED, OP_NULL, 0},
1690     {"template", TEMPLATE, OP_NULL, 1},
1691     {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
1692     {"struct", STRUCT, OP_NULL, 0},
1693     {"signed", SIGNED_KEYWORD, OP_NULL, 0},
1694     {"sizeof", SIZEOF, OP_NULL, 0},
1695     {"double", DOUBLE_KEYWORD, OP_NULL, 0},
1696     {"false", FALSEKEYWORD, OP_NULL, 1},
1697     {"class", CLASS, OP_NULL, 1},
1698     {"union", UNION, OP_NULL, 0},
1699     {"short", SHORT, OP_NULL, 0},
1700     {"const", CONST_KEYWORD, OP_NULL, 0},
1701     {"enum", ENUM, OP_NULL, 0},
1702     {"long", LONG, OP_NULL, 0},
1703     {"true", TRUEKEYWORD, OP_NULL, 1},
1704     {"int", INT_KEYWORD, OP_NULL, 0},
1705
1706     {"and", ANDAND, BINOP_END, 1},
1707     {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, 1},
1708     {"bitand", '&', OP_NULL, 1},
1709     {"bitor", '|', OP_NULL, 1},
1710     {"compl", '~', OP_NULL, 1},
1711     {"not", '!', OP_NULL, 1},
1712     {"not_eq", NOTEQUAL, BINOP_END, 1},
1713     {"or", OROR, BINOP_END, 1},
1714     {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 1},
1715     {"xor", '^', OP_NULL, 1},
1716     {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 1}
1717   };
1718
1719 /* When we find that lexptr (the global var defined in parse.c) is
1720    pointing at a macro invocation, we expand the invocation, and call
1721    scan_macro_expansion to save the old lexptr here and point lexptr
1722    into the expanded text.  When we reach the end of that, we call
1723    end_macro_expansion to pop back to the value we saved here.  The
1724    macro expansion code promises to return only fully-expanded text,
1725    so we don't need to "push" more than one level.
1726
1727    This is disgusting, of course.  It would be cleaner to do all macro
1728    expansion beforehand, and then hand that to lexptr.  But we don't
1729    really know where the expression ends.  Remember, in a command like
1730
1731      (gdb) break *ADDRESS if CONDITION
1732
1733    we evaluate ADDRESS in the scope of the current frame, but we
1734    evaluate CONDITION in the scope of the breakpoint's location.  So
1735    it's simply wrong to try to macro-expand the whole thing at once.  */
1736 static char *macro_original_text;
1737
1738 /* We save all intermediate macro expansions on this obstack for the
1739    duration of a single parse.  The expansion text may sometimes have
1740    to live past the end of the expansion, due to yacc lookahead.
1741    Rather than try to be clever about saving the data for a single
1742    token, we simply keep it all and delete it after parsing has
1743    completed.  */
1744 static struct obstack expansion_obstack;
1745
1746 static void
1747 scan_macro_expansion (char *expansion)
1748 {
1749   char *copy;
1750
1751   /* We'd better not be trying to push the stack twice.  */
1752   gdb_assert (! macro_original_text);
1753
1754   /* Copy to the obstack, and then free the intermediate
1755      expansion.  */
1756   copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
1757   xfree (expansion);
1758
1759   /* Save the old lexptr value, so we can return to it when we're done
1760      parsing the expanded text.  */
1761   macro_original_text = lexptr;
1762   lexptr = copy;
1763 }
1764
1765
1766 static int
1767 scanning_macro_expansion (void)
1768 {
1769   return macro_original_text != 0;
1770 }
1771
1772
1773 static void
1774 finished_macro_expansion (void)
1775 {
1776   /* There'd better be something to pop back to.  */
1777   gdb_assert (macro_original_text);
1778
1779   /* Pop back to the original text.  */
1780   lexptr = macro_original_text;
1781   macro_original_text = 0;
1782 }
1783
1784
1785 static void
1786 scan_macro_cleanup (void *dummy)
1787 {
1788   if (macro_original_text)
1789     finished_macro_expansion ();
1790
1791   obstack_free (&expansion_obstack, NULL);
1792 }
1793
1794
1795 /* The scope used for macro expansion.  */
1796 static struct macro_scope *expression_macro_scope;
1797
1798 /* This is set if a NAME token appeared at the very end of the input
1799    string, with no whitespace separating the name from the EOF.  This
1800    is used only when parsing to do field name completion.  */
1801 static int saw_name_at_eof;
1802
1803 /* This is set if the previously-returned token was a structure
1804    operator -- either '.' or ARROW.  This is used only when parsing to
1805    do field name completion.  */
1806 static int last_was_structop;
1807
1808 /* Read one token, getting characters through lexptr.  */
1809
1810 static int
1811 yylex (void)
1812 {
1813   int c;
1814   int namelen;
1815   unsigned int i;
1816   char *tokstart;
1817   int saw_structop = last_was_structop;
1818   char *copy;
1819
1820   last_was_structop = 0;
1821
1822  retry:
1823
1824   /* Check if this is a macro invocation that we need to expand.  */
1825   if (! scanning_macro_expansion ())
1826     {
1827       char *expanded = macro_expand_next (&lexptr,
1828                                           standard_macro_lookup,
1829                                           expression_macro_scope);
1830
1831       if (expanded)
1832         scan_macro_expansion (expanded);
1833     }
1834
1835   prev_lexptr = lexptr;
1836
1837   tokstart = lexptr;
1838   /* See if it is a special token of length 3.  */
1839   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1840     if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
1841       {
1842         lexptr += 3;
1843         yylval.opcode = tokentab3[i].opcode;
1844         return tokentab3[i].token;
1845       }
1846
1847   /* See if it is a special token of length 2.  */
1848   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1849     if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
1850       {
1851         lexptr += 2;
1852         yylval.opcode = tokentab2[i].opcode;
1853         if (in_parse_field && tokentab2[i].token == ARROW)
1854           last_was_structop = 1;
1855         return tokentab2[i].token;
1856       }
1857
1858   switch (c = *tokstart)
1859     {
1860     case 0:
1861       /* If we were just scanning the result of a macro expansion,
1862          then we need to resume scanning the original text.
1863          If we're parsing for field name completion, and the previous
1864          token allows such completion, return a COMPLETE token.
1865          Otherwise, we were already scanning the original text, and
1866          we're really done.  */
1867       if (scanning_macro_expansion ())
1868         {
1869           finished_macro_expansion ();
1870           goto retry;
1871         }
1872       else if (saw_name_at_eof)
1873         {
1874           saw_name_at_eof = 0;
1875           return COMPLETE;
1876         }
1877       else if (saw_structop)
1878         return COMPLETE;
1879       else
1880         return 0;
1881
1882     case ' ':
1883     case '\t':
1884     case '\n':
1885       lexptr++;
1886       goto retry;
1887
1888     case '[':
1889     case '(':
1890       paren_depth++;
1891       lexptr++;
1892       return c;
1893
1894     case ']':
1895     case ')':
1896       if (paren_depth == 0)
1897         return 0;
1898       paren_depth--;
1899       lexptr++;
1900       return c;
1901
1902     case ',':
1903       if (comma_terminates
1904           && paren_depth == 0
1905           && ! scanning_macro_expansion ())
1906         return 0;
1907       lexptr++;
1908       return c;
1909
1910     case '.':
1911       /* Might be a floating point number.  */
1912       if (lexptr[1] < '0' || lexptr[1] > '9')
1913         {
1914           if (in_parse_field)
1915             last_was_structop = 1;
1916           goto symbol;          /* Nope, must be a symbol. */
1917         }
1918       /* FALL THRU into number case.  */
1919
1920     case '0':
1921     case '1':
1922     case '2':
1923     case '3':
1924     case '4':
1925     case '5':
1926     case '6':
1927     case '7':
1928     case '8':
1929     case '9':
1930       {
1931         /* It's a number.  */
1932         int got_dot = 0, got_e = 0, toktype;
1933         char *p = tokstart;
1934         int hex = input_radix > 10;
1935
1936         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1937           {
1938             p += 2;
1939             hex = 1;
1940           }
1941         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1942           {
1943             p += 2;
1944             hex = 0;
1945           }
1946
1947         for (;; ++p)
1948           {
1949             /* This test includes !hex because 'e' is a valid hex digit
1950                and thus does not indicate a floating point number when
1951                the radix is hex.  */
1952             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1953               got_dot = got_e = 1;
1954             /* This test does not include !hex, because a '.' always indicates
1955                a decimal floating point number regardless of the radix.  */
1956             else if (!got_dot && *p == '.')
1957               got_dot = 1;
1958             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1959                      && (*p == '-' || *p == '+'))
1960               /* This is the sign of the exponent, not the end of the
1961                  number.  */
1962               continue;
1963             /* We will take any letters or digits.  parse_number will
1964                complain if past the radix, or if L or U are not final.  */
1965             else if ((*p < '0' || *p > '9')
1966                      && ((*p < 'a' || *p > 'z')
1967                                   && (*p < 'A' || *p > 'Z')))
1968               break;
1969           }
1970         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1971         if (toktype == ERROR)
1972           {
1973             char *err_copy = (char *) alloca (p - tokstart + 1);
1974
1975             memcpy (err_copy, tokstart, p - tokstart);
1976             err_copy[p - tokstart] = 0;
1977             error ("Invalid number \"%s\".", err_copy);
1978           }
1979         lexptr = p;
1980         return toktype;
1981       }
1982
1983     case '+':
1984     case '-':
1985     case '*':
1986     case '/':
1987     case '%':
1988     case '|':
1989     case '&':
1990     case '^':
1991     case '~':
1992     case '!':
1993     case '@':
1994     case '<':
1995     case '>':
1996     case '?':
1997     case ':':
1998     case '=':
1999     case '{':
2000     case '}':
2001     symbol:
2002       lexptr++;
2003       return c;
2004
2005     case 'L':
2006     case 'u':
2007     case 'U':
2008       if (tokstart[1] != '"' && tokstart[1] != '\'')
2009         break;
2010       /* Fall through.  */
2011     case '\'':
2012     case '"':
2013       {
2014         int host_len;
2015         int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
2016                                            &host_len);
2017         if (result == CHAR)
2018           {
2019             if (host_len == 0)
2020               error ("Empty character constant.");
2021             else if (host_len > 2 && c == '\'')
2022               {
2023                 ++tokstart;
2024                 namelen = lexptr - tokstart - 1;
2025                 goto tryname;
2026               }
2027             else if (host_len > 1)
2028               error ("Invalid character constant.");
2029           }
2030         return result;
2031       }
2032     }
2033
2034   if (!(c == '_' || c == '$'
2035         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2036     /* We must have come across a bad character (e.g. ';').  */
2037     error ("Invalid character '%c' in expression.", c);
2038
2039   /* It's a name.  See how long it is.  */
2040   namelen = 0;
2041   for (c = tokstart[namelen];
2042        (c == '_' || c == '$' || (c >= '0' && c <= '9')
2043         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
2044     {
2045       /* Template parameter lists are part of the name.
2046          FIXME: This mishandles `print $a<4&&$a>3'.  */
2047
2048       if (c == '<')
2049         {
2050                /* Scan ahead to get rest of the template specification.  Note
2051                   that we look ahead only when the '<' adjoins non-whitespace
2052                   characters; for comparison expressions, e.g. "a < b > c",
2053                   there must be spaces before the '<', etc. */
2054
2055                char * p = find_template_name_end (tokstart + namelen);
2056                if (p)
2057                  namelen = p - tokstart;
2058                break;
2059         }
2060       c = tokstart[++namelen];
2061     }
2062
2063   /* The token "if" terminates the expression and is NOT removed from
2064      the input stream.  It doesn't count if it appears in the
2065      expansion of a macro.  */
2066   if (namelen == 2
2067       && tokstart[0] == 'i'
2068       && tokstart[1] == 'f'
2069       && ! scanning_macro_expansion ())
2070     {
2071       return 0;
2072     }
2073
2074   lexptr += namelen;
2075
2076   tryname:
2077
2078   yylval.sval.ptr = tokstart;
2079   yylval.sval.length = namelen;
2080
2081   /* Catch specific keywords.  */
2082   copy = copy_name (yylval.sval);
2083   for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
2084     if (strcmp (copy, ident_tokens[i].operator) == 0)
2085       {
2086         if (ident_tokens[i].cxx_only
2087             && parse_language->la_language != language_cplus)
2088           break;
2089
2090         /* It is ok to always set this, even though we don't always
2091            strictly need to.  */
2092         yylval.opcode = ident_tokens[i].opcode;
2093         return ident_tokens[i].token;
2094       }
2095
2096   if (*tokstart == '$')
2097     {
2098       write_dollar_variable (yylval.sval);
2099       return VARIABLE;
2100     }
2101
2102   /* Use token-type BLOCKNAME for symbols that happen to be defined as
2103      functions or symtabs.  If this is not so, then ...
2104      Use token-type TYPENAME for symbols that happen to be defined
2105      currently as names of types; NAME for other symbols.
2106      The caller is not constrained to care about the distinction.  */
2107   {
2108     struct symbol *sym;
2109     int is_a_field_of_this = 0;
2110     int hextype;
2111
2112     sym = lookup_symbol (copy, expression_context_block,
2113                          VAR_DOMAIN,
2114                          parse_language->la_language == language_cplus
2115                          ? &is_a_field_of_this : (int *) NULL);
2116     /* Call lookup_symtab, not lookup_partial_symtab, in case there are
2117        no psymtabs (coff, xcoff, or some future change to blow away the
2118        psymtabs once once symbols are read).  */
2119     if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2120       {
2121         yylval.ssym.sym = sym;
2122         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2123         return BLOCKNAME;
2124       }
2125     else if (!sym)
2126       {                         /* See if it's a file name. */
2127         struct symtab *symtab;
2128
2129         symtab = lookup_symtab (copy);
2130
2131         if (symtab)
2132           {
2133             yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
2134             return FILENAME;
2135           }
2136       }
2137
2138     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2139         {
2140           /* NOTE: carlton/2003-09-25: There used to be code here to
2141              handle nested types.  It didn't work very well.  See the
2142              comment before qualified_type for more info.  */
2143           yylval.tsym.type = SYMBOL_TYPE (sym);
2144           return TYPENAME;
2145         }
2146     yylval.tsym.type
2147       = language_lookup_primitive_type_by_name (parse_language,
2148                                                 parse_gdbarch, copy);
2149     if (yylval.tsym.type != NULL)
2150       return TYPENAME;
2151
2152     /* Input names that aren't symbols but ARE valid hex numbers,
2153        when the input radix permits them, can be names or numbers
2154        depending on the parse.  Note we support radixes > 16 here.  */
2155     if (!sym &&
2156         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
2157          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
2158       {
2159         YYSTYPE newlval;        /* Its value is ignored.  */
2160         hextype = parse_number (tokstart, namelen, 0, &newlval);
2161         if (hextype == INT)
2162           {
2163             yylval.ssym.sym = sym;
2164             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2165             return NAME_OR_INT;
2166           }
2167       }
2168
2169     /* Any other kind of symbol */
2170     yylval.ssym.sym = sym;
2171     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2172     if (in_parse_field && *lexptr == '\0')
2173       saw_name_at_eof = 1;
2174     return NAME;
2175   }
2176 }
2177
2178 int
2179 c_parse (void)
2180 {
2181   int result;
2182   struct cleanup *back_to = make_cleanup (free_current_contents,
2183                                           &expression_macro_scope);
2184
2185   /* Set up the scope for macro expansion.  */
2186   expression_macro_scope = NULL;
2187
2188   if (expression_context_block)
2189     expression_macro_scope
2190       = sal_macro_scope (find_pc_line (expression_context_pc, 0));
2191   else
2192     expression_macro_scope = default_macro_scope ();
2193   if (! expression_macro_scope)
2194     expression_macro_scope = user_macro_scope ();
2195
2196   /* Initialize macro expansion code.  */
2197   obstack_init (&expansion_obstack);
2198   gdb_assert (! macro_original_text);
2199   make_cleanup (scan_macro_cleanup, 0);
2200
2201   /* Initialize some state used by the lexer.  */
2202   last_was_structop = 0;
2203   saw_name_at_eof = 0;
2204
2205   result = yyparse ();
2206   do_cleanups (back_to);
2207   return result;
2208 }
2209
2210
2211 void
2212 yyerror (char *msg)
2213 {
2214   if (prev_lexptr)
2215     lexptr = prev_lexptr;
2216
2217   error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
2218 }