gdb/c-exp.y

   1 /* YACC parser for C expressions, for GDB.
   2    Copyright (C) 1986-2014 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 3 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, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* Parse a C expression from text in a string,
  20    and return the result as a  struct expression  pointer.
  21    That structure contains arithmetic operations in reverse polish,
  22    with constants represented by operations that are followed by special data.
  23    See expression.h for the details of the format.
  24    What is important here is that it can be built up sequentially
  25    during the process of parsing; the lower levels of the tree always
  26    come first in the result.
  27
  28    Note that malloc's and realloc's in this file are transformed to
  29    xmalloc and xrealloc respectively by the same sed command in the
  30    makefile that remaps any other malloc/realloc inserted by the parser
  31    generator.  Doing this with #defines and trying to control the interaction
  32    with include files (<malloc.h> and <stdlib.h> for example) just became
  33    too messy, particularly when such includes can be inserted at random
  34    times by the parser generator.  */
  35
  36 %{
  37
  38 #include "defs.h"
  39 #include <string.h>
  40 #include <ctype.h>
  41 #include "expression.h"
  42 #include "value.h"
  43 #include "parser-defs.h"
  44 #include "language.h"
  45 #include "c-lang.h"
  46 #include "bfd.h" /* Required by objfiles.h.  */
  47 #include "symfile.h" /* Required by objfiles.h.  */
  48 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
  49 #include "charset.h"
  50 #include "block.h"
  51 #include "cp-support.h"
  52 #include "dfp.h"
  53 #include "gdb_assert.h"
  54 #include "macroscope.h"
  55 #include "objc-lang.h"
  56 #include "typeprint.h"
  57 #include "cp-abi.h"
  58
  59 #define parse_type(ps) builtin_type (parse_gdbarch (ps))
  60
  61 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
  62    as well as gratuitiously global symbol names, so we can have multiple
  63    yacc generated parsers in gdb.  Note that these are only the variables
  64    produced by yacc.  If other parser generators (bison, byacc, etc) produce
  65    additional global names that conflict at link time, then those parser
  66    generators need to be fixed instead of adding those names to this list. */
  67
  68 #define yymaxdepth c_maxdepth
  69 #define yyparse c_parse_internal
  70 #define yylex   c_lex
  71 #define yyerror c_error
  72 #define yylval  c_lval
  73 #define yychar  c_char
  74 #define yydebug c_debug
  75 #define yypact  c_pact
  76 #define yyr1    c_r1
  77 #define yyr2    c_r2
  78 #define yydef   c_def
  79 #define yychk   c_chk
  80 #define yypgo   c_pgo
  81 #define yyact   c_act
  82 #define yyexca  c_exca
  83 #define yyerrflag c_errflag
  84 #define yynerrs c_nerrs
  85 #define yyps    c_ps
  86 #define yypv    c_pv
  87 #define yys     c_s
  88 #define yy_yys  c_yys
  89 #define yystate c_state
  90 #define yytmp   c_tmp
  91 #define yyv     c_v
  92 #define yy_yyv  c_yyv
  93 #define yyval   c_val
  94 #define yylloc  c_lloc
  95 #define yyreds  c_reds          /* With YYDEBUG defined */
  96 #define yytoks  c_toks          /* With YYDEBUG defined */
  97 #define yyname  c_name          /* With YYDEBUG defined */
  98 #define yyrule  c_rule          /* With YYDEBUG defined */
  99 #define yylhs   c_yylhs
 100 #define yylen   c_yylen
 101 #define yydefred c_yydefred
 102 #define yydgoto c_yydgoto
 103 #define yysindex c_yysindex
 104 #define yyrindex c_yyrindex
 105 #define yygindex c_yygindex
 106 #define yytable  c_yytable
 107 #define yycheck  c_yycheck
 108 #define yyss    c_yyss
 109 #define yysslim c_yysslim
 110 #define yyssp   c_yyssp
 111 #define yystacksize c_yystacksize
 112 #define yyvs    c_yyvs
 113 #define yyvsp   c_yyvsp
 114
 115 #ifndef YYDEBUG
 116 #define YYDEBUG 1               /* Default to yydebug support */
 117 #endif
 118
 119 #define YYFPRINTF parser_fprintf
 120
 121 /* The state of the parser, used internally when we are parsing the
 122    expression.  */
 123
 124 static struct parser_state *pstate = NULL;
 125
 126 int yyparse (void);
 127
 128 static int yylex (void);
 129
 130 void yyerror (char *);
 131
 132 %}
 133
 134 /* Although the yacc "value" of an expression is not used,
 135    since the result is stored in the structure being created,
 136    other node types do have values.  */
 137
 138 %union
 139   {
 140     LONGEST lval;
 141     struct {
 142       LONGEST val;
 143       struct type *type;
 144     } typed_val_int;
 145     struct {
 146       DOUBLEST dval;
 147       struct type *type;
 148     } typed_val_float;
 149     struct {
 150       gdb_byte val[16];
 151       struct type *type;
 152     } typed_val_decfloat;
 153     struct type *tval;
 154     struct stoken sval;
 155     struct typed_stoken tsval;
 156     struct ttype tsym;
 157     struct symtoken ssym;
 158     int voidval;
 159     struct block *bval;
 160     enum exp_opcode opcode;
 161
 162     struct stoken_vector svec;
 163     VEC (type_ptr) *tvec;
 164
 165     struct type_stack *type_stack;
 166
 167     struct objc_class_str class;
 168   }
 169
 170 %{
 171 /* YYSTYPE gets defined by %union */
 172 static int parse_number (struct parser_state *par_state,
 173                          const char *, int, int, YYSTYPE *);
 174 static struct stoken operator_stoken (const char *);
 175 static void check_parameter_typelist (VEC (type_ptr) *);
 176 static void write_destructor_name (struct parser_state *par_state,
 177                                    struct stoken);
 178
 179 #ifdef YYBISON
 180 static void c_print_token (FILE *file, int type, YYSTYPE value);
 181 #define YYPRINT(FILE, TYPE, VALUE) c_print_token (FILE, TYPE, VALUE)
 182 #endif
 183 %}
 184
 185 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
 186 %type <lval> rcurly
 187 %type <tval> type typebase
 188 %type <tvec> nonempty_typelist func_mod parameter_typelist
 189 /* %type <bval> block */
 190
 191 /* Fancy type parsing.  */
 192 %type <tval> ptype
 193 %type <lval> array_mod
 194 %type <tval> conversion_type_id
 195
 196 %type <type_stack> ptr_operator_ts abs_decl direct_abs_decl
 197
 198 %token <typed_val_int> INT
 199 %token <typed_val_float> FLOAT
 200 %token <typed_val_decfloat> DECFLOAT
 201
 202 /* Both NAME and TYPENAME tokens represent symbols in the input,
 203    and both convey their data as strings.
 204    But a TYPENAME is a string that happens to be defined as a typedef
 205    or builtin type name (such as int or char)
 206    and a NAME is any other symbol.
 207    Contexts where this distinction is not important can use the
 208    nonterminal "name", which matches either NAME or TYPENAME.  */
 209
 210 %token <tsval> STRING
 211 %token <sval> NSSTRING          /* ObjC Foundation "NSString" literal */
 212 %token SELECTOR                 /* ObjC "@selector" pseudo-operator   */
 213 %token <tsval> CHAR
 214 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
 215 %token <ssym> UNKNOWN_CPP_NAME
 216 %token <voidval> COMPLETE
 217 %token <tsym> TYPENAME
 218 %token <class> CLASSNAME        /* ObjC Class name */
 219 %type <sval> name
 220 %type <svec> string_exp
 221 %type <ssym> name_not_typename
 222 %type <tsym> typename
 223
 224  /* This is like a '[' token, but is only generated when parsing
 225     Objective C.  This lets us reuse the same parser without
 226     erroneously parsing ObjC-specific expressions in C.  */
 227 %token OBJC_LBRAC
 228
 229 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
 230    but which would parse as a valid number in the current input radix.
 231    E.g. "c" when input_radix==16.  Depending on the parse, it will be
 232    turned into a name or into a number.  */
 233
 234 %token <ssym> NAME_OR_INT
 235
 236 %token OPERATOR
 237 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
 238 %token TEMPLATE
 239 %token ERROR
 240 %token NEW DELETE
 241 %type <sval> operator
 242 %token REINTERPRET_CAST DYNAMIC_CAST STATIC_CAST CONST_CAST
 243 %token ENTRY
 244 %token TYPEOF
 245 %token DECLTYPE
 246 %token TYPEID
 247
 248 /* Special type cases, put in to allow the parser to distinguish different
 249    legal basetypes.  */
 250 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
 251
 252 %token <sval> VARIABLE
 253
 254 %token <opcode> ASSIGN_MODIFY
 255
 256 /* C++ */
 257 %token TRUEKEYWORD
 258 %token FALSEKEYWORD
 259
 260
 261 %left ','
 262 %left ABOVE_COMMA
 263 %right '=' ASSIGN_MODIFY
 264 %right '?'
 265 %left OROR
 266 %left ANDAND
 267 %left '|'
 268 %left '^'
 269 %left '&'
 270 %left EQUAL NOTEQUAL
 271 %left '<' '>' LEQ GEQ
 272 %left LSH RSH
 273 %left '@'
 274 %left '+' '-'
 275 %left '*' '/' '%'
 276 %right UNARY INCREMENT DECREMENT
 277 %right ARROW ARROW_STAR '.' DOT_STAR '[' OBJC_LBRAC '('
 278 %token <ssym> BLOCKNAME
 279 %token <bval> FILENAME
 280 %type <bval> block
 281 %left COLONCOLON
 282
 283 %token DOTDOTDOT
 284
 285 \f
 286 %%
 287
 288 start   :       exp1
 289         |       type_exp
 290         ;
 291
 292 type_exp:       type
 293                         { write_exp_elt_opcode(pstate, OP_TYPE);
 294                           write_exp_elt_type(pstate, $1);
 295                           write_exp_elt_opcode(pstate, OP_TYPE);}
 296         |       TYPEOF '(' exp ')'
 297                         {
 298                           write_exp_elt_opcode (pstate, OP_TYPEOF);
 299                         }
 300         |       TYPEOF '(' type ')'
 301                         {
 302                           write_exp_elt_opcode (pstate, OP_TYPE);
 303                           write_exp_elt_type (pstate, $3);
 304                           write_exp_elt_opcode (pstate, OP_TYPE);
 305                         }
 306         |       DECLTYPE '(' exp ')'
 307                         {
 308                           write_exp_elt_opcode (pstate, OP_DECLTYPE);
 309                         }
 310         ;
 311
 312 /* Expressions, including the comma operator.  */
 313 exp1    :       exp
 314         |       exp1 ',' exp
 315                         { write_exp_elt_opcode (pstate, BINOP_COMMA); }
 316         ;
 317
 318 /* Expressions, not including the comma operator.  */
 319 exp     :       '*' exp    %prec UNARY
 320                         { write_exp_elt_opcode (pstate, UNOP_IND); }
 321         ;
 322
 323 exp     :       '&' exp    %prec UNARY
 324                         { write_exp_elt_opcode (pstate, UNOP_ADDR); }
 325         ;
 326
 327 exp     :       '-' exp    %prec UNARY
 328                         { write_exp_elt_opcode (pstate, UNOP_NEG); }
 329         ;
 330
 331 exp     :       '+' exp    %prec UNARY
 332                         { write_exp_elt_opcode (pstate, UNOP_PLUS); }
 333         ;
 334
 335 exp     :       '!' exp    %prec UNARY
 336                         { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
 337         ;
 338
 339 exp     :       '~' exp    %prec UNARY
 340                         { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); }
 341         ;
 342
 343 exp     :       INCREMENT exp    %prec UNARY
 344                         { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
 345         ;
 346
 347 exp     :       DECREMENT exp    %prec UNARY
 348                         { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); }
 349         ;
 350
 351 exp     :       exp INCREMENT    %prec UNARY
 352                         { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); }
 353         ;
 354
 355 exp     :       exp DECREMENT    %prec UNARY
 356                         { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); }
 357         ;
 358
 359 exp     :       TYPEID '(' exp ')' %prec UNARY
 360                         { write_exp_elt_opcode (pstate, OP_TYPEID); }
 361         ;
 362
 363 exp     :       TYPEID '(' type_exp ')' %prec UNARY
 364                         { write_exp_elt_opcode (pstate, OP_TYPEID); }
 365         ;
 366
 367 exp     :       SIZEOF exp       %prec UNARY
 368                         { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
 369         ;
 370
 371 exp     :       exp ARROW name
 372                         { write_exp_elt_opcode (pstate, STRUCTOP_PTR);
 373                           write_exp_string (pstate, $3);
 374                           write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
 375         ;
 376
 377 exp     :       exp ARROW name COMPLETE
 378                         { mark_struct_expression (pstate);
 379                           write_exp_elt_opcode (pstate, STRUCTOP_PTR);
 380                           write_exp_string (pstate, $3);
 381                           write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
 382         ;
 383
 384 exp     :       exp ARROW COMPLETE
 385                         { struct stoken s;
 386                           mark_struct_expression (pstate);
 387                           write_exp_elt_opcode (pstate, STRUCTOP_PTR);
 388                           s.ptr = "";
 389                           s.length = 0;
 390                           write_exp_string (pstate, s);
 391                           write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
 392         ;
 393
 394 exp     :       exp ARROW '~' name
 395                         { write_exp_elt_opcode (pstate, STRUCTOP_PTR);
 396                           write_destructor_name (pstate, $4);
 397                           write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
 398         ;
 399
 400 exp     :       exp ARROW '~' name COMPLETE
 401                         { mark_struct_expression (pstate);
 402                           write_exp_elt_opcode (pstate, STRUCTOP_PTR);
 403                           write_destructor_name (pstate, $4);
 404                           write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
 405         ;
 406
 407 exp     :       exp ARROW qualified_name
 408                         { /* exp->type::name becomes exp->*(&type::name) */
 409                           /* Note: this doesn't work if name is a
 410                              static member!  FIXME */
 411                           write_exp_elt_opcode (pstate, UNOP_ADDR);
 412                           write_exp_elt_opcode (pstate, STRUCTOP_MPTR); }
 413         ;
 414
 415 exp     :       exp ARROW_STAR exp
 416                         { write_exp_elt_opcode (pstate, STRUCTOP_MPTR); }
 417         ;
 418
 419 exp     :       exp '.' name
 420                         { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
 421                           write_exp_string (pstate, $3);
 422                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
 423         ;
 424
 425 exp     :       exp '.' name COMPLETE
 426                         { mark_struct_expression (pstate);
 427                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
 428                           write_exp_string (pstate, $3);
 429                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
 430         ;
 431
 432 exp     :       exp '.' COMPLETE
 433                         { struct stoken s;
 434                           mark_struct_expression (pstate);
 435                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
 436                           s.ptr = "";
 437                           s.length = 0;
 438                           write_exp_string (pstate, s);
 439                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
 440         ;
 441
 442 exp     :       exp '.' '~' name
 443                         { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
 444                           write_destructor_name (pstate, $4);
 445                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
 446         ;
 447
 448 exp     :       exp '.' '~' name COMPLETE
 449                         { mark_struct_expression (pstate);
 450                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
 451                           write_destructor_name (pstate, $4);
 452                           write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
 453         ;
 454
 455 exp     :       exp '.' qualified_name
 456                         { /* exp.type::name becomes exp.*(&type::name) */
 457                           /* Note: this doesn't work if name is a
 458                              static member!  FIXME */
 459                           write_exp_elt_opcode (pstate, UNOP_ADDR);
 460                           write_exp_elt_opcode (pstate, STRUCTOP_MEMBER); }
 461         ;
 462
 463 exp     :       exp DOT_STAR exp
 464                         { write_exp_elt_opcode (pstate, STRUCTOP_MEMBER); }
 465         ;
 466
 467 exp     :       exp '[' exp1 ']'
 468                         { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }
 469         ;
 470
 471 exp     :       exp OBJC_LBRAC exp1 ']'
 472                         { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }
 473         ;
 474
 475 /*
 476  * The rules below parse ObjC message calls of the form:
 477  *      '[' target selector {':' argument}* ']'
 478  */
 479
 480 exp     :       OBJC_LBRAC TYPENAME
 481                         {
 482                           CORE_ADDR class;
 483
 484                           class = lookup_objc_class (parse_gdbarch (pstate),
 485                                                      copy_name ($2.stoken));
 486                           if (class == 0)
 487                             error (_("%s is not an ObjC Class"),
 488                                    copy_name ($2.stoken));
 489                           write_exp_elt_opcode (pstate, OP_LONG);
 490                           write_exp_elt_type (pstate,
 491                                             parse_type (pstate)->builtin_int);
 492                           write_exp_elt_longcst (pstate, (LONGEST) class);
 493                           write_exp_elt_opcode (pstate, OP_LONG);
 494                           start_msglist();
 495                         }
 496                 msglist ']'
 497                         { write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
 498                           end_msglist (pstate);
 499                           write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
 500                         }
 501         ;
 502
 503 exp     :       OBJC_LBRAC CLASSNAME
 504                         {
 505                           write_exp_elt_opcode (pstate, OP_LONG);
 506                           write_exp_elt_type (pstate,
 507                                             parse_type (pstate)->builtin_int);
 508                           write_exp_elt_longcst (pstate, (LONGEST) $2.class);
 509                           write_exp_elt_opcode (pstate, OP_LONG);
 510                           start_msglist();
 511                         }
 512                 msglist ']'
 513                         { write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
 514                           end_msglist (pstate);
 515                           write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
 516                         }
 517         ;
 518
 519 exp     :       OBJC_LBRAC exp
 520                         { start_msglist(); }
 521                 msglist ']'
 522                         { write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
 523                           end_msglist (pstate);
 524                           write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
 525                         }
 526         ;
 527
 528 msglist :       name
 529                         { add_msglist(&$1, 0); }
 530         |       msgarglist
 531         ;
 532
 533 msgarglist :    msgarg
 534         |       msgarglist msgarg
 535         ;
 536
 537 msgarg  :       name ':' exp
 538                         { add_msglist(&$1, 1); }
 539         |       ':' exp /* Unnamed arg.  */
 540                         { add_msglist(0, 1);   }
 541         |       ',' exp /* Variable number of args.  */
 542                         { add_msglist(0, 0);   }
 543         ;
 544
 545 exp     :       exp '('
 546                         /* This is to save the value of arglist_len
 547                            being accumulated by an outer function call.  */
 548                         { start_arglist (); }
 549                 arglist ')'     %prec ARROW
 550                         { write_exp_elt_opcode (pstate, OP_FUNCALL);
 551                           write_exp_elt_longcst (pstate,
 552                                                  (LONGEST) end_arglist ());
 553                           write_exp_elt_opcode (pstate, OP_FUNCALL); }
 554         ;
 555
 556 exp     :       UNKNOWN_CPP_NAME '('
 557                         {
 558                           /* This could potentially be a an argument defined
 559                              lookup function (Koenig).  */
 560                           write_exp_elt_opcode (pstate, OP_ADL_FUNC);
 561                           write_exp_elt_block (pstate,
 562                                                expression_context_block);
 563                           write_exp_elt_sym (pstate,
 564                                              NULL); /* Placeholder.  */
 565                           write_exp_string (pstate, $1.stoken);
 566                           write_exp_elt_opcode (pstate, OP_ADL_FUNC);
 567
 568                         /* This is to save the value of arglist_len
 569                            being accumulated by an outer function call.  */
 570
 571                           start_arglist ();
 572                         }
 573                 arglist ')'     %prec ARROW
 574                         {
 575                           write_exp_elt_opcode (pstate, OP_FUNCALL);
 576                           write_exp_elt_longcst (pstate,
 577                                                  (LONGEST) end_arglist ());
 578                           write_exp_elt_opcode (pstate, OP_FUNCALL);
 579                         }
 580         ;
 581
 582 lcurly  :       '{'
 583                         { start_arglist (); }
 584         ;
 585
 586 arglist :
 587         ;
 588
 589 arglist :       exp
 590                         { arglist_len = 1; }
 591         ;
 592
 593 arglist :       arglist ',' exp   %prec ABOVE_COMMA
 594                         { arglist_len++; }
 595         ;
 596
 597 exp     :       exp '(' parameter_typelist ')' const_or_volatile
 598                         { int i;
 599                           VEC (type_ptr) *type_list = $3;
 600                           struct type *type_elt;
 601                           LONGEST len = VEC_length (type_ptr, type_list);
 602
 603                           write_exp_elt_opcode (pstate, TYPE_INSTANCE);
 604                           write_exp_elt_longcst (pstate, len);
 605                           for (i = 0;
 606                                VEC_iterate (type_ptr, type_list, i, type_elt);
 607                                ++i)
 608                             write_exp_elt_type (pstate, type_elt);
 609                           write_exp_elt_longcst(pstate, len);
 610                           write_exp_elt_opcode (pstate, TYPE_INSTANCE);
 611                           VEC_free (type_ptr, type_list);
 612                         }
 613         ;
 614
 615 rcurly  :       '}'
 616                         { $$ = end_arglist () - 1; }
 617         ;
 618 exp     :       lcurly arglist rcurly   %prec ARROW
 619                         { write_exp_elt_opcode (pstate, OP_ARRAY);
 620                           write_exp_elt_longcst (pstate, (LONGEST) 0);
 621                           write_exp_elt_longcst (pstate, (LONGEST) $3);
 622                           write_exp_elt_opcode (pstate, OP_ARRAY); }
 623         ;
 624
 625 exp     :       lcurly type_exp rcurly exp  %prec UNARY
 626                         { write_exp_elt_opcode (pstate, UNOP_MEMVAL_TYPE); }
 627         ;
 628
 629 exp     :       '(' type_exp ')' exp  %prec UNARY
 630                         { write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }
 631         ;
 632
 633 exp     :       '(' exp1 ')'
 634                         { }
 635         ;
 636
 637 /* Binary operators in order of decreasing precedence.  */
 638
 639 exp     :       exp '@' exp
 640                         { write_exp_elt_opcode (pstate, BINOP_REPEAT); }
 641         ;
 642
 643 exp     :       exp '*' exp
 644                         { write_exp_elt_opcode (pstate, BINOP_MUL); }
 645         ;
 646
 647 exp     :       exp '/' exp
 648                         { write_exp_elt_opcode (pstate, BINOP_DIV); }
 649         ;
 650
 651 exp     :       exp '%' exp
 652                         { write_exp_elt_opcode (pstate, BINOP_REM); }
 653         ;
 654
 655 exp     :       exp '+' exp
 656                         { write_exp_elt_opcode (pstate, BINOP_ADD); }
 657         ;
 658
 659 exp     :       exp '-' exp
 660                         { write_exp_elt_opcode (pstate, BINOP_SUB); }
 661         ;
 662
 663 exp     :       exp LSH exp
 664                         { write_exp_elt_opcode (pstate, BINOP_LSH); }
 665         ;
 666
 667 exp     :       exp RSH exp
 668                         { write_exp_elt_opcode (pstate, BINOP_RSH); }
 669         ;
 670
 671 exp     :       exp EQUAL exp
 672                         { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
 673         ;
 674
 675 exp     :       exp NOTEQUAL exp
 676                         { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
 677         ;
 678
 679 exp     :       exp LEQ exp
 680                         { write_exp_elt_opcode (pstate, BINOP_LEQ); }
 681         ;
 682
 683 exp     :       exp GEQ exp
 684                         { write_exp_elt_opcode (pstate, BINOP_GEQ); }
 685         ;
 686
 687 exp     :       exp '<' exp
 688                         { write_exp_elt_opcode (pstate, BINOP_LESS); }
 689         ;
 690
 691 exp     :       exp '>' exp
 692                         { write_exp_elt_opcode (pstate, BINOP_GTR); }
 693         ;
 694
 695 exp     :       exp '&' exp
 696                         { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
 697         ;
 698
 699 exp     :       exp '^' exp
 700                         { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
 701         ;
 702
 703 exp     :       exp '|' exp
 704                         { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
 705         ;
 706
 707 exp     :       exp ANDAND exp
 708                         { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
 709         ;
 710
 711 exp     :       exp OROR exp
 712                         { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
 713         ;
 714
 715 exp     :       exp '?' exp ':' exp     %prec '?'
 716                         { write_exp_elt_opcode (pstate, TERNOP_COND); }
 717         ;
 718
 719 exp     :       exp '=' exp
 720                         { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
 721         ;
 722
 723 exp     :       exp ASSIGN_MODIFY exp
 724                         { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
 725                           write_exp_elt_opcode (pstate, $2);
 726                           write_exp_elt_opcode (pstate,
 727                                                 BINOP_ASSIGN_MODIFY); }
 728         ;
 729
 730 exp     :       INT
 731                         { write_exp_elt_opcode (pstate, OP_LONG);
 732                           write_exp_elt_type (pstate, $1.type);
 733                           write_exp_elt_longcst (pstate, (LONGEST) ($1.val));
 734                           write_exp_elt_opcode (pstate, OP_LONG); }
 735         ;
 736
 737 exp     :       CHAR
 738                         {
 739                           struct stoken_vector vec;
 740                           vec.len = 1;
 741                           vec.tokens = &$1;
 742                           write_exp_string_vector (pstate, $1.type, &vec);
 743                         }
 744         ;
 745
 746 exp     :       NAME_OR_INT
 747                         { YYSTYPE val;
 748                           parse_number (pstate, $1.stoken.ptr,
 749                                         $1.stoken.length, 0, &val);
 750                           write_exp_elt_opcode (pstate, OP_LONG);
 751                           write_exp_elt_type (pstate, val.typed_val_int.type);
 752                           write_exp_elt_longcst (pstate,
 753                                             (LONGEST) val.typed_val_int.val);
 754                           write_exp_elt_opcode (pstate, OP_LONG);
 755                         }
 756         ;
 757
 758
 759 exp     :       FLOAT
 760                         { write_exp_elt_opcode (pstate, OP_DOUBLE);
 761                           write_exp_elt_type (pstate, $1.type);
 762                           write_exp_elt_dblcst (pstate, $1.dval);
 763                           write_exp_elt_opcode (pstate, OP_DOUBLE); }
 764         ;
 765
 766 exp     :       DECFLOAT
 767                         { write_exp_elt_opcode (pstate, OP_DECFLOAT);
 768                           write_exp_elt_type (pstate, $1.type);
 769                           write_exp_elt_decfloatcst (pstate, $1.val);
 770                           write_exp_elt_opcode (pstate, OP_DECFLOAT); }
 771         ;
 772
 773 exp     :       variable
 774         ;
 775
 776 exp     :       VARIABLE
 777                         {
 778                           write_dollar_variable (pstate, $1);
 779                         }
 780         ;
 781
 782 exp     :       SELECTOR '(' name ')'
 783                         {
 784                           write_exp_elt_opcode (pstate, OP_OBJC_SELECTOR);
 785                           write_exp_string (pstate, $3);
 786                           write_exp_elt_opcode (pstate, OP_OBJC_SELECTOR); }
 787         ;
 788
 789 exp     :       SIZEOF '(' type ')'     %prec UNARY
 790                         { write_exp_elt_opcode (pstate, OP_LONG);
 791                           write_exp_elt_type (pstate, lookup_signed_typename
 792                                               (parse_language (pstate),
 793                                                parse_gdbarch (pstate),
 794                                                "int"));
 795                           CHECK_TYPEDEF ($3);
 796                           write_exp_elt_longcst (pstate,
 797                                                  (LONGEST) TYPE_LENGTH ($3));
 798                           write_exp_elt_opcode (pstate, OP_LONG); }
 799         ;
 800
 801 exp     :       REINTERPRET_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
 802                         { write_exp_elt_opcode (pstate,
 803                                                 UNOP_REINTERPRET_CAST); }
 804         ;
 805
 806 exp     :       STATIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
 807                         { write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }
 808         ;
 809
 810 exp     :       DYNAMIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
 811                         { write_exp_elt_opcode (pstate, UNOP_DYNAMIC_CAST); }
 812         ;
 813
 814 exp     :       CONST_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
 815                         { /* We could do more error checking here, but
 816                              it doesn't seem worthwhile.  */
 817                           write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }
 818         ;
 819
 820 string_exp:
 821                 STRING
 822                         {
 823                           /* We copy the string here, and not in the
 824                              lexer, to guarantee that we do not leak a
 825                              string.  Note that we follow the
 826                              NUL-termination convention of the
 827                              lexer.  */
 828                           struct typed_stoken *vec = XNEW (struct typed_stoken);
 829                           $$.len = 1;
 830                           $$.tokens = vec;
 831
 832                           vec->type = $1.type;
 833                           vec->length = $1.length;
 834                           vec->ptr = malloc ($1.length + 1);
 835                           memcpy (vec->ptr, $1.ptr, $1.length + 1);
 836                         }
 837
 838         |       string_exp STRING
 839                         {
 840                           /* Note that we NUL-terminate here, but just
 841                              for convenience.  */
 842                           char *p;
 843                           ++$$.len;
 844                           $$.tokens = realloc ($$.tokens,
 845                                                $$.len * sizeof (struct typed_stoken));
 846
 847                           p = malloc ($2.length + 1);
 848                           memcpy (p, $2.ptr, $2.length + 1);
 849
 850                           $$.tokens[$$.len - 1].type = $2.type;
 851                           $$.tokens[$$.len - 1].length = $2.length;
 852                           $$.tokens[$$.len - 1].ptr = p;
 853                         }
 854                 ;
 855
 856 exp     :       string_exp
 857                         {
 858                           int i;
 859                           enum c_string_type type = C_STRING;
 860
 861                           for (i = 0; i < $1.len; ++i)
 862                             {
 863                               switch ($1.tokens[i].type)
 864                                 {
 865                                 case C_STRING:
 866                                   break;
 867                                 case C_WIDE_STRING:
 868                                 case C_STRING_16:
 869                                 case C_STRING_32:
 870                                   if (type != C_STRING
 871                                       && type != $1.tokens[i].type)
 872                                     error (_("Undefined string concatenation."));
 873                                   type = $1.tokens[i].type;
 874                                   break;
 875                                 default:
 876                                   /* internal error */
 877                                   internal_error (__FILE__, __LINE__,
 878                                                   "unrecognized type in string concatenation");
 879                                 }
 880                             }
 881
 882                           write_exp_string_vector (pstate, type, &$1);
 883                           for (i = 0; i < $1.len; ++i)
 884                             free ($1.tokens[i].ptr);
 885                           free ($1.tokens);
 886                         }
 887         ;
 888
 889 exp     :       NSSTRING        /* ObjC NextStep NSString constant
 890                                  * of the form '@' '"' string '"'.
 891                                  */
 892                         { write_exp_elt_opcode (pstate, OP_OBJC_NSSTRING);
 893                           write_exp_string (pstate, $1);
 894                           write_exp_elt_opcode (pstate, OP_OBJC_NSSTRING); }
 895         ;
 896
 897 /* C++.  */
 898 exp     :       TRUEKEYWORD
 899                         { write_exp_elt_opcode (pstate, OP_LONG);
 900                           write_exp_elt_type (pstate,
 901                                           parse_type (pstate)->builtin_bool);
 902                           write_exp_elt_longcst (pstate, (LONGEST) 1);
 903                           write_exp_elt_opcode (pstate, OP_LONG); }
 904         ;
 905
 906 exp     :       FALSEKEYWORD
 907                         { write_exp_elt_opcode (pstate, OP_LONG);
 908                           write_exp_elt_type (pstate,
 909                                           parse_type (pstate)->builtin_bool);
 910                           write_exp_elt_longcst (pstate, (LONGEST) 0);
 911                           write_exp_elt_opcode (pstate, OP_LONG); }
 912         ;
 913
 914 /* end of C++.  */
 915
 916 block   :       BLOCKNAME
 917                         {
 918                           if ($1.sym)
 919                             $$ = SYMBOL_BLOCK_VALUE ($1.sym);
 920                           else
 921                             error (_("No file or function \"%s\"."),
 922                                    copy_name ($1.stoken));
 923                         }
 924         |       FILENAME
 925                         {
 926                           $$ = $1;
 927                         }
 928         ;
 929
 930 block   :       block COLONCOLON name
 931                         { struct symbol *tem
 932                             = lookup_symbol (copy_name ($3), $1,
 933                                              VAR_DOMAIN, NULL);
 934                           if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
 935                             error (_("No function \"%s\" in specified context."),
 936                                    copy_name ($3));
 937                           $$ = SYMBOL_BLOCK_VALUE (tem); }
 938         ;
 939
 940 variable:       name_not_typename ENTRY
 941                         { struct symbol *sym = $1.sym;
 942
 943                           if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym)
 944                               || !symbol_read_needs_frame (sym))
 945                             error (_("@entry can be used only for function "
 946                                      "parameters, not for \"%s\""),
 947                                    copy_name ($1.stoken));
 948
 949                           write_exp_elt_opcode (pstate, OP_VAR_ENTRY_VALUE);
 950                           write_exp_elt_sym (pstate, sym);
 951                           write_exp_elt_opcode (pstate, OP_VAR_ENTRY_VALUE);
 952                         }
 953         ;
 954
 955 variable:       block COLONCOLON name
 956                         { struct symbol *sym;
 957                           sym = lookup_symbol (copy_name ($3), $1,
 958                                                VAR_DOMAIN, NULL);
 959                           if (sym == 0)
 960                             error (_("No symbol \"%s\" in specified context."),
 961                                    copy_name ($3));
 962                           if (symbol_read_needs_frame (sym))
 963                             {
 964                               if (innermost_block == 0
 965                                   || contained_in (block_found,
 966                                                    innermost_block))
 967                                 innermost_block = block_found;
 968                             }
 969
 970                           write_exp_elt_opcode (pstate, OP_VAR_VALUE);
 971                           /* block_found is set by lookup_symbol.  */
 972                           write_exp_elt_block (pstate, block_found);
 973                           write_exp_elt_sym (pstate, sym);
 974                           write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
 975         ;
 976
 977 qualified_name: TYPENAME COLONCOLON name
 978                         {
 979                           struct type *type = $1.type;
 980                           CHECK_TYPEDEF (type);
 981                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 982                               && TYPE_CODE (type) != TYPE_CODE_UNION
 983                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
 984                             error (_("`%s' is not defined as an aggregate type."),
 985                                    TYPE_SAFE_NAME (type));
 986
 987                           write_exp_elt_opcode (pstate, OP_SCOPE);
 988                           write_exp_elt_type (pstate, type);
 989                           write_exp_string (pstate, $3);
 990                           write_exp_elt_opcode (pstate, OP_SCOPE);
 991                         }
 992         |       TYPENAME COLONCOLON '~' name
 993                         {
 994                           struct type *type = $1.type;
 995                           struct stoken tmp_token;
 996                           char *buf;
 997
 998                           CHECK_TYPEDEF (type);
 999                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1000                               && TYPE_CODE (type) != TYPE_CODE_UNION
1001                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
1002                             error (_("`%s' is not defined as an aggregate type."),
1003                                    TYPE_SAFE_NAME (type));
1004                           buf = alloca ($4.length + 2);
1005                           tmp_token.ptr = buf;
1006                           tmp_token.length = $4.length + 1;
1007                           buf[0] = '~';
1008                           memcpy (buf+1, $4.ptr, $4.length);
1009                           buf[tmp_token.length] = 0;
1010
1011                           /* Check for valid destructor name.  */
1012                           destructor_name_p (tmp_token.ptr, $1.type);
1013                           write_exp_elt_opcode (pstate, OP_SCOPE);
1014                           write_exp_elt_type (pstate, type);
1015                           write_exp_string (pstate, tmp_token);
1016                           write_exp_elt_opcode (pstate, OP_SCOPE);
1017                         }
1018         |       TYPENAME COLONCOLON name COLONCOLON name
1019                         {
1020                           char *copy = copy_name ($3);
1021                           error (_("No type \"%s\" within class "
1022                                    "or namespace \"%s\"."),
1023                                  copy, TYPE_SAFE_NAME ($1.type));
1024                         }
1025         ;
1026
1027 variable:       qualified_name
1028         |       COLONCOLON name_not_typename
1029                         {
1030                           char *name = copy_name ($2.stoken);
1031                           struct symbol *sym;
1032                           struct bound_minimal_symbol msymbol;
1033
1034                           sym =
1035                             lookup_symbol (name, (const struct block *) NULL,
1036                                            VAR_DOMAIN, NULL);
1037                           if (sym)
1038                             {
1039                               write_exp_elt_opcode (pstate, OP_VAR_VALUE);
1040                               write_exp_elt_block (pstate, NULL);
1041                               write_exp_elt_sym (pstate, sym);
1042                               write_exp_elt_opcode (pstate, OP_VAR_VALUE);
1043                               break;
1044                             }
1045
1046                           msymbol = lookup_bound_minimal_symbol (name);
1047                           if (msymbol.minsym != NULL)
1048                             write_exp_msymbol (pstate, msymbol);
1049                           else if (!have_full_symbols () && !have_partial_symbols ())
1050                             error (_("No symbol table is loaded.  Use the \"file\" command."));
1051                           else
1052                             error (_("No symbol \"%s\" in current context."), name);
1053                         }
1054         ;
1055
1056 variable:       name_not_typename
1057                         { struct symbol *sym = $1.sym;
1058
1059                           if (sym)
1060                             {
1061                               if (symbol_read_needs_frame (sym))
1062                                 {
1063                                   if (innermost_block == 0
1064                                       || contained_in (block_found,
1065                                                        innermost_block))
1066                                     innermost_block = block_found;
1067                                 }
1068
1069                               write_exp_elt_opcode (pstate, OP_VAR_VALUE);
1070                               /* We want to use the selected frame, not
1071                                  another more inner frame which happens to
1072                                  be in the same block.  */
1073                               write_exp_elt_block (pstate, NULL);
1074                               write_exp_elt_sym (pstate, sym);
1075                               write_exp_elt_opcode (pstate, OP_VAR_VALUE);
1076                             }
1077                           else if ($1.is_a_field_of_this)
1078                             {
1079                               /* C++: it hangs off of `this'.  Must
1080                                  not inadvertently convert from a method call
1081                                  to data ref.  */
1082                               if (innermost_block == 0
1083                                   || contained_in (block_found,
1084                                                    innermost_block))
1085                                 innermost_block = block_found;
1086                               write_exp_elt_opcode (pstate, OP_THIS);
1087                               write_exp_elt_opcode (pstate, OP_THIS);
1088                               write_exp_elt_opcode (pstate, STRUCTOP_PTR);
1089                               write_exp_string (pstate, $1.stoken);
1090                               write_exp_elt_opcode (pstate, STRUCTOP_PTR);
1091                             }
1092                           else
1093                             {
1094                               struct bound_minimal_symbol msymbol;
1095                               char *arg = copy_name ($1.stoken);
1096
1097                               msymbol =
1098                                 lookup_bound_minimal_symbol (arg);
1099                               if (msymbol.minsym != NULL)
1100                                 write_exp_msymbol (pstate, msymbol);
1101                               else if (!have_full_symbols () && !have_partial_symbols ())
1102                                 error (_("No symbol table is loaded.  Use the \"file\" command."));
1103                               else
1104                                 error (_("No symbol \"%s\" in current context."),
1105                                        copy_name ($1.stoken));
1106                             }
1107                         }
1108         ;
1109
1110 space_identifier : '@' NAME
1111                 { insert_type_address_space (pstate, copy_name ($2.stoken)); }
1112         ;
1113
1114 const_or_volatile: const_or_volatile_noopt
1115         |
1116         ;
1117
1118 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
1119         ;
1120
1121 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
1122         | const_or_volatile_noopt
1123         ;
1124
1125 const_or_volatile_or_space_identifier:
1126                 const_or_volatile_or_space_identifier_noopt
1127         |
1128         ;
1129
1130 ptr_operator:
1131                 ptr_operator '*'
1132                         { insert_type (tp_pointer); }
1133                 const_or_volatile_or_space_identifier
1134         |       '*'
1135                         { insert_type (tp_pointer); }
1136                 const_or_volatile_or_space_identifier
1137         |       '&'
1138                         { insert_type (tp_reference); }
1139         |       '&' ptr_operator
1140                         { insert_type (tp_reference); }
1141         ;
1142
1143 ptr_operator_ts: ptr_operator
1144                         {
1145                           $$ = get_type_stack ();
1146                           /* This cleanup is eventually run by
1147                              c_parse.  */
1148                           make_cleanup (type_stack_cleanup, $$);
1149                         }
1150         ;
1151
1152 abs_decl:       ptr_operator_ts direct_abs_decl
1153                         { $$ = append_type_stack ($2, $1); }
1154         |       ptr_operator_ts
1155         |       direct_abs_decl
1156         ;
1157
1158 direct_abs_decl: '(' abs_decl ')'
1159                         { $$ = $2; }
1160         |       direct_abs_decl array_mod
1161                         {
1162                           push_type_stack ($1);
1163                           push_type_int ($2);
1164                           push_type (tp_array);
1165                           $$ = get_type_stack ();
1166                         }
1167         |       array_mod
1168                         {
1169                           push_type_int ($1);
1170                           push_type (tp_array);
1171                           $$ = get_type_stack ();
1172                         }
1173
1174         |       direct_abs_decl func_mod
1175                         {
1176                           push_type_stack ($1);
1177                           push_typelist ($2);
1178                           $$ = get_type_stack ();
1179                         }
1180         |       func_mod
1181                         {
1182                           push_typelist ($1);
1183                           $$ = get_type_stack ();
1184                         }
1185         ;
1186
1187 array_mod:      '[' ']'
1188                         { $$ = -1; }
1189         |       OBJC_LBRAC ']'
1190                         { $$ = -1; }
1191         |       '[' INT ']'
1192                         { $$ = $2.val; }
1193         |       OBJC_LBRAC INT ']'
1194                         { $$ = $2.val; }
1195         ;
1196
1197 func_mod:       '(' ')'
1198                         { $$ = NULL; }
1199         |       '(' parameter_typelist ')'
1200                         { $$ = $2; }
1201         ;
1202
1203 /* We used to try to recognize pointer to member types here, but
1204    that didn't work (shift/reduce conflicts meant that these rules never
1205    got executed).  The problem is that
1206      int (foo::bar::baz::bizzle)
1207    is a function type but
1208      int (foo::bar::baz::bizzle::*)
1209    is a pointer to member type.  Stroustrup loses again!  */
1210
1211 type    :       ptype
1212         ;
1213
1214 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
1215         :       TYPENAME
1216                         { $$ = $1.type; }
1217         |       INT_KEYWORD
1218                         { $$ = lookup_signed_typename (parse_language (pstate),
1219                                                        parse_gdbarch (pstate),
1220                                                        "int"); }
1221         |       LONG
1222                         { $$ = lookup_signed_typename (parse_language (pstate),
1223                                                        parse_gdbarch (pstate),
1224                                                        "long"); }
1225         |       SHORT
1226                         { $$ = lookup_signed_typename (parse_language (pstate),
1227                                                        parse_gdbarch (pstate),
1228                                                        "short"); }
1229         |       LONG INT_KEYWORD
1230                         { $$ = lookup_signed_typename (parse_language (pstate),
1231                                                        parse_gdbarch (pstate),
1232                                                        "long"); }
1233         |       LONG SIGNED_KEYWORD INT_KEYWORD
1234                         { $$ = lookup_signed_typename (parse_language (pstate),
1235                                                        parse_gdbarch (pstate),
1236                                                        "long"); }
1237         |       LONG SIGNED_KEYWORD
1238                         { $$ = lookup_signed_typename (parse_language (pstate),
1239                                                        parse_gdbarch (pstate),
1240                                                        "long"); }
1241         |       SIGNED_KEYWORD LONG INT_KEYWORD
1242                         { $$ = lookup_signed_typename (parse_language (pstate),
1243                                                        parse_gdbarch (pstate),
1244                                                        "long"); }
1245         |       UNSIGNED LONG INT_KEYWORD
1246                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1247                                                          parse_gdbarch (pstate),
1248                                                          "long"); }
1249         |       LONG UNSIGNED INT_KEYWORD
1250                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1251                                                          parse_gdbarch (pstate),
1252                                                          "long"); }
1253         |       LONG UNSIGNED
1254                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1255                                                          parse_gdbarch (pstate),
1256                                                          "long"); }
1257         |       LONG LONG
1258                         { $$ = lookup_signed_typename (parse_language (pstate),
1259                                                        parse_gdbarch (pstate),
1260                                                        "long long"); }
1261         |       LONG LONG INT_KEYWORD
1262                         { $$ = lookup_signed_typename (parse_language (pstate),
1263                                                        parse_gdbarch (pstate),
1264                                                        "long long"); }
1265         |       LONG LONG SIGNED_KEYWORD INT_KEYWORD
1266                         { $$ = lookup_signed_typename (parse_language (pstate),
1267                                                        parse_gdbarch (pstate),
1268                                                        "long long"); }
1269         |       LONG LONG SIGNED_KEYWORD
1270                         { $$ = lookup_signed_typename (parse_language (pstate),
1271                                                        parse_gdbarch (pstate),
1272                                                        "long long"); }
1273         |       SIGNED_KEYWORD LONG LONG
1274                         { $$ = lookup_signed_typename (parse_language (pstate),
1275                                                        parse_gdbarch (pstate),
1276                                                        "long long"); }
1277         |       SIGNED_KEYWORD LONG LONG INT_KEYWORD
1278                         { $$ = lookup_signed_typename (parse_language (pstate),
1279                                                        parse_gdbarch (pstate),
1280                                                        "long long"); }
1281         |       UNSIGNED LONG LONG
1282                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1283                                                          parse_gdbarch (pstate),
1284                                                          "long long"); }
1285         |       UNSIGNED LONG LONG INT_KEYWORD
1286                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1287                                                          parse_gdbarch (pstate),
1288                                                          "long long"); }
1289         |       LONG LONG UNSIGNED
1290                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1291                                                          parse_gdbarch (pstate),
1292                                                          "long long"); }
1293         |       LONG LONG UNSIGNED INT_KEYWORD
1294                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1295                                                          parse_gdbarch (pstate),
1296                                                          "long long"); }
1297         |       SHORT INT_KEYWORD
1298                         { $$ = lookup_signed_typename (parse_language (pstate),
1299                                                        parse_gdbarch (pstate),
1300                                                        "short"); }
1301         |       SHORT SIGNED_KEYWORD INT_KEYWORD
1302                         { $$ = lookup_signed_typename (parse_language (pstate),
1303                                                        parse_gdbarch (pstate),
1304                                                        "short"); }
1305         |       SHORT SIGNED_KEYWORD
1306                         { $$ = lookup_signed_typename (parse_language (pstate),
1307                                                        parse_gdbarch (pstate),
1308                                                        "short"); }
1309         |       UNSIGNED SHORT INT_KEYWORD
1310                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1311                                                          parse_gdbarch (pstate),
1312                                                          "short"); }
1313         |       SHORT UNSIGNED
1314                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1315                                                          parse_gdbarch (pstate),
1316                                                          "short"); }
1317         |       SHORT UNSIGNED INT_KEYWORD
1318                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1319                                                          parse_gdbarch (pstate),
1320                                                          "short"); }
1321         |       DOUBLE_KEYWORD
1322                         { $$ = lookup_typename (parse_language (pstate),
1323                                                 parse_gdbarch (pstate),
1324                                                 "double",
1325                                                 (struct block *) NULL,
1326                                                 0); }
1327         |       LONG DOUBLE_KEYWORD
1328                         { $$ = lookup_typename (parse_language (pstate),
1329                                                 parse_gdbarch (pstate),
1330                                                 "long double",
1331                                                 (struct block *) NULL,
1332                                                 0); }
1333         |       STRUCT name
1334                         { $$ = lookup_struct (copy_name ($2),
1335                                               expression_context_block); }
1336         |       STRUCT COMPLETE
1337                         {
1338                           mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
1339                           $$ = NULL;
1340                         }
1341         |       STRUCT name COMPLETE
1342                         {
1343                           mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr,
1344                                                $2.length);
1345                           $$ = NULL;
1346                         }
1347         |       CLASS name
1348                         { $$ = lookup_struct (copy_name ($2),
1349                                               expression_context_block); }
1350         |       CLASS COMPLETE
1351                         {
1352                           mark_completion_tag (TYPE_CODE_CLASS, "", 0);
1353                           $$ = NULL;
1354                         }
1355         |       CLASS name COMPLETE
1356                         {
1357                           mark_completion_tag (TYPE_CODE_CLASS, $2.ptr,
1358                                                $2.length);
1359                           $$ = NULL;
1360                         }
1361         |       UNION name
1362                         { $$ = lookup_union (copy_name ($2),
1363                                              expression_context_block); }
1364         |       UNION COMPLETE
1365                         {
1366                           mark_completion_tag (TYPE_CODE_UNION, "", 0);
1367                           $$ = NULL;
1368                         }
1369         |       UNION name COMPLETE
1370                         {
1371                           mark_completion_tag (TYPE_CODE_UNION, $2.ptr,
1372                                                $2.length);
1373                           $$ = NULL;
1374                         }
1375         |       ENUM name
1376                         { $$ = lookup_enum (copy_name ($2),
1377                                             expression_context_block); }
1378         |       ENUM COMPLETE
1379                         {
1380                           mark_completion_tag (TYPE_CODE_ENUM, "", 0);
1381                           $$ = NULL;
1382                         }
1383         |       ENUM name COMPLETE
1384                         {
1385                           mark_completion_tag (TYPE_CODE_ENUM, $2.ptr,
1386                                                $2.length);
1387                           $$ = NULL;
1388                         }
1389         |       UNSIGNED typename
1390                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1391                                                          parse_gdbarch (pstate),
1392                                                          TYPE_NAME($2.type)); }
1393         |       UNSIGNED
1394                         { $$ = lookup_unsigned_typename (parse_language (pstate),
1395                                                          parse_gdbarch (pstate),
1396                                                          "int"); }
1397         |       SIGNED_KEYWORD typename
1398                         { $$ = lookup_signed_typename (parse_language (pstate),
1399                                                        parse_gdbarch (pstate),
1400                                                        TYPE_NAME($2.type)); }
1401         |       SIGNED_KEYWORD
1402                         { $$ = lookup_signed_typename (parse_language (pstate),
1403                                                        parse_gdbarch (pstate),
1404                                                        "int"); }
1405                 /* It appears that this rule for templates is never
1406                    reduced; template recognition happens by lookahead
1407                    in the token processing code in yylex. */
1408         |       TEMPLATE name '<' type '>'
1409                         { $$ = lookup_template_type(copy_name($2), $4,
1410                                                     expression_context_block);
1411                         }
1412         | const_or_volatile_or_space_identifier_noopt typebase
1413                         { $$ = follow_types ($2); }
1414         | typebase const_or_volatile_or_space_identifier_noopt
1415                         { $$ = follow_types ($1); }
1416         ;
1417
1418 typename:       TYPENAME
1419         |       INT_KEYWORD
1420                 {
1421                   $$.stoken.ptr = "int";
1422                   $$.stoken.length = 3;
1423                   $$.type = lookup_signed_typename (parse_language (pstate),
1424                                                     parse_gdbarch (pstate),
1425                                                     "int");
1426                 }
1427         |       LONG
1428                 {
1429                   $$.stoken.ptr = "long";
1430                   $$.stoken.length = 4;
1431                   $$.type = lookup_signed_typename (parse_language (pstate),
1432                                                     parse_gdbarch (pstate),
1433                                                     "long");
1434                 }
1435         |       SHORT
1436                 {
1437                   $$.stoken.ptr = "short";
1438                   $$.stoken.length = 5;
1439                   $$.type = lookup_signed_typename (parse_language (pstate),
1440                                                     parse_gdbarch (pstate),
1441                                                     "short");
1442                 }
1443         ;
1444
1445 parameter_typelist:
1446                 nonempty_typelist
1447                         { check_parameter_typelist ($1); }
1448         |       nonempty_typelist ',' DOTDOTDOT
1449                         {
1450                           VEC_safe_push (type_ptr, $1, NULL);
1451                           check_parameter_typelist ($1);
1452                           $$ = $1;
1453                         }
1454         ;
1455
1456 nonempty_typelist
1457         :       type
1458                 {
1459                   VEC (type_ptr) *typelist = NULL;
1460                   VEC_safe_push (type_ptr, typelist, $1);
1461                   $$ = typelist;
1462                 }
1463         |       nonempty_typelist ',' type
1464                 {
1465                   VEC_safe_push (type_ptr, $1, $3);
1466                   $$ = $1;
1467                 }
1468         ;
1469
1470 ptype   :       typebase
1471         |       ptype abs_decl
1472                 {
1473                   push_type_stack ($2);
1474                   $$ = follow_types ($1);
1475                 }
1476         ;
1477
1478 conversion_type_id: typebase conversion_declarator
1479                 { $$ = follow_types ($1); }
1480         ;
1481
1482 conversion_declarator:  /* Nothing.  */
1483         | ptr_operator conversion_declarator
1484         ;
1485
1486 const_and_volatile:     CONST_KEYWORD VOLATILE_KEYWORD
1487         |               VOLATILE_KEYWORD CONST_KEYWORD
1488         ;
1489
1490 const_or_volatile_noopt:        const_and_volatile
1491                         { insert_type (tp_const);
1492                           insert_type (tp_volatile);
1493                         }
1494         |               CONST_KEYWORD
1495                         { insert_type (tp_const); }
1496         |               VOLATILE_KEYWORD
1497                         { insert_type (tp_volatile); }
1498         ;
1499
1500 operator:       OPERATOR NEW
1501                         { $$ = operator_stoken (" new"); }
1502         |       OPERATOR DELETE
1503                         { $$ = operator_stoken (" delete"); }
1504         |       OPERATOR NEW '[' ']'
1505                         { $$ = operator_stoken (" new[]"); }
1506         |       OPERATOR DELETE '[' ']'
1507                         { $$ = operator_stoken (" delete[]"); }
1508         |       OPERATOR NEW OBJC_LBRAC ']'
1509                         { $$ = operator_stoken (" new[]"); }
1510         |       OPERATOR DELETE OBJC_LBRAC ']'
1511                         { $$ = operator_stoken (" delete[]"); }
1512         |       OPERATOR '+'
1513                         { $$ = operator_stoken ("+"); }
1514         |       OPERATOR '-'
1515                         { $$ = operator_stoken ("-"); }
1516         |       OPERATOR '*'
1517                         { $$ = operator_stoken ("*"); }
1518         |       OPERATOR '/'
1519                         { $$ = operator_stoken ("/"); }
1520         |       OPERATOR '%'
1521                         { $$ = operator_stoken ("%"); }
1522         |       OPERATOR '^'
1523                         { $$ = operator_stoken ("^"); }
1524         |       OPERATOR '&'
1525                         { $$ = operator_stoken ("&"); }
1526         |       OPERATOR '|'
1527                         { $$ = operator_stoken ("|"); }
1528         |       OPERATOR '~'
1529                         { $$ = operator_stoken ("~"); }
1530         |       OPERATOR '!'
1531                         { $$ = operator_stoken ("!"); }
1532         |       OPERATOR '='
1533                         { $$ = operator_stoken ("="); }
1534         |       OPERATOR '<'
1535                         { $$ = operator_stoken ("<"); }
1536         |       OPERATOR '>'
1537                         { $$ = operator_stoken (">"); }
1538         |       OPERATOR ASSIGN_MODIFY
1539                         { const char *op = "unknown";
1540                           switch ($2)
1541                             {
1542                             case BINOP_RSH:
1543                               op = ">>=";
1544                               break;
1545                             case BINOP_LSH:
1546                               op = "<<=";
1547                               break;
1548                             case BINOP_ADD:
1549                               op = "+=";
1550                               break;
1551                             case BINOP_SUB:
1552                               op = "-=";
1553                               break;
1554                             case BINOP_MUL:
1555                               op = "*=";
1556                               break;
1557                             case BINOP_DIV:
1558                               op = "/=";
1559                               break;
1560                             case BINOP_REM:
1561                               op = "%=";
1562                               break;
1563                             case BINOP_BITWISE_IOR:
1564                               op = "|=";
1565                               break;
1566                             case BINOP_BITWISE_AND:
1567                               op = "&=";
1568                               break;
1569                             case BINOP_BITWISE_XOR:
1570                               op = "^=";
1571                               break;
1572                             default:
1573                               break;
1574                             }
1575
1576                           $$ = operator_stoken (op);
1577                         }
1578         |       OPERATOR LSH
1579                         { $$ = operator_stoken ("<<"); }
1580         |       OPERATOR RSH
1581                         { $$ = operator_stoken (">>"); }
1582         |       OPERATOR EQUAL
1583                         { $$ = operator_stoken ("=="); }
1584         |       OPERATOR NOTEQUAL
1585                         { $$ = operator_stoken ("!="); }
1586         |       OPERATOR LEQ
1587                         { $$ = operator_stoken ("<="); }
1588         |       OPERATOR GEQ
1589                         { $$ = operator_stoken (">="); }
1590         |       OPERATOR ANDAND
1591                         { $$ = operator_stoken ("&&"); }
1592         |       OPERATOR OROR
1593                         { $$ = operator_stoken ("||"); }
1594         |       OPERATOR INCREMENT
1595                         { $$ = operator_stoken ("++"); }
1596         |       OPERATOR DECREMENT
1597                         { $$ = operator_stoken ("--"); }
1598         |       OPERATOR ','
1599                         { $$ = operator_stoken (","); }
1600         |       OPERATOR ARROW_STAR
1601                         { $$ = operator_stoken ("->*"); }
1602         |       OPERATOR ARROW
1603                         { $$ = operator_stoken ("->"); }
1604         |       OPERATOR '(' ')'
1605                         { $$ = operator_stoken ("()"); }
1606         |       OPERATOR '[' ']'
1607                         { $$ = operator_stoken ("[]"); }
1608         |       OPERATOR OBJC_LBRAC ']'
1609                         { $$ = operator_stoken ("[]"); }
1610         |       OPERATOR conversion_type_id
1611                         { char *name;
1612                           long length;
1613                           struct ui_file *buf = mem_fileopen ();
1614
1615                           c_print_type ($2, NULL, buf, -1, 0,
1616                                         &type_print_raw_options);
1617                           name = ui_file_xstrdup (buf, &length);
1618                           ui_file_delete (buf);
1619                           $$ = operator_stoken (name);
1620                           free (name);
1621                         }
1622         ;
1623
1624
1625
1626 name    :       NAME { $$ = $1.stoken; }
1627         |       BLOCKNAME { $$ = $1.stoken; }
1628         |       TYPENAME { $$ = $1.stoken; }
1629         |       NAME_OR_INT  { $$ = $1.stoken; }
1630         |       UNKNOWN_CPP_NAME  { $$ = $1.stoken; }
1631         |       operator { $$ = $1; }
1632         ;
1633
1634 name_not_typename :     NAME
1635         |       BLOCKNAME
1636 /* These would be useful if name_not_typename was useful, but it is just
1637    a fake for "variable", so these cause reduce/reduce conflicts because
1638    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1639    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
1640    context where only a name could occur, this might be useful.
1641         |       NAME_OR_INT
1642  */
1643         |       operator
1644                         {
1645                           struct field_of_this_result is_a_field_of_this;
1646
1647                           $$.stoken = $1;
1648                           $$.sym = lookup_symbol ($1.ptr,
1649                                                   expression_context_block,
1650                                                   VAR_DOMAIN,
1651                                                   &is_a_field_of_this);
1652                           $$.is_a_field_of_this
1653                             = is_a_field_of_this.type != NULL;
1654                         }
1655         |       UNKNOWN_CPP_NAME
1656         ;
1657
1658 %%
1659
1660 /* Like write_exp_string, but prepends a '~'.  */
1661
1662 static void
1663 write_destructor_name (struct parser_state *par_state, struct stoken token)
1664 {
1665   char *copy = alloca (token.length + 1);
1666
1667   copy[0] = '~';
1668   memcpy (&copy[1], token.ptr, token.length);
1669
1670   token.ptr = copy;
1671   ++token.length;
1672
1673   write_exp_string (par_state, token);
1674 }
1675
1676 /* Returns a stoken of the operator name given by OP (which does not
1677    include the string "operator").  */
1678 static struct stoken
1679 operator_stoken (const char *op)
1680 {
1681   static const char *operator_string = "operator";
1682   struct stoken st = { NULL, 0 };
1683   char *buf;
1684
1685   st.length = strlen (operator_string) + strlen (op);
1686   buf = malloc (st.length + 1);
1687   strcpy (buf, operator_string);
1688   strcat (buf, op);
1689   st.ptr = buf;
1690
1691   /* The toplevel (c_parse) will free the memory allocated here.  */
1692   make_cleanup (free, buf);
1693   return st;
1694 };
1695
1696 /* Validate a parameter typelist.  */
1697
1698 static void
1699 check_parameter_typelist (VEC (type_ptr) *params)
1700 {
1701   struct type *type;
1702   int ix;
1703
1704   for (ix = 0; VEC_iterate (type_ptr, params, ix, type); ++ix)
1705     {
1706       if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
1707         {
1708           if (ix == 0)
1709             {
1710               if (VEC_length (type_ptr, params) == 1)
1711                 {
1712                   /* Ok.  */
1713                   break;
1714                 }
1715               VEC_free (type_ptr, params);
1716               error (_("parameter types following 'void'"));
1717             }
1718           else
1719             {
1720               VEC_free (type_ptr, params);
1721               error (_("'void' invalid as parameter type"));
1722             }
1723         }
1724     }
1725 }
1726
1727 /* Take care of parsing a number (anything that starts with a digit).
1728    Set yylval and return the token type; update lexptr.
1729    LEN is the number of characters in it.  */
1730
1731 /*** Needs some error checking for the float case ***/
1732
1733 static int
1734 parse_number (struct parser_state *par_state,
1735               const char *buf, int len, int parsed_float, YYSTYPE *putithere)
1736 {
1737   /* FIXME: Shouldn't these be unsigned?  We don't deal with negative values
1738      here, and we do kind of silly things like cast to unsigned.  */
1739   LONGEST n = 0;
1740   LONGEST prevn = 0;
1741   ULONGEST un;
1742
1743   int i = 0;
1744   int c;
1745   int base = input_radix;
1746   int unsigned_p = 0;
1747
1748   /* Number of "L" suffixes encountered.  */
1749   int long_p = 0;
1750
1751   /* We have found a "L" or "U" suffix.  */
1752   int found_suffix = 0;
1753
1754   ULONGEST high_bit;
1755   struct type *signed_type;
1756   struct type *unsigned_type;
1757   char *p;
1758
1759   p = alloca (len);
1760   memcpy (p, buf, len);
1761
1762   if (parsed_float)
1763     {
1764       /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
1765          point.  Return DECFLOAT.  */
1766
1767       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1768         {
1769           p[len - 2] = '\0';
1770           putithere->typed_val_decfloat.type
1771             = parse_type (par_state)->builtin_decfloat;
1772           decimal_from_string (putithere->typed_val_decfloat.val, 4,
1773                                gdbarch_byte_order (parse_gdbarch (par_state)),
1774                                p);
1775           p[len - 2] = 'd';
1776           return DECFLOAT;
1777         }
1778
1779       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1780         {
1781           p[len - 2] = '\0';
1782           putithere->typed_val_decfloat.type
1783             = parse_type (par_state)->builtin_decdouble;
1784           decimal_from_string (putithere->typed_val_decfloat.val, 8,
1785                                gdbarch_byte_order (parse_gdbarch (par_state)),
1786                                p);
1787           p[len - 2] = 'd';
1788           return DECFLOAT;
1789         }
1790
1791       if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1792         {
1793           p[len - 2] = '\0';
1794           putithere->typed_val_decfloat.type
1795             = parse_type (par_state)->builtin_declong;
1796           decimal_from_string (putithere->typed_val_decfloat.val, 16,
1797                                gdbarch_byte_order (parse_gdbarch (par_state)),
1798                                p);
1799           p[len - 2] = 'd';
1800           return DECFLOAT;
1801         }
1802
1803       if (! parse_c_float (parse_gdbarch (par_state), p, len,
1804                            &putithere->typed_val_float.dval,
1805                            &putithere->typed_val_float.type))
1806         return ERROR;
1807       return FLOAT;
1808     }
1809
1810   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1811   if (p[0] == '0')
1812     switch (p[1])
1813       {
1814       case 'x':
1815       case 'X':
1816         if (len >= 3)
1817           {
1818             p += 2;
1819             base = 16;
1820             len -= 2;
1821           }
1822         break;
1823
1824       case 'b':
1825       case 'B':
1826         if (len >= 3)
1827           {
1828             p += 2;
1829             base = 2;
1830             len -= 2;
1831           }
1832         break;
1833
1834       case 't':
1835       case 'T':
1836       case 'd':
1837       case 'D':
1838         if (len >= 3)
1839           {
1840             p += 2;
1841             base = 10;
1842             len -= 2;
1843           }
1844         break;
1845
1846       default:
1847         base = 8;
1848         break;
1849       }
1850
1851   while (len-- > 0)
1852     {
1853       c = *p++;
1854       if (c >= 'A' && c <= 'Z')
1855         c += 'a' - 'A';
1856       if (c != 'l' && c != 'u')
1857         n *= base;
1858       if (c >= '0' && c <= '9')
1859         {
1860           if (found_suffix)
1861             return ERROR;
1862           n += i = c - '0';
1863         }
1864       else
1865         {
1866           if (base > 10 && c >= 'a' && c <= 'f')
1867             {
1868               if (found_suffix)
1869                 return ERROR;
1870               n += i = c - 'a' + 10;
1871             }
1872           else if (c == 'l')
1873             {
1874               ++long_p;
1875               found_suffix = 1;
1876             }
1877           else if (c == 'u')
1878             {
1879               unsigned_p = 1;
1880               found_suffix = 1;
1881             }
1882           else
1883             return ERROR;       /* Char not a digit */
1884         }
1885       if (i >= base)
1886         return ERROR;           /* Invalid digit in this base */
1887
1888       /* Portably test for overflow (only works for nonzero values, so make
1889          a second check for zero).  FIXME: Can't we just make n and prevn
1890          unsigned and avoid this?  */
1891       if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1892         unsigned_p = 1;         /* Try something unsigned */
1893
1894       /* Portably test for unsigned overflow.
1895          FIXME: This check is wrong; for example it doesn't find overflow
1896          on 0x123456789 when LONGEST is 32 bits.  */
1897       if (c != 'l' && c != 'u' && n != 0)
1898         {
1899           if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1900             error (_("Numeric constant too large."));
1901         }
1902       prevn = n;
1903     }
1904
1905   /* An integer constant is an int, a long, or a long long.  An L
1906      suffix forces it to be long; an LL suffix forces it to be long
1907      long.  If not forced to a larger size, it gets the first type of
1908      the above that it fits in.  To figure out whether it fits, we
1909      shift it right and see whether anything remains.  Note that we
1910      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1911      operation, because many compilers will warn about such a shift
1912      (which always produces a zero result).  Sometimes gdbarch_int_bit
1913      or gdbarch_long_bit will be that big, sometimes not.  To deal with
1914      the case where it is we just always shift the value more than
1915      once, with fewer bits each time.  */
1916
1917   un = (ULONGEST)n >> 2;
1918   if (long_p == 0
1919       && (un >> (gdbarch_int_bit (parse_gdbarch (par_state)) - 2)) == 0)
1920     {
1921       high_bit
1922         = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state)) - 1);
1923
1924       /* A large decimal (not hex or octal) constant (between INT_MAX
1925          and UINT_MAX) is a long or unsigned long, according to ANSI,
1926          never an unsigned int, but this code treats it as unsigned
1927          int.  This probably should be fixed.  GCC gives a warning on
1928          such constants.  */
1929
1930       unsigned_type = parse_type (par_state)->builtin_unsigned_int;
1931       signed_type = parse_type (par_state)->builtin_int;
1932     }
1933   else if (long_p <= 1
1934            && (un >> (gdbarch_long_bit (parse_gdbarch (par_state)) - 2)) == 0)
1935     {
1936       high_bit
1937         = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch (par_state)) - 1);
1938       unsigned_type = parse_type (par_state)->builtin_unsigned_long;
1939       signed_type = parse_type (par_state)->builtin_long;
1940     }
1941   else
1942     {
1943       int shift;
1944       if (sizeof (ULONGEST) * HOST_CHAR_BIT
1945           < gdbarch_long_long_bit (parse_gdbarch (par_state)))
1946         /* A long long does not fit in a LONGEST.  */
1947         shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1948       else
1949         shift = (gdbarch_long_long_bit (parse_gdbarch (par_state)) - 1);
1950       high_bit = (ULONGEST) 1 << shift;
1951       unsigned_type = parse_type (par_state)->builtin_unsigned_long_long;
1952       signed_type = parse_type (par_state)->builtin_long_long;
1953     }
1954
1955    putithere->typed_val_int.val = n;
1956
1957    /* If the high bit of the worked out type is set then this number
1958       has to be unsigned. */
1959
1960    if (unsigned_p || (n & high_bit))
1961      {
1962        putithere->typed_val_int.type = unsigned_type;
1963      }
1964    else
1965      {
1966        putithere->typed_val_int.type = signed_type;
1967      }
1968
1969    return INT;
1970 }
1971
1972 /* Temporary obstack used for holding strings.  */
1973 static struct obstack tempbuf;
1974 static int tempbuf_init;
1975
1976 /* Parse a C escape sequence.  The initial backslash of the sequence
1977    is at (*PTR)[-1].  *PTR will be updated to point to just after the
1978    last character of the sequence.  If OUTPUT is not NULL, the
1979    translated form of the escape sequence will be written there.  If
1980    OUTPUT is NULL, no output is written and the call will only affect
1981    *PTR.  If an escape sequence is expressed in target bytes, then the
1982    entire sequence will simply be copied to OUTPUT.  Return 1 if any
1983    character was emitted, 0 otherwise.  */
1984
1985 int
1986 c_parse_escape (const char **ptr, struct obstack *output)
1987 {
1988   const char *tokptr = *ptr;
1989   int result = 1;
1990
1991   /* Some escape sequences undergo character set conversion.  Those we
1992      translate here.  */
1993   switch (*tokptr)
1994     {
1995       /* Hex escapes do not undergo character set conversion, so keep
1996          the escape sequence for later.  */
1997     case 'x':
1998       if (output)
1999         obstack_grow_str (output, "\\x");
2000       ++tokptr;
2001       if (!isxdigit (*tokptr))
2002         error (_("\\x escape without a following hex digit"));
2003       while (isxdigit (*tokptr))
2004         {
2005           if (output)
2006             obstack_1grow (output, *tokptr);
2007           ++tokptr;
2008         }
2009       break;
2010
2011       /* Octal escapes do not undergo character set conversion, so
2012          keep the escape sequence for later.  */
2013     case '0':
2014     case '1':
2015     case '2':
2016     case '3':
2017     case '4':
2018     case '5':
2019     case '6':
2020     case '7':
2021       {
2022         int i;
2023         if (output)
2024           obstack_grow_str (output, "\\");
2025         for (i = 0;
2026              i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9';
2027              ++i)
2028           {
2029             if (output)
2030               obstack_1grow (output, *tokptr);
2031             ++tokptr;
2032           }
2033       }
2034       break;
2035
2036       /* We handle UCNs later.  We could handle them here, but that
2037          would mean a spurious error in the case where the UCN could
2038          be converted to the target charset but not the host
2039          charset.  */
2040     case 'u':
2041     case 'U':
2042       {
2043         char c = *tokptr;
2044         int i, len = c == 'U' ? 8 : 4;
2045         if (output)
2046           {
2047             obstack_1grow (output, '\\');
2048             obstack_1grow (output, *tokptr);
2049           }
2050         ++tokptr;
2051         if (!isxdigit (*tokptr))
2052           error (_("\\%c escape without a following hex digit"), c);
2053         for (i = 0; i < len && isxdigit (*tokptr); ++i)
2054           {
2055             if (output)
2056               obstack_1grow (output, *tokptr);
2057             ++tokptr;
2058           }
2059       }
2060       break;
2061
2062       /* We must pass backslash through so that it does not
2063          cause quoting during the second expansion.  */
2064     case '\\':
2065       if (output)
2066         obstack_grow_str (output, "\\\\");
2067       ++tokptr;
2068       break;
2069
2070       /* Escapes which undergo conversion.  */
2071     case 'a':
2072       if (output)
2073         obstack_1grow (output, '\a');
2074       ++tokptr;
2075       break;
2076     case 'b':
2077       if (output)
2078         obstack_1grow (output, '\b');
2079       ++tokptr;
2080       break;
2081     case 'f':
2082       if (output)
2083         obstack_1grow (output, '\f');
2084       ++tokptr;
2085       break;
2086     case 'n':
2087       if (output)
2088         obstack_1grow (output, '\n');
2089       ++tokptr;
2090       break;
2091     case 'r':
2092       if (output)
2093         obstack_1grow (output, '\r');
2094       ++tokptr;
2095       break;
2096     case 't':
2097       if (output)
2098         obstack_1grow (output, '\t');
2099       ++tokptr;
2100       break;
2101     case 'v':
2102       if (output)
2103         obstack_1grow (output, '\v');
2104       ++tokptr;
2105       break;
2106
2107       /* GCC extension.  */
2108     case 'e':
2109       if (output)
2110         obstack_1grow (output, HOST_ESCAPE_CHAR);
2111       ++tokptr;
2112       break;
2113
2114       /* Backslash-newline expands to nothing at all.  */
2115     case '\n':
2116       ++tokptr;
2117       result = 0;
2118       break;
2119
2120       /* A few escapes just expand to the character itself.  */
2121     case '\'':
2122     case '\"':
2123     case '?':
2124       /* GCC extensions.  */
2125     case '(':
2126     case '{':
2127     case '[':
2128     case '%':
2129       /* Unrecognized escapes turn into the character itself.  */
2130     default:
2131       if (output)
2132         obstack_1grow (output, *tokptr);
2133       ++tokptr;
2134       break;
2135     }
2136   *ptr = tokptr;
2137   return result;
2138 }
2139
2140 /* Parse a string or character literal from TOKPTR.  The string or
2141    character may be wide or unicode.  *OUTPTR is set to just after the
2142    end of the literal in the input string.  The resulting token is
2143    stored in VALUE.  This returns a token value, either STRING or
2144    CHAR, depending on what was parsed.  *HOST_CHARS is set to the
2145    number of host characters in the literal.  */
2146 static int
2147 parse_string_or_char (const char *tokptr, const char **outptr,
2148                       struct typed_stoken *value, int *host_chars)
2149 {
2150   int quote;
2151   enum c_string_type type;
2152   int is_objc = 0;
2153
2154   /* Build the gdb internal form of the input string in tempbuf.  Note
2155      that the buffer is null byte terminated *only* for the
2156      convenience of debugging gdb itself and printing the buffer
2157      contents when the buffer contains no embedded nulls.  Gdb does
2158      not depend upon the buffer being null byte terminated, it uses
2159      the length string instead.  This allows gdb to handle C strings
2160      (as well as strings in other languages) with embedded null
2161      bytes */
2162
2163   if (!tempbuf_init)
2164     tempbuf_init = 1;
2165   else
2166     obstack_free (&tempbuf, NULL);
2167   obstack_init (&tempbuf);
2168
2169   /* Record the string type.  */
2170   if (*tokptr == 'L')
2171     {
2172       type = C_WIDE_STRING;
2173       ++tokptr;
2174     }
2175   else if (*tokptr == 'u')
2176     {
2177       type = C_STRING_16;
2178       ++tokptr;
2179     }
2180   else if (*tokptr == 'U')
2181     {
2182       type = C_STRING_32;
2183       ++tokptr;
2184     }
2185   else if (*tokptr == '@')
2186     {
2187       /* An Objective C string.  */
2188       is_objc = 1;
2189       type = C_STRING;
2190       ++tokptr;
2191     }
2192   else
2193     type = C_STRING;
2194
2195   /* Skip the quote.  */
2196   quote = *tokptr;
2197   if (quote == '\'')
2198     type |= C_CHAR;
2199   ++tokptr;
2200
2201   *host_chars = 0;
2202
2203   while (*tokptr)
2204     {
2205       char c = *tokptr;
2206       if (c == '\\')
2207         {
2208           ++tokptr;
2209           *host_chars += c_parse_escape (&tokptr, &tempbuf);
2210         }
2211       else if (c == quote)
2212         break;
2213       else
2214         {
2215           obstack_1grow (&tempbuf, c);
2216           ++tokptr;
2217           /* FIXME: this does the wrong thing with multi-byte host
2218              characters.  We could use mbrlen here, but that would
2219              make "set host-charset" a bit less useful.  */
2220           ++*host_chars;
2221         }
2222     }
2223
2224   if (*tokptr != quote)
2225     {
2226       if (quote == '"')
2227         error (_("Unterminated string in expression."));
2228       else
2229         error (_("Unmatched single quote."));
2230     }
2231   ++tokptr;
2232
2233   value->type = type;
2234   value->ptr = obstack_base (&tempbuf);
2235   value->length = obstack_object_size (&tempbuf);
2236
2237   *outptr = tokptr;
2238
2239   return quote == '"' ? (is_objc ? NSSTRING : STRING) : CHAR;
2240 }
2241
2242 /* This is used to associate some attributes with a token.  */
2243
2244 enum token_flags
2245 {
2246   /* If this bit is set, the token is C++-only.  */
2247
2248   FLAG_CXX = 1,
2249
2250   /* If this bit is set, the token is conditional: if there is a
2251      symbol of the same name, then the token is a symbol; otherwise,
2252      the token is a keyword.  */
2253
2254   FLAG_SHADOW = 2
2255 };
2256
2257 struct token
2258 {
2259   char *operator;
2260   int token;
2261   enum exp_opcode opcode;
2262   enum token_flags flags;
2263 };
2264
2265 static const struct token tokentab3[] =
2266   {
2267     {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
2268     {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
2269     {"->*", ARROW_STAR, BINOP_END, FLAG_CXX},
2270     {"...", DOTDOTDOT, BINOP_END, 0}
2271   };
2272
2273 static const struct token tokentab2[] =
2274   {
2275     {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
2276     {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
2277     {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
2278     {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
2279     {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
2280     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
2281     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
2282     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
2283     {"++", INCREMENT, BINOP_END, 0},
2284     {"--", DECREMENT, BINOP_END, 0},
2285     {"->", ARROW, BINOP_END, 0},
2286     {"&&", ANDAND, BINOP_END, 0},
2287     {"||", OROR, BINOP_END, 0},
2288     /* "::" is *not* only C++: gdb overrides its meaning in several
2289        different ways, e.g., 'filename'::func, function::variable.  */
2290     {"::", COLONCOLON, BINOP_END, 0},
2291     {"<<", LSH, BINOP_END, 0},
2292     {">>", RSH, BINOP_END, 0},
2293     {"==", EQUAL, BINOP_END, 0},
2294     {"!=", NOTEQUAL, BINOP_END, 0},
2295     {"<=", LEQ, BINOP_END, 0},
2296     {">=", GEQ, BINOP_END, 0},
2297     {".*", DOT_STAR, BINOP_END, FLAG_CXX}
2298   };
2299
2300 /* Identifier-like tokens.  */
2301 static const struct token ident_tokens[] =
2302   {
2303     {"unsigned", UNSIGNED, OP_NULL, 0},
2304     {"template", TEMPLATE, OP_NULL, FLAG_CXX},
2305     {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
2306     {"struct", STRUCT, OP_NULL, 0},
2307     {"signed", SIGNED_KEYWORD, OP_NULL, 0},
2308     {"sizeof", SIZEOF, OP_NULL, 0},
2309     {"double", DOUBLE_KEYWORD, OP_NULL, 0},
2310     {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
2311     {"class", CLASS, OP_NULL, FLAG_CXX},
2312     {"union", UNION, OP_NULL, 0},
2313     {"short", SHORT, OP_NULL, 0},
2314     {"const", CONST_KEYWORD, OP_NULL, 0},
2315     {"enum", ENUM, OP_NULL, 0},
2316     {"long", LONG, OP_NULL, 0},
2317     {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX},
2318     {"int", INT_KEYWORD, OP_NULL, 0},
2319     {"new", NEW, OP_NULL, FLAG_CXX},
2320     {"delete", DELETE, OP_NULL, FLAG_CXX},
2321     {"operator", OPERATOR, OP_NULL, FLAG_CXX},
2322
2323     {"and", ANDAND, BINOP_END, FLAG_CXX},
2324     {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX},
2325     {"bitand", '&', OP_NULL, FLAG_CXX},
2326     {"bitor", '|', OP_NULL, FLAG_CXX},
2327     {"compl", '~', OP_NULL, FLAG_CXX},
2328     {"not", '!', OP_NULL, FLAG_CXX},
2329     {"not_eq", NOTEQUAL, BINOP_END, FLAG_CXX},
2330     {"or", OROR, BINOP_END, FLAG_CXX},
2331     {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX},
2332     {"xor", '^', OP_NULL, FLAG_CXX},
2333     {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX},
2334
2335     {"const_cast", CONST_CAST, OP_NULL, FLAG_CXX },
2336     {"dynamic_cast", DYNAMIC_CAST, OP_NULL, FLAG_CXX },
2337     {"static_cast", STATIC_CAST, OP_NULL, FLAG_CXX },
2338     {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, FLAG_CXX },
2339
2340     {"__typeof__", TYPEOF, OP_TYPEOF, 0 },
2341     {"__typeof", TYPEOF, OP_TYPEOF, 0 },
2342     {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW },
2343     {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX },
2344     {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW },
2345
2346     {"typeid", TYPEID, OP_TYPEID, FLAG_CXX}
2347   };
2348
2349 /* When we find that lexptr (the global var defined in parse.c) is
2350    pointing at a macro invocation, we expand the invocation, and call
2351    scan_macro_expansion to save the old lexptr here and point lexptr
2352    into the expanded text.  When we reach the end of that, we call
2353    end_macro_expansion to pop back to the value we saved here.  The
2354    macro expansion code promises to return only fully-expanded text,
2355    so we don't need to "push" more than one level.
2356
2357    This is disgusting, of course.  It would be cleaner to do all macro
2358    expansion beforehand, and then hand that to lexptr.  But we don't
2359    really know where the expression ends.  Remember, in a command like
2360
2361      (gdb) break *ADDRESS if CONDITION
2362
2363    we evaluate ADDRESS in the scope of the current frame, but we
2364    evaluate CONDITION in the scope of the breakpoint's location.  So
2365    it's simply wrong to try to macro-expand the whole thing at once.  */
2366 static const char *macro_original_text;
2367
2368 /* We save all intermediate macro expansions on this obstack for the
2369    duration of a single parse.  The expansion text may sometimes have
2370    to live past the end of the expansion, due to yacc lookahead.
2371    Rather than try to be clever about saving the data for a single
2372    token, we simply keep it all and delete it after parsing has
2373    completed.  */
2374 static struct obstack expansion_obstack;
2375
2376 static void
2377 scan_macro_expansion (char *expansion)
2378 {
2379   char *copy;
2380
2381   /* We'd better not be trying to push the stack twice.  */
2382   gdb_assert (! macro_original_text);
2383
2384   /* Copy to the obstack, and then free the intermediate
2385      expansion.  */
2386   copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
2387   xfree (expansion);
2388
2389   /* Save the old lexptr value, so we can return to it when we're done
2390      parsing the expanded text.  */
2391   macro_original_text = lexptr;
2392   lexptr = copy;
2393 }
2394
2395
2396 static int
2397 scanning_macro_expansion (void)
2398 {
2399   return macro_original_text != 0;
2400 }
2401
2402
2403 static void
2404 finished_macro_expansion (void)
2405 {
2406   /* There'd better be something to pop back to.  */
2407   gdb_assert (macro_original_text);
2408
2409   /* Pop back to the original text.  */
2410   lexptr = macro_original_text;
2411   macro_original_text = 0;
2412 }
2413
2414
2415 static void
2416 scan_macro_cleanup (void *dummy)
2417 {
2418   if (macro_original_text)
2419     finished_macro_expansion ();
2420
2421   obstack_free (&expansion_obstack, NULL);
2422 }
2423
2424 /* Return true iff the token represents a C++ cast operator.  */
2425
2426 static int
2427 is_cast_operator (const char *token, int len)
2428 {
2429   return (! strncmp (token, "dynamic_cast", len)
2430           || ! strncmp (token, "static_cast", len)
2431           || ! strncmp (token, "reinterpret_cast", len)
2432           || ! strncmp (token, "const_cast", len));
2433 }
2434
2435 /* The scope used for macro expansion.  */
2436 static struct macro_scope *expression_macro_scope;
2437
2438 /* This is set if a NAME token appeared at the very end of the input
2439    string, with no whitespace separating the name from the EOF.  This
2440    is used only when parsing to do field name completion.  */
2441 static int saw_name_at_eof;
2442
2443 /* This is set if the previously-returned token was a structure
2444    operator -- either '.' or ARROW.  This is used only when parsing to
2445    do field name completion.  */
2446 static int last_was_structop;
2447
2448 /* Read one token, getting characters through lexptr.  */
2449
2450 static int
2451 lex_one_token (struct parser_state *par_state, int *is_quoted_name)
2452 {
2453   int c;
2454   int namelen;
2455   unsigned int i;
2456   const char *tokstart;
2457   int saw_structop = last_was_structop;
2458   char *copy;
2459
2460   last_was_structop = 0;
2461   *is_quoted_name = 0;
2462
2463  retry:
2464
2465   /* Check if this is a macro invocation that we need to expand.  */
2466   if (! scanning_macro_expansion ())
2467     {
2468       char *expanded = macro_expand_next (&lexptr,
2469                                           standard_macro_lookup,
2470                                           expression_macro_scope);
2471
2472       if (expanded)
2473         scan_macro_expansion (expanded);
2474     }
2475
2476   prev_lexptr = lexptr;
2477
2478   tokstart = lexptr;
2479   /* See if it is a special token of length 3.  */
2480   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
2481     if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
2482       {
2483         if ((tokentab3[i].flags & FLAG_CXX) != 0
2484             && parse_language (par_state)->la_language != language_cplus)
2485           break;
2486
2487         lexptr += 3;
2488         yylval.opcode = tokentab3[i].opcode;
2489         return tokentab3[i].token;
2490       }
2491
2492   /* See if it is a special token of length 2.  */
2493   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
2494     if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
2495       {
2496         if ((tokentab2[i].flags & FLAG_CXX) != 0
2497             && parse_language (par_state)->la_language != language_cplus)
2498           break;
2499
2500         lexptr += 2;
2501         yylval.opcode = tokentab2[i].opcode;
2502         if (parse_completion && tokentab2[i].token == ARROW)
2503           last_was_structop = 1;
2504         return tokentab2[i].token;
2505       }
2506
2507   switch (c = *tokstart)
2508     {
2509     case 0:
2510       /* If we were just scanning the result of a macro expansion,
2511          then we need to resume scanning the original text.
2512          If we're parsing for field name completion, and the previous
2513          token allows such completion, return a COMPLETE token.
2514          Otherwise, we were already scanning the original text, and
2515          we're really done.  */
2516       if (scanning_macro_expansion ())
2517         {
2518           finished_macro_expansion ();
2519           goto retry;
2520         }
2521       else if (saw_name_at_eof)
2522         {
2523           saw_name_at_eof = 0;
2524           return COMPLETE;
2525         }
2526       else if (saw_structop)
2527         return COMPLETE;
2528       else
2529         return 0;
2530
2531     case ' ':
2532     case '\t':
2533     case '\n':
2534       lexptr++;
2535       goto retry;
2536
2537     case '[':
2538     case '(':
2539       paren_depth++;
2540       lexptr++;
2541       if (parse_language (par_state)->la_language == language_objc
2542           && c == '[')
2543         return OBJC_LBRAC;
2544       return c;
2545
2546     case ']':
2547     case ')':
2548       if (paren_depth == 0)
2549         return 0;
2550       paren_depth--;
2551       lexptr++;
2552       return c;
2553
2554     case ',':
2555       if (comma_terminates
2556           && paren_depth == 0
2557           && ! scanning_macro_expansion ())
2558         return 0;
2559       lexptr++;
2560       return c;
2561
2562     case '.':
2563       /* Might be a floating point number.  */
2564       if (lexptr[1] < '0' || lexptr[1] > '9')
2565         {
2566           if (parse_completion)
2567             last_was_structop = 1;
2568           goto symbol;          /* Nope, must be a symbol. */
2569         }
2570       /* FALL THRU into number case.  */
2571
2572     case '0':
2573     case '1':
2574     case '2':
2575     case '3':
2576     case '4':
2577     case '5':
2578     case '6':
2579     case '7':
2580     case '8':
2581     case '9':
2582       {
2583         /* It's a number.  */
2584         int got_dot = 0, got_e = 0, toktype;
2585         const char *p = tokstart;
2586         int hex = input_radix > 10;
2587
2588         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2589           {
2590             p += 2;
2591             hex = 1;
2592           }
2593         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2594           {
2595             p += 2;
2596             hex = 0;
2597           }
2598
2599         for (;; ++p)
2600           {
2601             /* This test includes !hex because 'e' is a valid hex digit
2602                and thus does not indicate a floating point number when
2603                the radix is hex.  */
2604             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2605               got_dot = got_e = 1;
2606             /* This test does not include !hex, because a '.' always indicates
2607                a decimal floating point number regardless of the radix.  */
2608             else if (!got_dot && *p == '.')
2609               got_dot = 1;
2610             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2611                      && (*p == '-' || *p == '+'))
2612               /* This is the sign of the exponent, not the end of the
2613                  number.  */
2614               continue;
2615             /* We will take any letters or digits.  parse_number will
2616                complain if past the radix, or if L or U are not final.  */
2617             else if ((*p < '0' || *p > '9')
2618                      && ((*p < 'a' || *p > 'z')
2619                                   && (*p < 'A' || *p > 'Z')))
2620               break;
2621           }
2622         toktype = parse_number (par_state, tokstart, p - tokstart,
2623                                 got_dot|got_e, &yylval);
2624         if (toktype == ERROR)
2625           {
2626             char *err_copy = (char *) alloca (p - tokstart + 1);
2627
2628             memcpy (err_copy, tokstart, p - tokstart);
2629             err_copy[p - tokstart] = 0;
2630             error (_("Invalid number \"%s\"."), err_copy);
2631           }
2632         lexptr = p;
2633         return toktype;
2634       }
2635
2636     case '@':
2637       {
2638         const char *p = &tokstart[1];
2639         size_t len = strlen ("entry");
2640
2641         if (parse_language (par_state)->la_language == language_objc)
2642           {
2643             size_t len = strlen ("selector");
2644
2645             if (strncmp (p, "selector", len) == 0
2646                 && (p[len] == '\0' || isspace (p[len])))
2647               {
2648                 lexptr = p + len;
2649                 return SELECTOR;
2650               }
2651             else if (*p == '"')
2652               goto parse_string;
2653           }
2654
2655         while (isspace (*p))
2656           p++;
2657         if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
2658             && p[len] != '_')
2659           {
2660             lexptr = &p[len];
2661             return ENTRY;
2662           }
2663       }
2664       /* FALLTHRU */
2665     case '+':
2666     case '-':
2667     case '*':
2668     case '/':
2669     case '%':
2670     case '|':
2671     case '&':
2672     case '^':
2673     case '~':
2674     case '!':
2675     case '<':
2676     case '>':
2677     case '?':
2678     case ':':
2679     case '=':
2680     case '{':
2681     case '}':
2682     symbol:
2683       lexptr++;
2684       return c;
2685
2686     case 'L':
2687     case 'u':
2688     case 'U':
2689       if (tokstart[1] != '"' && tokstart[1] != '\'')
2690         break;
2691       /* Fall through.  */
2692     case '\'':
2693     case '"':
2694
2695     parse_string:
2696       {
2697         int host_len;
2698         int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
2699                                            &host_len);
2700         if (result == CHAR)
2701           {
2702             if (host_len == 0)
2703               error (_("Empty character constant."));
2704             else if (host_len > 2 && c == '\'')
2705               {
2706                 ++tokstart;
2707                 namelen = lexptr - tokstart - 1;
2708                 *is_quoted_name = 1;
2709
2710                 goto tryname;
2711               }
2712             else if (host_len > 1)
2713               error (_("Invalid character constant."));
2714           }
2715         return result;
2716       }
2717     }
2718
2719   if (!(c == '_' || c == '$'
2720         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2721     /* We must have come across a bad character (e.g. ';').  */
2722     error (_("Invalid character '%c' in expression."), c);
2723
2724   /* It's a name.  See how long it is.  */
2725   namelen = 0;
2726   for (c = tokstart[namelen];
2727        (c == '_' || c == '$' || (c >= '0' && c <= '9')
2728         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
2729     {
2730       /* Template parameter lists are part of the name.
2731          FIXME: This mishandles `print $a<4&&$a>3'.  */
2732
2733       if (c == '<')
2734         {
2735           if (! is_cast_operator (tokstart, namelen))
2736             {
2737               /* Scan ahead to get rest of the template specification.  Note
2738                  that we look ahead only when the '<' adjoins non-whitespace
2739                  characters; for comparison expressions, e.g. "a < b > c",
2740                  there must be spaces before the '<', etc. */
2741
2742               const char *p = find_template_name_end (tokstart + namelen);
2743
2744               if (p)
2745                 namelen = p - tokstart;
2746             }
2747           break;
2748         }
2749       c = tokstart[++namelen];
2750     }
2751
2752   /* The token "if" terminates the expression and is NOT removed from
2753      the input stream.  It doesn't count if it appears in the
2754      expansion of a macro.  */
2755   if (namelen == 2
2756       && tokstart[0] == 'i'
2757       && tokstart[1] == 'f'
2758       && ! scanning_macro_expansion ())
2759     {
2760       return 0;
2761     }
2762
2763   /* For the same reason (breakpoint conditions), "thread N"
2764      terminates the expression.  "thread" could be an identifier, but
2765      an identifier is never followed by a number without intervening
2766      punctuation.  "task" is similar.  Handle abbreviations of these,
2767      similarly to breakpoint.c:find_condition_and_thread.  */
2768   if (namelen >= 1
2769       && (strncmp (tokstart, "thread", namelen) == 0
2770           || strncmp (tokstart, "task", namelen) == 0)
2771       && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
2772       && ! scanning_macro_expansion ())
2773     {
2774       const char *p = tokstart + namelen + 1;
2775
2776       while (*p == ' ' || *p == '\t')
2777         p++;
2778       if (*p >= '0' && *p <= '9')
2779         return 0;
2780     }
2781
2782   lexptr += namelen;
2783
2784   tryname:
2785
2786   yylval.sval.ptr = tokstart;
2787   yylval.sval.length = namelen;
2788
2789   /* Catch specific keywords.  */
2790   copy = copy_name (yylval.sval);
2791   for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
2792     if (strcmp (copy, ident_tokens[i].operator) == 0)
2793       {
2794         if ((ident_tokens[i].flags & FLAG_CXX) != 0
2795             && parse_language (par_state)->la_language != language_cplus)
2796           break;
2797
2798         if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
2799           {
2800             struct field_of_this_result is_a_field_of_this;
2801
2802             if (lookup_symbol (copy, expression_context_block,
2803                                VAR_DOMAIN,
2804                                (parse_language (par_state)->la_language
2805                                 == language_cplus ? &is_a_field_of_this
2806                                 : NULL))
2807                 != NULL)
2808               {
2809                 /* The keyword is shadowed.  */
2810                 break;
2811               }
2812           }
2813
2814         /* It is ok to always set this, even though we don't always
2815            strictly need to.  */
2816         yylval.opcode = ident_tokens[i].opcode;
2817         return ident_tokens[i].token;
2818       }
2819
2820   if (*tokstart == '$')
2821     return VARIABLE;
2822
2823   if (parse_completion && *lexptr == '\0')
2824     saw_name_at_eof = 1;
2825
2826   yylval.ssym.stoken = yylval.sval;
2827   yylval.ssym.sym = NULL;
2828   yylval.ssym.is_a_field_of_this = 0;
2829   return NAME;
2830 }
2831
2832 /* An object of this type is pushed on a FIFO by the "outer" lexer.  */
2833 typedef struct
2834 {
2835   int token;
2836   YYSTYPE value;
2837 } token_and_value;
2838
2839 DEF_VEC_O (token_and_value);
2840
2841 /* A FIFO of tokens that have been read but not yet returned to the
2842    parser.  */
2843 static VEC (token_and_value) *token_fifo;
2844
2845 /* Non-zero if the lexer should return tokens from the FIFO.  */
2846 static int popping;
2847
2848 /* Temporary storage for c_lex; this holds symbol names as they are
2849    built up.  */
2850 static struct obstack name_obstack;
2851
2852 /* Classify a NAME token.  The contents of the token are in `yylval'.
2853    Updates yylval and returns the new token type.  BLOCK is the block
2854    in which lookups start; this can be NULL to mean the global scope.
2855    IS_QUOTED_NAME is non-zero if the name token was originally quoted
2856    in single quotes.  */
2857 static int
2858 classify_name (struct parser_state *par_state, const struct block *block,
2859                int is_quoted_name)
2860 {
2861   struct symbol *sym;
2862   char *copy;
2863   struct field_of_this_result is_a_field_of_this;
2864
2865   copy = copy_name (yylval.sval);
2866
2867   /* Initialize this in case we *don't* use it in this call; that way
2868      we can refer to it unconditionally below.  */
2869   memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));
2870
2871   sym = lookup_symbol (copy, block, VAR_DOMAIN,
2872                        parse_language (par_state)->la_name_of_this
2873                        ? &is_a_field_of_this : NULL);
2874
2875   if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2876     {
2877       yylval.ssym.sym = sym;
2878       yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
2879       return BLOCKNAME;
2880     }
2881   else if (!sym)
2882     {
2883       /* If we found a field of 'this', we might have erroneously
2884          found a constructor where we wanted a type name.  Handle this
2885          case by noticing that we found a constructor and then look up
2886          the type tag instead.  */
2887       if (is_a_field_of_this.type != NULL
2888           && is_a_field_of_this.fn_field != NULL
2889           && TYPE_FN_FIELD_CONSTRUCTOR (is_a_field_of_this.fn_field->fn_fields,
2890                                         0))
2891         {
2892           struct field_of_this_result inner_is_a_field_of_this;
2893
2894           sym = lookup_symbol (copy, block, STRUCT_DOMAIN,
2895                                &inner_is_a_field_of_this);
2896           if (sym != NULL)
2897             {
2898               yylval.tsym.type = SYMBOL_TYPE (sym);
2899               return TYPENAME;
2900             }
2901         }
2902
2903       /* If we found a field, then we want to prefer it over a
2904          filename.  However, if the name was quoted, then it is better
2905          to check for a filename or a block, since this is the only
2906          way the user has of requiring the extension to be used.  */
2907       if (is_a_field_of_this.type == NULL || is_quoted_name)
2908         {
2909           /* See if it's a file name. */
2910           struct symtab *symtab;
2911
2912           symtab = lookup_symtab (copy);
2913           if (symtab)
2914             {
2915               yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab),
2916                                                STATIC_BLOCK);
2917               return FILENAME;
2918             }
2919         }
2920     }
2921
2922   if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2923     {
2924       yylval.tsym.type = SYMBOL_TYPE (sym);
2925       return TYPENAME;
2926     }
2927
2928   yylval.tsym.type
2929     = language_lookup_primitive_type_by_name (parse_language (par_state),
2930                                               parse_gdbarch (par_state),
2931                                               copy);
2932   if (yylval.tsym.type != NULL)
2933     return TYPENAME;
2934
2935   /* See if it's an ObjC classname.  */
2936   if (parse_language (par_state)->la_language == language_objc && !sym)
2937     {
2938       CORE_ADDR Class = lookup_objc_class (parse_gdbarch (par_state), copy);
2939       if (Class)
2940         {
2941           yylval.class.class = Class;
2942           sym = lookup_struct_typedef (copy, expression_context_block, 1);
2943           if (sym)
2944             yylval.class.type = SYMBOL_TYPE (sym);
2945           return CLASSNAME;
2946         }
2947     }
2948
2949   /* Input names that aren't symbols but ARE valid hex numbers, when
2950      the input radix permits them, can be names or numbers depending
2951      on the parse.  Note we support radixes > 16 here.  */
2952   if (!sym
2953       && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
2954           || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
2955     {
2956       YYSTYPE newlval;  /* Its value is ignored.  */
2957       int hextype = parse_number (par_state, copy, yylval.sval.length,
2958                                   0, &newlval);
2959       if (hextype == INT)
2960         {
2961           yylval.ssym.sym = sym;
2962           yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
2963           return NAME_OR_INT;
2964         }
2965     }
2966
2967   /* Any other kind of symbol */
2968   yylval.ssym.sym = sym;
2969   yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
2970
2971   if (sym == NULL
2972       && parse_language (par_state)->la_language == language_cplus
2973       && is_a_field_of_this.type == NULL
2974       && lookup_minimal_symbol (copy, NULL, NULL).minsym == NULL)
2975     return UNKNOWN_CPP_NAME;
2976
2977   return NAME;
2978 }
2979
2980 /* Like classify_name, but used by the inner loop of the lexer, when a
2981    name might have already been seen.  CONTEXT is the context type, or
2982    NULL if this is the first component of a name.  */
2983
2984 static int
2985 classify_inner_name (struct parser_state *par_state,
2986                      const struct block *block, struct type *context)
2987 {
2988   struct type *type;
2989   char *copy;
2990
2991   if (context == NULL)
2992     return classify_name (par_state, block, 0);
2993
2994   type = check_typedef (context);
2995   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
2996       && TYPE_CODE (type) != TYPE_CODE_UNION
2997       && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
2998     return ERROR;
2999
3000   copy = copy_name (yylval.ssym.stoken);
3001   yylval.ssym.sym = cp_lookup_nested_symbol (type, copy, block);
3002
3003   /* If no symbol was found, search for a matching base class named
3004      COPY.  This will allow users to enter qualified names of class members
3005      relative to the `this' pointer.  */
3006   if (yylval.ssym.sym == NULL)
3007     {
3008       struct type *base_type = find_type_baseclass_by_name (type, copy);
3009
3010       if (base_type != NULL)
3011         {
3012           yylval.tsym.type = base_type;
3013           return TYPENAME;
3014         }
3015
3016       return ERROR;
3017     }
3018
3019   switch (SYMBOL_CLASS (yylval.ssym.sym))
3020     {
3021     case LOC_BLOCK:
3022     case LOC_LABEL:
3023       /* cp_lookup_nested_symbol might have accidentally found a constructor
3024          named COPY when we really wanted a base class of the same name.
3025          Double-check this case by looking for a base class.  */
3026       {
3027         struct type *base_type = find_type_baseclass_by_name (type, copy);
3028
3029         if (base_type != NULL)
3030           {
3031             yylval.tsym.type = base_type;
3032             return TYPENAME;
3033           }
3034       }
3035       return ERROR;
3036
3037     case LOC_TYPEDEF:
3038       yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym);;
3039       return TYPENAME;
3040
3041     default:
3042       return NAME;
3043     }
3044   internal_error (__FILE__, __LINE__, _("not reached"));
3045 }
3046
3047 /* The outer level of a two-level lexer.  This calls the inner lexer
3048    to return tokens.  It then either returns these tokens, or
3049    aggregates them into a larger token.  This lets us work around a
3050    problem in our parsing approach, where the parser could not
3051    distinguish between qualified names and qualified types at the
3052    right point.
3053
3054    This approach is still not ideal, because it mishandles template
3055    types.  See the comment in lex_one_token for an example.  However,
3056    this is still an improvement over the earlier approach, and will
3057    suffice until we move to better parsing technology.  */
3058 static int
3059 yylex (void)
3060 {
3061   token_and_value current;
3062   int first_was_coloncolon, last_was_coloncolon;
3063   struct type *context_type = NULL;
3064   int last_to_examine, next_to_examine, checkpoint;
3065   const struct block *search_block;
3066   int is_quoted_name;
3067
3068   if (popping && !VEC_empty (token_and_value, token_fifo))
3069     goto do_pop;
3070   popping = 0;
3071
3072   /* Read the first token and decide what to do.  Most of the
3073      subsequent code is C++-only; but also depends on seeing a "::" or
3074      name-like token.  */
3075   current.token = lex_one_token (pstate, &is_quoted_name);
3076   if (current.token == NAME)
3077     current.token = classify_name (pstate, expression_context_block,
3078                                    is_quoted_name);
3079   if (parse_language (pstate)->la_language != language_cplus
3080       || (current.token != TYPENAME && current.token != COLONCOLON
3081           && current.token != FILENAME))
3082     return current.token;
3083
3084   /* Read any sequence of alternating "::" and name-like tokens into
3085      the token FIFO.  */
3086   current.value = yylval;
3087   VEC_safe_push (token_and_value, token_fifo, &current);
3088   last_was_coloncolon = current.token == COLONCOLON;
3089   while (1)
3090     {
3091       int ignore;
3092
3093       /* We ignore quoted names other than the very first one.
3094          Subsequent ones do not have any special meaning.  */
3095       current.token = lex_one_token (pstate, &ignore);
3096       current.value = yylval;
3097       VEC_safe_push (token_and_value, token_fifo, &current);
3098
3099       if ((last_was_coloncolon && current.token != NAME)
3100           || (!last_was_coloncolon && current.token != COLONCOLON))
3101         break;
3102       last_was_coloncolon = !last_was_coloncolon;
3103     }
3104   popping = 1;
3105
3106   /* We always read one extra token, so compute the number of tokens
3107      to examine accordingly.  */
3108   last_to_examine = VEC_length (token_and_value, token_fifo) - 2;
3109   next_to_examine = 0;
3110
3111   current = *VEC_index (token_and_value, token_fifo, next_to_examine);
3112   ++next_to_examine;
3113
3114   obstack_free (&name_obstack, obstack_base (&name_obstack));
3115   checkpoint = 0;
3116   if (current.token == FILENAME)
3117     search_block = current.value.bval;
3118   else if (current.token == COLONCOLON)
3119     search_block = NULL;
3120   else
3121     {
3122       gdb_assert (current.token == TYPENAME);
3123       search_block = expression_context_block;
3124       obstack_grow (&name_obstack, current.value.sval.ptr,
3125                     current.value.sval.length);
3126       context_type = current.value.tsym.type;
3127       checkpoint = 1;
3128     }
3129
3130   first_was_coloncolon = current.token == COLONCOLON;
3131   last_was_coloncolon = first_was_coloncolon;
3132
3133   while (next_to_examine <= last_to_examine)
3134     {
3135       token_and_value *next;
3136
3137       next = VEC_index (token_and_value, token_fifo, next_to_examine);
3138       ++next_to_examine;
3139
3140       if (next->token == NAME && last_was_coloncolon)
3141         {
3142           int classification;
3143
3144           yylval = next->value;
3145           classification = classify_inner_name (pstate, search_block,
3146                                                 context_type);
3147           /* We keep going until we either run out of names, or until
3148              we have a qualified name which is not a type.  */
3149           if (classification != TYPENAME && classification != NAME)
3150             break;
3151
3152           /* Accept up to this token.  */
3153           checkpoint = next_to_examine;
3154
3155           /* Update the partial name we are constructing.  */
3156           if (context_type != NULL)
3157             {
3158               /* We don't want to put a leading "::" into the name.  */
3159               obstack_grow_str (&name_obstack, "::");
3160             }
3161           obstack_grow (&name_obstack, next->value.sval.ptr,
3162                         next->value.sval.length);
3163
3164           yylval.sval.ptr = obstack_base (&name_obstack);
3165           yylval.sval.length = obstack_object_size (&name_obstack);
3166           current.value = yylval;
3167           current.token = classification;
3168
3169           last_was_coloncolon = 0;
3170
3171           if (classification == NAME)
3172             break;
3173
3174           context_type = yylval.tsym.type;
3175         }
3176       else if (next->token == COLONCOLON && !last_was_coloncolon)
3177         last_was_coloncolon = 1;
3178       else
3179         {
3180           /* We've reached the end of the name.  */
3181           break;
3182         }
3183     }
3184
3185   /* If we have a replacement token, install it as the first token in
3186      the FIFO, and delete the other constituent tokens.  */
3187   if (checkpoint > 0)
3188     {
3189       current.value.sval.ptr = obstack_copy0 (&expansion_obstack,
3190                                               current.value.sval.ptr,
3191                                               current.value.sval.length);
3192
3193       VEC_replace (token_and_value, token_fifo, 0, &current);
3194       if (checkpoint > 1)
3195         VEC_block_remove (token_and_value, token_fifo, 1, checkpoint - 1);
3196     }
3197
3198  do_pop:
3199   current = *VEC_index (token_and_value, token_fifo, 0);
3200   VEC_ordered_remove (token_and_value, token_fifo, 0);
3201   yylval = current.value;
3202   return current.token;
3203 }
3204
3205 int
3206 c_parse (struct parser_state *par_state)
3207 {
3208   int result;
3209   struct cleanup *back_to;
3210
3211   /* Setting up the parser state.  */
3212   gdb_assert (par_state != NULL);
3213   pstate = par_state;
3214
3215   back_to = make_cleanup (free_current_contents, &expression_macro_scope);
3216   make_cleanup_clear_parser_state (&pstate);
3217
3218   /* Set up the scope for macro expansion.  */
3219   expression_macro_scope = NULL;
3220
3221   if (expression_context_block)
3222     expression_macro_scope
3223       = sal_macro_scope (find_pc_line (expression_context_pc, 0));
3224   else
3225     expression_macro_scope = default_macro_scope ();
3226   if (! expression_macro_scope)
3227     expression_macro_scope = user_macro_scope ();
3228
3229   /* Initialize macro expansion code.  */
3230   obstack_init (&expansion_obstack);
3231   gdb_assert (! macro_original_text);
3232   make_cleanup (scan_macro_cleanup, 0);
3233
3234   make_cleanup_restore_integer (&yydebug);
3235   yydebug = parser_debug;
3236
3237   /* Initialize some state used by the lexer.  */
3238   last_was_structop = 0;
3239   saw_name_at_eof = 0;
3240
3241   VEC_free (token_and_value, token_fifo);
3242   popping = 0;
3243   obstack_init (&name_obstack);
3244   make_cleanup_obstack_free (&name_obstack);
3245
3246   result = yyparse ();
3247   do_cleanups (back_to);
3248
3249   return result;
3250 }
3251
3252 #ifdef YYBISON
3253
3254 /* This is called via the YYPRINT macro when parser debugging is
3255    enabled.  It prints a token's value.  */
3256
3257 static void
3258 c_print_token (FILE *file, int type, YYSTYPE value)
3259 {
3260   switch (type)
3261     {
3262     case INT:
3263       fprintf (file, "typed_val_int<%s, %s>",
3264                TYPE_SAFE_NAME (value.typed_val_int.type),
3265                pulongest (value.typed_val_int.val));
3266       break;
3267
3268     case CHAR:
3269     case STRING:
3270       {
3271         char *copy = alloca (value.tsval.length + 1);
3272
3273         memcpy (copy, value.tsval.ptr, value.tsval.length);
3274         copy[value.tsval.length] = '\0';
3275
3276         fprintf (file, "tsval<type=%d, %s>", value.tsval.type, copy);
3277       }
3278       break;
3279
3280     case NSSTRING:
3281     case VARIABLE:
3282       fprintf (file, "sval<%s>", copy_name (value.sval));
3283       break;
3284
3285     case TYPENAME:
3286       fprintf (file, "tsym<type=%s, name=%s>",
3287                TYPE_SAFE_NAME (value.tsym.type),
3288                copy_name (value.tsym.stoken));
3289       break;
3290
3291     case NAME:
3292     case UNKNOWN_CPP_NAME:
3293     case NAME_OR_INT:
3294     case BLOCKNAME:
3295       fprintf (file, "ssym<name=%s, sym=%s, field_of_this=%d>",
3296                copy_name (value.ssym.stoken),
3297                (value.ssym.sym == NULL
3298                 ? "(null)" : SYMBOL_PRINT_NAME (value.ssym.sym)),
3299                value.ssym.is_a_field_of_this);
3300       break;
3301
3302     case FILENAME:
3303       fprintf (file, "bval<%s>", host_address_to_string (value.bval));
3304       break;
3305     }
3306 }
3307
3308 #endif
3309
3310 void
3311 yyerror (char *msg)
3312 {
3313   if (prev_lexptr)
3314     lexptr = prev_lexptr;
3315
3316   error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
3317 }