gdb/expread.y

   1 /* Parse C expressions for GDB.
   2    Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19 \f
  20 /* Parse a C expression from text in a string,
  21    and return the result as a  struct expression  pointer.
  22    That structure contains arithmetic operations in reverse polish,
  23    with constants represented by operations that are followed by special data.
  24    See expression.h for the details of the format.
  25    What is important here is that it can be built up sequentially
  26    during the process of parsing; the lower levels of the tree always
  27    come first in the result.  */
  28
  29 %{
  30 #include <stdio.h>
  31 #include "defs.h"
  32 #include "param.h"
  33 #include "symtab.h"
  34 #include "frame.h"
  35 #include "expression.h"
  36 #include "value.h"
  37 #include "command.h"
  38
  39 static struct expression *expout;
  40 static int expout_size;
  41 static int expout_ptr;
  42
  43 static int yylex ();
  44 static void yyerror ();
  45 static void write_exp_elt ();
  46 static void write_exp_elt_opcode ();
  47 static void write_exp_elt_sym ();
  48 static void write_exp_elt_longcst ();
  49 static void write_exp_elt_dblcst ();
  50 static void write_exp_elt_type ();
  51 static void write_exp_elt_intern ();
  52 static void write_exp_string ();
  53 static void start_arglist ();
  54 static int end_arglist ();
  55 static void free_funcalls ();
  56 static char *copy_name ();
  57 static int parse_number ();
  58
  59 /* If this is nonzero, this block is used as the lexical context
  60    for symbol names.  */
  61
  62 static struct block *expression_context_block;
  63
  64 /* The innermost context required by the stack and register variables
  65    we've encountered so far. */
  66 struct block *innermost_block;
  67
  68 /* The block in which the most recently discovered symbol was found. */
  69 struct block *block_found;
  70
  71 /* Number of arguments seen so far in innermost function call.  */
  72 static int arglist_len;
  73
  74 /* Data structure for saving values of arglist_len
  75    for function calls whose arguments contain other function calls.  */
  76
  77 struct funcall
  78   {
  79     struct funcall *next;
  80     int arglist_len;
  81   };
  82
  83 struct funcall *funcall_chain;
  84
  85 /* This kind of datum is used to represent the name
  86    of a symbol token.  */
  87
  88 struct stoken
  89   {
  90     char *ptr;
  91     int length;
  92   };
  93
  94 struct ttype
  95   {
  96     struct stoken stoken;
  97     struct type *type;
  98   };
  99
 100 struct symtoken
 101   {
 102     struct stoken stoken;
 103     struct symbol *sym;
 104     int is_a_field_of_this;
 105   };
 106
 107 /* For parsing of complicated types.
 108    An array should be preceded in the list by the size of the array.  */
 109 enum type_pieces
 110   {tp_end = -1, tp_pointer, tp_reference, tp_array, tp_function};
 111 /* The stack can contain either an enum type_pieces or an int.  */
 112 union type_stack_elt {
 113   enum type_pieces piece;
 114   int int_val;
 115 };
 116 static union type_stack_elt *type_stack;
 117 static int type_stack_depth, type_stack_size;
 118
 119 static void push_type ();
 120 static void push_type_int ();
 121 static enum type_pieces pop_type ();
 122 static int pop_type_int ();
 123
 124 /* Allow debugging of parsing.  */
 125 #define YYDEBUG 1
 126 %}
 127
 128 /* Although the yacc "value" of an expression is not used,
 129    since the result is stored in the structure being created,
 130    other node types do have values.  */
 131
 132 %union
 133   {
 134     LONGEST lval;
 135     unsigned LONGEST ulval;
 136     double dval;
 137     struct symbol *sym;
 138     struct type *tval;
 139     struct stoken sval;
 140     struct ttype tsym;
 141     struct symtoken ssym;
 142     int voidval;
 143     struct block *bval;
 144     enum exp_opcode opcode;
 145     struct internalvar *ivar;
 146
 147     struct type **tvec;
 148     int *ivec;
 149   }
 150
 151 %type <voidval> exp exp1 start variable
 152 %type <tval> type typebase
 153 %type <tvec> nonempty_typelist
 154 %type <bval> block
 155
 156 /* Fancy type parsing.  */
 157 %type <voidval> func_mod direct_abs_decl abs_decl
 158 %type <tval> ptype
 159 %type <lval> array_mod
 160
 161 %token <lval> INT CHAR
 162 %token <ulval> UINT
 163 %token <dval> FLOAT
 164
 165 /* Both NAME and TYPENAME tokens represent symbols in the input,
 166    and both convey their data as strings.
 167    But a TYPENAME is a string that happens to be defined as a typedef
 168    or builtin type name (such as int or char)
 169    and a NAME is any other symbol.
 170
 171    Contexts where this distinction is not important can use the
 172    nonterminal "name", which matches either NAME or TYPENAME.  */
 173
 174 %token <sval> STRING
 175 %token <ssym> NAME BLOCKNAME
 176 %token <tsym> TYPENAME
 177 %type <sval> name
 178 %type <ssym> name_not_typename
 179 %type <tsym> typename
 180
 181 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
 182    but which would parse as a valid number in the current input radix.
 183    E.g. "c" when input_radix==16.  Depending on the parse, it will be
 184    turned into a name or into a number.  NAME_OR_UINT ditto.  */
 185
 186 %token <ssym> NAME_OR_INT NAME_OR_UINT
 187
 188 %token STRUCT UNION ENUM SIZEOF UNSIGNED COLONCOLON
 189 %token ERROR
 190
 191 /* Special type cases, put in to allow the parser to distinguish different
 192    legal basetypes.  */
 193 %token SIGNED LONG SHORT INT_KEYWORD
 194
 195 %token <lval> LAST REGNAME
 196
 197 %token <ivar> VARIABLE
 198
 199 %token <opcode> ASSIGN_MODIFY
 200
 201 /* C++ */
 202 %token THIS
 203
 204 %left ','
 205 %left ABOVE_COMMA
 206 %right '=' ASSIGN_MODIFY
 207 %right '?'
 208 %left OR
 209 %left AND
 210 %left '|'
 211 %left '^'
 212 %left '&'
 213 %left EQUAL NOTEQUAL
 214 %left '<' '>' LEQ GEQ
 215 %left LSH RSH
 216 %left '@'
 217 %left '+' '-'
 218 %left '*' '/' '%'
 219 %right UNARY INCREMENT DECREMENT
 220 %right ARROW '.' '[' '('
 221 %left COLONCOLON
 222 \f
 223 %%
 224
 225 start   :       exp1
 226         ;
 227
 228 /* Expressions, including the comma operator.  */
 229 exp1    :       exp
 230         |       exp1 ',' exp
 231                         { write_exp_elt_opcode (BINOP_COMMA); }
 232         ;
 233
 234 /* Expressions, not including the comma operator.  */
 235 exp     :       '*' exp    %prec UNARY
 236                         { write_exp_elt_opcode (UNOP_IND); }
 237
 238 exp     :       '&' exp    %prec UNARY
 239                         { write_exp_elt_opcode (UNOP_ADDR); }
 240
 241 exp     :       '-' exp    %prec UNARY
 242                         { write_exp_elt_opcode (UNOP_NEG); }
 243         ;
 244
 245 exp     :       '!' exp    %prec UNARY
 246                         { write_exp_elt_opcode (UNOP_ZEROP); }
 247         ;
 248
 249 exp     :       '~' exp    %prec UNARY
 250                         { write_exp_elt_opcode (UNOP_LOGNOT); }
 251         ;
 252
 253 exp     :       INCREMENT exp    %prec UNARY
 254                         { write_exp_elt_opcode (UNOP_PREINCREMENT); }
 255         ;
 256
 257 exp     :       DECREMENT exp    %prec UNARY
 258                         { write_exp_elt_opcode (UNOP_PREDECREMENT); }
 259         ;
 260
 261 exp     :       exp INCREMENT    %prec UNARY
 262                         { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
 263         ;
 264
 265 exp     :       exp DECREMENT    %prec UNARY
 266                         { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
 267         ;
 268
 269 exp     :       SIZEOF exp       %prec UNARY
 270                         { write_exp_elt_opcode (UNOP_SIZEOF); }
 271         ;
 272
 273 exp     :       exp ARROW name
 274                         { write_exp_elt_opcode (STRUCTOP_PTR);
 275                           write_exp_string ($3);
 276                           write_exp_elt_opcode (STRUCTOP_PTR); }
 277         ;
 278
 279 exp     :       exp ARROW '*' exp
 280                         { write_exp_elt_opcode (STRUCTOP_MPTR); }
 281         ;
 282
 283 exp     :       exp '.' name
 284                         { write_exp_elt_opcode (STRUCTOP_STRUCT);
 285                           write_exp_string ($3);
 286                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
 287         ;
 288
 289 exp     :       exp '.' '*' exp
 290                         { write_exp_elt_opcode (STRUCTOP_MEMBER); }
 291         ;
 292
 293 exp     :       exp '[' exp1 ']'
 294                         { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
 295         ;
 296
 297 exp     :       exp '('
 298                         /* This is to save the value of arglist_len
 299                            being accumulated by an outer function call.  */
 300                         { start_arglist (); }
 301                 arglist ')'     %prec ARROW
 302                         { write_exp_elt_opcode (OP_FUNCALL);
 303                           write_exp_elt_longcst ((LONGEST) end_arglist ());
 304                           write_exp_elt_opcode (OP_FUNCALL); }
 305         ;
 306
 307 arglist :
 308         ;
 309
 310 arglist :       exp
 311                         { arglist_len = 1; }
 312         ;
 313
 314 arglist :       arglist ',' exp   %prec ABOVE_COMMA
 315                         { arglist_len++; }
 316         ;
 317
 318 exp     :       '{' type '}' exp  %prec UNARY
 319                         { write_exp_elt_opcode (UNOP_MEMVAL);
 320                           write_exp_elt_type ($2);
 321                           write_exp_elt_opcode (UNOP_MEMVAL); }
 322         ;
 323
 324 exp     :       '(' type ')' exp  %prec UNARY
 325                         { write_exp_elt_opcode (UNOP_CAST);
 326                           write_exp_elt_type ($2);
 327                           write_exp_elt_opcode (UNOP_CAST); }
 328         ;
 329
 330 exp     :       '(' exp1 ')'
 331                         { }
 332         ;
 333
 334 /* Binary operators in order of decreasing precedence.  */
 335
 336 exp     :       exp '@' exp
 337                         { write_exp_elt_opcode (BINOP_REPEAT); }
 338         ;
 339
 340 exp     :       exp '*' exp
 341                         { write_exp_elt_opcode (BINOP_MUL); }
 342         ;
 343
 344 exp     :       exp '/' exp
 345                         { write_exp_elt_opcode (BINOP_DIV); }
 346         ;
 347
 348 exp     :       exp '%' exp
 349                         { write_exp_elt_opcode (BINOP_REM); }
 350         ;
 351
 352 exp     :       exp '+' exp
 353                         { write_exp_elt_opcode (BINOP_ADD); }
 354         ;
 355
 356 exp     :       exp '-' exp
 357                         { write_exp_elt_opcode (BINOP_SUB); }
 358         ;
 359
 360 exp     :       exp LSH exp
 361                         { write_exp_elt_opcode (BINOP_LSH); }
 362         ;
 363
 364 exp     :       exp RSH exp
 365                         { write_exp_elt_opcode (BINOP_RSH); }
 366         ;
 367
 368 exp     :       exp EQUAL exp
 369                         { write_exp_elt_opcode (BINOP_EQUAL); }
 370         ;
 371
 372 exp     :       exp NOTEQUAL exp
 373                         { write_exp_elt_opcode (BINOP_NOTEQUAL); }
 374         ;
 375
 376 exp     :       exp LEQ exp
 377                         { write_exp_elt_opcode (BINOP_LEQ); }
 378         ;
 379
 380 exp     :       exp GEQ exp
 381                         { write_exp_elt_opcode (BINOP_GEQ); }
 382         ;
 383
 384 exp     :       exp '<' exp
 385                         { write_exp_elt_opcode (BINOP_LESS); }
 386         ;
 387
 388 exp     :       exp '>' exp
 389                         { write_exp_elt_opcode (BINOP_GTR); }
 390         ;
 391
 392 exp     :       exp '&' exp
 393                         { write_exp_elt_opcode (BINOP_LOGAND); }
 394         ;
 395
 396 exp     :       exp '^' exp
 397                         { write_exp_elt_opcode (BINOP_LOGXOR); }
 398         ;
 399
 400 exp     :       exp '|' exp
 401                         { write_exp_elt_opcode (BINOP_LOGIOR); }
 402         ;
 403
 404 exp     :       exp AND exp
 405                         { write_exp_elt_opcode (BINOP_AND); }
 406         ;
 407
 408 exp     :       exp OR exp
 409                         { write_exp_elt_opcode (BINOP_OR); }
 410         ;
 411
 412 exp     :       exp '?' exp ':' exp     %prec '?'
 413                         { write_exp_elt_opcode (TERNOP_COND); }
 414         ;
 415
 416 exp     :       exp '=' exp
 417                         { write_exp_elt_opcode (BINOP_ASSIGN); }
 418         ;
 419
 420 exp     :       exp ASSIGN_MODIFY exp
 421                         { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
 422                           write_exp_elt_opcode ($2);
 423                           write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
 424         ;
 425
 426 exp     :       INT
 427                         { write_exp_elt_opcode (OP_LONG);
 428                           if ($1 == (int) $1 || $1 == (unsigned int) $1)
 429                             write_exp_elt_type (builtin_type_int);
 430                           else
 431                             write_exp_elt_type (BUILTIN_TYPE_LONGEST);
 432                           write_exp_elt_longcst ((LONGEST) $1);
 433                           write_exp_elt_opcode (OP_LONG); }
 434         ;
 435
 436 exp     :       NAME_OR_INT
 437                         { YYSTYPE val;
 438                           parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
 439                           write_exp_elt_opcode (OP_LONG);
 440                           if (val.lval == (int) val.lval ||
 441                               val.lval == (unsigned int) val.lval)
 442                             write_exp_elt_type (builtin_type_int);
 443                           else
 444                             write_exp_elt_type (BUILTIN_TYPE_LONGEST);
 445                           write_exp_elt_longcst (val.lval);
 446                           write_exp_elt_opcode (OP_LONG); }
 447         ;
 448
 449 exp     :       UINT
 450                         {
 451                           write_exp_elt_opcode (OP_LONG);
 452                           if ($1 == (unsigned int) $1)
 453                             write_exp_elt_type (builtin_type_unsigned_int);
 454                           else
 455                             write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
 456                           write_exp_elt_longcst ((LONGEST) $1);
 457                           write_exp_elt_opcode (OP_LONG);
 458                         }
 459         ;
 460
 461 exp     :       NAME_OR_UINT
 462                         { YYSTYPE val;
 463                           parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
 464                           write_exp_elt_opcode (OP_LONG);
 465                           if (val.ulval == (unsigned int) val.ulval)
 466                             write_exp_elt_type (builtin_type_unsigned_int);
 467                           else
 468                             write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
 469                           write_exp_elt_longcst ((LONGEST)val.ulval);
 470                           write_exp_elt_opcode (OP_LONG);
 471                         }
 472         ;
 473
 474 exp     :       CHAR
 475                         { write_exp_elt_opcode (OP_LONG);
 476                           write_exp_elt_type (builtin_type_char);
 477                           write_exp_elt_longcst ((LONGEST) $1);
 478                           write_exp_elt_opcode (OP_LONG); }
 479         ;
 480
 481 exp     :       FLOAT
 482                         { write_exp_elt_opcode (OP_DOUBLE);
 483                           write_exp_elt_type (builtin_type_double);
 484                           write_exp_elt_dblcst ($1);
 485                           write_exp_elt_opcode (OP_DOUBLE); }
 486         ;
 487
 488 exp     :       variable
 489         ;
 490
 491 exp     :       LAST
 492                         { write_exp_elt_opcode (OP_LAST);
 493                           write_exp_elt_longcst ((LONGEST) $1);
 494                           write_exp_elt_opcode (OP_LAST); }
 495         ;
 496
 497 exp     :       REGNAME
 498                         { write_exp_elt_opcode (OP_REGISTER);
 499                           write_exp_elt_longcst ((LONGEST) $1);
 500                           write_exp_elt_opcode (OP_REGISTER); }
 501         ;
 502
 503 exp     :       VARIABLE
 504                         { write_exp_elt_opcode (OP_INTERNALVAR);
 505                           write_exp_elt_intern ($1);
 506                           write_exp_elt_opcode (OP_INTERNALVAR); }
 507         ;
 508
 509 exp     :       SIZEOF '(' type ')'     %prec UNARY
 510                         { write_exp_elt_opcode (OP_LONG);
 511                           write_exp_elt_type (builtin_type_int);
 512                           write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
 513                           write_exp_elt_opcode (OP_LONG); }
 514         ;
 515
 516 exp     :       STRING
 517                         { write_exp_elt_opcode (OP_STRING);
 518                           write_exp_string ($1);
 519                           write_exp_elt_opcode (OP_STRING); }
 520         ;
 521
 522 /* C++.  */
 523 exp     :       THIS
 524                         { write_exp_elt_opcode (OP_THIS);
 525                           write_exp_elt_opcode (OP_THIS); }
 526         ;
 527
 528 /* end of C++.  */
 529
 530 block   :       BLOCKNAME
 531                         {
 532                           if ($1.sym != 0)
 533                               $$ = SYMBOL_BLOCK_VALUE ($1.sym);
 534                           else
 535                             {
 536                               struct symtab *tem =
 537                                   lookup_symtab (copy_name ($1.stoken));
 538                               if (tem)
 539                                 $$ = BLOCKVECTOR_BLOCK
 540                                          (BLOCKVECTOR (tem), STATIC_BLOCK);
 541                               else
 542                                 error ("No file or function \"%s\".",
 543                                        copy_name ($1.stoken));
 544                             }
 545                         }
 546         ;
 547
 548 block   :       block COLONCOLON name
 549                         { struct symbol *tem
 550                             = lookup_symbol (copy_name ($3), $1,
 551                                              VAR_NAMESPACE, 0, NULL);
 552                           if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
 553                             error ("No function \"%s\" in specified context.",
 554                                    copy_name ($3));
 555                           $$ = SYMBOL_BLOCK_VALUE (tem); }
 556         ;
 557
 558 variable:       block COLONCOLON name
 559                         { struct symbol *sym;
 560                           sym = lookup_symbol (copy_name ($3), $1,
 561                                                VAR_NAMESPACE, 0, NULL);
 562                           if (sym == 0)
 563                             error ("No symbol \"%s\" in specified context.",
 564                                    copy_name ($3));
 565                           write_exp_elt_opcode (OP_VAR_VALUE);
 566                           write_exp_elt_sym (sym);
 567                           write_exp_elt_opcode (OP_VAR_VALUE); }
 568         ;
 569
 570 variable:       typebase COLONCOLON name
 571                         {
 572                           struct type *type = $1;
 573                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 574                               && TYPE_CODE (type) != TYPE_CODE_UNION)
 575                             error ("`%s' is not defined as an aggregate type.",
 576                                    TYPE_NAME (type));
 577
 578                           write_exp_elt_opcode (OP_SCOPE);
 579                           write_exp_elt_type (type);
 580                           write_exp_string ($3);
 581                           write_exp_elt_opcode (OP_SCOPE);
 582                         }
 583         |       typebase COLONCOLON '~' name
 584                         {
 585                           struct type *type = $1;
 586                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 587                               && TYPE_CODE (type) != TYPE_CODE_UNION)
 588                             error ("`%s' is not defined as an aggregate type.",
 589                                    TYPE_NAME (type));
 590
 591                           if (strcmp (type_name_no_tag (type), $4.ptr))
 592                             error ("invalid destructor `%s::~%s'",
 593                                    type_name_no_tag (type), $4.ptr);
 594
 595                           write_exp_elt_opcode (OP_SCOPE);
 596                           write_exp_elt_type (type);
 597                           write_exp_string ($4);
 598                           write_exp_elt_opcode (OP_SCOPE);
 599                           write_exp_elt_opcode (UNOP_LOGNOT);
 600                         }
 601         |       COLONCOLON name
 602                         {
 603                           char *name = copy_name ($2);
 604                           struct symbol *sym;
 605                           int i;
 606
 607                           sym =
 608                             lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
 609                           if (sym)
 610                             {
 611                               write_exp_elt_opcode (OP_VAR_VALUE);
 612                               write_exp_elt_sym (sym);
 613                               write_exp_elt_opcode (OP_VAR_VALUE);
 614                               break;
 615                             }
 616                           for (i = 0; i < misc_function_count; i++)
 617                             if (!strcmp (misc_function_vector[i].name, name))
 618                               break;
 619
 620                           if (i < misc_function_count)
 621                             {
 622                               enum misc_function_type mft =
 623                                   misc_function_vector[i].type;
 624
 625                               write_exp_elt_opcode (OP_LONG);
 626                               write_exp_elt_type (builtin_type_int);
 627                               write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
 628                               write_exp_elt_opcode (OP_LONG);
 629                               write_exp_elt_opcode (UNOP_MEMVAL);
 630                               if (mft == mf_data || mft == mf_bss)
 631                                 write_exp_elt_type (builtin_type_int);
 632                               else if (mft == mf_text)
 633                                 write_exp_elt_type (lookup_function_type (builtin_type_int));
 634                               else
 635                                 write_exp_elt_type (builtin_type_char);
 636                               write_exp_elt_opcode (UNOP_MEMVAL);
 637                             }
 638                           else
 639                             if (symtab_list == 0
 640                                 && partial_symtab_list == 0)
 641                               error ("No symbol table is loaded.  Use the \"file\" command.");
 642                             else
 643                               error ("No symbol \"%s\" in current context.", name);
 644                         }
 645         ;
 646
 647 variable:       name_not_typename
 648                         { struct symbol *sym = $1.sym;
 649
 650                           if (sym)
 651                             {
 652                               switch (sym->class)
 653                                 {
 654                                 case LOC_REGISTER:
 655                                 case LOC_ARG:
 656                                 case LOC_REF_ARG:
 657                                 case LOC_REGPARM:
 658                                 case LOC_LOCAL:
 659                                 case LOC_LOCAL_ARG:
 660                                   if (innermost_block == 0 ||
 661                                       contained_in (block_found,
 662                                                     innermost_block))
 663                                     innermost_block = block_found;
 664                                 case LOC_UNDEF:
 665                                 case LOC_CONST:
 666                                 case LOC_STATIC:
 667                                 case LOC_TYPEDEF:
 668                                 case LOC_LABEL:
 669                                 case LOC_BLOCK:
 670                                 case LOC_CONST_BYTES:
 671
 672                                   /* In this case the expression can
 673                                      be evaluated regardless of what
 674                                      frame we are in, so there is no
 675                                      need to check for the
 676                                      innermost_block.  These cases are
 677                                      listed so that gcc -Wall will
 678                                      report types that may not have
 679                                      been considered.  */
 680
 681                                   break;
 682                                 }
 683                               write_exp_elt_opcode (OP_VAR_VALUE);
 684                               write_exp_elt_sym (sym);
 685                               write_exp_elt_opcode (OP_VAR_VALUE);
 686                             }
 687                           else if ($1.is_a_field_of_this)
 688                             {
 689                               /* C++: it hangs off of `this'.  Must
 690                                  not inadvertently convert from a method call
 691                                  to data ref.  */
 692                               if (innermost_block == 0 ||
 693                                   contained_in (block_found, innermost_block))
 694                                 innermost_block = block_found;
 695                               write_exp_elt_opcode (OP_THIS);
 696                               write_exp_elt_opcode (OP_THIS);
 697                               write_exp_elt_opcode (STRUCTOP_PTR);
 698                               write_exp_string ($1.stoken);
 699                               write_exp_elt_opcode (STRUCTOP_PTR);
 700                             }
 701                           else
 702                             {
 703                               register int i;
 704                               register char *arg = copy_name ($1.stoken);
 705
 706                                 /* FIXME, this search is linear!  At least
 707                                    optimize the strcmp with a 1-char cmp... */
 708                               for (i = 0; i < misc_function_count; i++)
 709                                 if (!strcmp (misc_function_vector[i].name, arg))
 710                                   break;
 711
 712                               if (i < misc_function_count)
 713                                 {
 714                                   enum misc_function_type mft =
 715                                       misc_function_vector[i].type;
 716
 717                                   write_exp_elt_opcode (OP_LONG);
 718                                   write_exp_elt_type (builtin_type_int);
 719                                   write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address);
 720                                   write_exp_elt_opcode (OP_LONG);
 721                                   write_exp_elt_opcode (UNOP_MEMVAL);
 722                                   if (mft == mf_data || mft == mf_bss)
 723                                     write_exp_elt_type (builtin_type_int);
 724                                   else if (mft == mf_text)
 725                                     write_exp_elt_type (lookup_function_type (builtin_type_int));
 726                                   else
 727                                     write_exp_elt_type (builtin_type_char);
 728                                   write_exp_elt_opcode (UNOP_MEMVAL);
 729                                 }
 730                               else if (symtab_list == 0
 731                                        && partial_symtab_list == 0)
 732                                 error ("No symbol table is loaded.  Use the \"file\" command.");
 733                               else
 734                                 error ("No symbol \"%s\" in current context.",
 735                                        copy_name ($1.stoken));
 736                             }
 737                         }
 738         ;
 739
 740
 741 ptype   :       typebase
 742         |       typebase abs_decl
 743                 {
 744                   /* This is where the interesting stuff happens.  */
 745                   int done = 0;
 746                   int array_size;
 747                   struct type *follow_type = $1;
 748
 749                   while (!done)
 750                     switch (pop_type ())
 751                       {
 752                       case tp_end:
 753                         done = 1;
 754                         break;
 755                       case tp_pointer:
 756                         follow_type = lookup_pointer_type (follow_type);
 757                         break;
 758                       case tp_reference:
 759                         follow_type = lookup_reference_type (follow_type);
 760                         break;
 761                       case tp_array:
 762                         array_size = pop_type_int ();
 763                         if (array_size != -1)
 764                           follow_type = create_array_type (follow_type,
 765                                                            array_size);
 766                         else
 767                           follow_type = lookup_pointer_type (follow_type);
 768                         break;
 769                       case tp_function:
 770                         follow_type = lookup_function_type (follow_type);
 771                         break;
 772                       }
 773                   $$ = follow_type;
 774                 }
 775         ;
 776
 777 abs_decl:       '*'
 778                         { push_type (tp_pointer); $$ = 0; }
 779         |       '*' abs_decl
 780                         { push_type (tp_pointer); $$ = $2; }
 781         |       '&'
 782                         { push_type (tp_reference); $$ = 0; }
 783         |       '&' abs_decl
 784                         { push_type (tp_reference); $$ = $2; }
 785         |       direct_abs_decl
 786         ;
 787
 788 direct_abs_decl: '(' abs_decl ')'
 789                         { $$ = $2; }
 790         |       direct_abs_decl array_mod
 791                         {
 792                           push_type_int ($2);
 793                           push_type (tp_array);
 794                         }
 795         |       array_mod
 796                         {
 797                           push_type_int ($1);
 798                           push_type (tp_array);
 799                           $$ = 0;
 800                         }
 801         |       direct_abs_decl func_mod
 802                         { push_type (tp_function); }
 803         |       func_mod
 804                         { push_type (tp_function); }
 805         ;
 806
 807 array_mod:      '[' ']'
 808                         { $$ = -1; }
 809         |       '[' INT ']'
 810                         { $$ = $2; }
 811         ;
 812
 813 func_mod:       '(' ')'
 814                         { $$ = 0; }
 815         ;
 816
 817 type    :       ptype
 818         |       typebase COLONCOLON '*'
 819                         { $$ = lookup_member_type (builtin_type_int, $1); }
 820         |       type '(' typebase COLONCOLON '*' ')'
 821                         { $$ = lookup_member_type ($1, $3); }
 822         |       type '(' typebase COLONCOLON '*' ')' '(' ')'
 823                         { $$ = lookup_member_type
 824                             (lookup_function_type ($1), $3); }
 825         |       type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
 826                         { $$ = lookup_member_type
 827                             (lookup_function_type ($1), $3);
 828                           free ($8); }
 829         ;
 830
 831 typebase
 832         :       TYPENAME
 833                         { $$ = $1.type; }
 834         |       INT_KEYWORD
 835                         { $$ = builtin_type_int; }
 836         |       LONG
 837                         { $$ = builtin_type_long; }
 838         |       SHORT
 839                         { $$ = builtin_type_short; }
 840         |       LONG INT_KEYWORD
 841                         { $$ = builtin_type_long; }
 842         |       UNSIGNED LONG INT_KEYWORD
 843                         { $$ = builtin_type_unsigned_long; }
 844         |       LONG LONG
 845                         { $$ = builtin_type_long_long; }
 846         |       LONG LONG INT_KEYWORD
 847                         { $$ = builtin_type_long_long; }
 848         |       UNSIGNED LONG LONG
 849                         { $$ = builtin_type_unsigned_long_long; }
 850         |       UNSIGNED LONG LONG INT_KEYWORD
 851                         { $$ = builtin_type_unsigned_long_long; }
 852         |       SHORT INT_KEYWORD
 853                         { $$ = builtin_type_short; }
 854         |       UNSIGNED SHORT INT_KEYWORD
 855                         { $$ = builtin_type_unsigned_short; }
 856         |       STRUCT name
 857                         { $$ = lookup_struct (copy_name ($2),
 858                                               expression_context_block); }
 859         |       UNION name
 860                         { $$ = lookup_union (copy_name ($2),
 861                                              expression_context_block); }
 862         |       ENUM name
 863                         { $$ = lookup_enum (copy_name ($2),
 864                                             expression_context_block); }
 865         |       UNSIGNED typename
 866                         { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
 867         |       UNSIGNED
 868                         { $$ = builtin_type_unsigned_int; }
 869         |       SIGNED typename
 870                         { $$ = $2.type; }
 871         |       SIGNED
 872                         { $$ = builtin_type_int; }
 873         ;
 874
 875 typename:       TYPENAME
 876         |       INT_KEYWORD
 877                 {
 878                   $$.stoken.ptr = "int";
 879                   $$.stoken.length = 3;
 880                   $$.type = builtin_type_int;
 881                 }
 882         |       LONG
 883                 {
 884                   $$.stoken.ptr = "long";
 885                   $$.stoken.length = 4;
 886                   $$.type = builtin_type_long;
 887                 }
 888         |       SHORT
 889                 {
 890                   $$.stoken.ptr = "short";
 891                   $$.stoken.length = 5;
 892                   $$.type = builtin_type_short;
 893                 }
 894         ;
 895
 896 nonempty_typelist
 897         :       type
 898                 { $$ = (struct type **)xmalloc (sizeof (struct type *) * 2);
 899                   $$[0] = (struct type *)0;
 900                   $$[1] = $1;
 901                 }
 902         |       nonempty_typelist ',' type
 903                 { int len = sizeof (struct type *) * ++($<ivec>1[0]);
 904                   $$ = (struct type **)xrealloc ($1, len);
 905                   $$[$<ivec>$[0]] = $3;
 906                 }
 907         ;
 908
 909 name    :       NAME { $$ = $1.stoken; }
 910         |       BLOCKNAME { $$ = $1.stoken; }
 911         |       TYPENAME { $$ = $1.stoken; }
 912         |       NAME_OR_INT  { $$ = $1.stoken; }
 913         |       NAME_OR_UINT  { $$ = $1.stoken; }
 914         ;
 915
 916 name_not_typename :     NAME
 917         |       BLOCKNAME
 918 /* These would be useful if name_not_typename was useful, but it is just
 919    a fake for "variable", so these cause reduce/reduce conflicts because
 920    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
 921    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
 922    context where only a name could occur, this might be useful.
 923         |       NAME_OR_INT
 924         |       NAME_OR_UINT
 925  */
 926         ;
 927
 928 %%
 929 \f
 930 /* Begin counting arguments for a function call,
 931    saving the data about any containing call.  */
 932
 933 static void
 934 start_arglist ()
 935 {
 936   register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall));
 937
 938   new->next = funcall_chain;
 939   new->arglist_len = arglist_len;
 940   arglist_len = 0;
 941   funcall_chain = new;
 942 }
 943
 944 /* Return the number of arguments in a function call just terminated,
 945    and restore the data for the containing function call.  */
 946
 947 static int
 948 end_arglist ()
 949 {
 950   register int val = arglist_len;
 951   register struct funcall *call = funcall_chain;
 952   funcall_chain = call->next;
 953   arglist_len = call->arglist_len;
 954   free (call);
 955   return val;
 956 }
 957
 958 /* Free everything in the funcall chain.
 959    Used when there is an error inside parsing.  */
 960
 961 static void
 962 free_funcalls ()
 963 {
 964   register struct funcall *call, *next;
 965
 966   for (call = funcall_chain; call; call = next)
 967     {
 968       next = call->next;
 969       free (call);
 970     }
 971 }
 972 \f
 973 /* This page contains the functions for adding data to the  struct expression
 974    being constructed.  */
 975
 976 /* Add one element to the end of the expression.  */
 977
 978 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
 979    a register through here */
 980
 981 static void
 982 write_exp_elt (expelt)
 983      union exp_element expelt;
 984 {
 985   if (expout_ptr >= expout_size)
 986     {
 987       expout_size *= 2;
 988       expout = (struct expression *) xrealloc (expout,
 989                                                sizeof (struct expression)
 990                                                + expout_size * sizeof (union exp_element));
 991     }
 992   expout->elts[expout_ptr++] = expelt;
 993 }
 994
 995 static void
 996 write_exp_elt_opcode (expelt)
 997      enum exp_opcode expelt;
 998 {
 999   union exp_element tmp;
1000
1001   tmp.opcode = expelt;
1002
1003   write_exp_elt (tmp);
1004 }
1005
1006 static void
1007 write_exp_elt_sym (expelt)
1008      struct symbol *expelt;
1009 {
1010   union exp_element tmp;
1011
1012   tmp.symbol = expelt;
1013
1014   write_exp_elt (tmp);
1015 }
1016
1017 static void
1018 write_exp_elt_longcst (expelt)
1019      LONGEST expelt;
1020 {
1021   union exp_element tmp;
1022
1023   tmp.longconst = expelt;
1024
1025   write_exp_elt (tmp);
1026 }
1027
1028 static void
1029 write_exp_elt_dblcst (expelt)
1030      double expelt;
1031 {
1032   union exp_element tmp;
1033
1034   tmp.doubleconst = expelt;
1035
1036   write_exp_elt (tmp);
1037 }
1038
1039 static void
1040 write_exp_elt_type (expelt)
1041      struct type *expelt;
1042 {
1043   union exp_element tmp;
1044
1045   tmp.type = expelt;
1046
1047   write_exp_elt (tmp);
1048 }
1049
1050 static void
1051 write_exp_elt_intern (expelt)
1052      struct internalvar *expelt;
1053 {
1054   union exp_element tmp;
1055
1056   tmp.internalvar = expelt;
1057
1058   write_exp_elt (tmp);
1059 }
1060
1061 /* Add a string constant to the end of the expression.
1062    Follow it by its length in bytes, as a separate exp_element.  */
1063
1064 static void
1065 write_exp_string (str)
1066      struct stoken str;
1067 {
1068   register int len = str.length;
1069   register int lenelt
1070     = (len + sizeof (union exp_element)) / sizeof (union exp_element);
1071
1072   expout_ptr += lenelt;
1073
1074   if (expout_ptr >= expout_size)
1075     {
1076       expout_size = max (expout_size * 2, expout_ptr + 10);
1077       expout = (struct expression *)
1078         xrealloc (expout, (sizeof (struct expression)
1079                            + (expout_size * sizeof (union exp_element))));
1080     }
1081   bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len);
1082   ((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
1083   write_exp_elt_longcst ((LONGEST) len);
1084 }
1085 \f
1086 /* During parsing of a C expression, the pointer to the next character
1087    is in this variable.  */
1088
1089 static char *lexptr;
1090
1091 /* Tokens that refer to names do so with explicit pointer and length,
1092    so they can share the storage that lexptr is parsing.
1093
1094    When it is necessary to pass a name to a function that expects
1095    a null-terminated string, the substring is copied out
1096    into a block of storage that namecopy points to.
1097
1098    namecopy is allocated once, guaranteed big enough, for each parsing.  */
1099
1100 static char *namecopy;
1101
1102 /* Current depth in parentheses within the expression.  */
1103
1104 static int paren_depth;
1105
1106 /* Nonzero means stop parsing on first comma (if not within parentheses).  */
1107
1108 static int comma_terminates;
1109
1110 /* Take care of parsing a number (anything that starts with a digit).
1111    Set yylval and return the token type; update lexptr.
1112    LEN is the number of characters in it.  */
1113
1114 /*** Needs some error checking for the float case ***/
1115
1116 static int
1117 parse_number (p, len, parsed_float, putithere)
1118      register char *p;
1119      register int len;
1120      int parsed_float;
1121      YYSTYPE *putithere;
1122 {
1123   register LONGEST n = 0;
1124   register int i;
1125   register int c;
1126   register int base = input_radix;
1127   int unsigned_p = 0;
1128
1129   extern double atof ();
1130
1131   if (parsed_float)
1132     {
1133       /* It's a float since it contains a point or an exponent.  */
1134       putithere->dval = atof (p);
1135       return FLOAT;
1136     }
1137
1138   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1139   if (p[0] == '0')
1140     switch (p[1])
1141       {
1142       case 'x':
1143       case 'X':
1144         if (len >= 3)
1145           {
1146             p += 2;
1147             base = 16;
1148             len -= 2;
1149           }
1150         break;
1151
1152       case 't':
1153       case 'T':
1154       case 'd':
1155       case 'D':
1156         if (len >= 3)
1157           {
1158             p += 2;
1159             base = 10;
1160             len -= 2;
1161           }
1162         break;
1163
1164       default:
1165         base = 8;
1166         break;
1167       }
1168
1169   while (len-- > 0)
1170     {
1171       c = *p++;
1172       if (c >= 'A' && c <= 'Z')
1173         c += 'a' - 'A';
1174       if (c != 'l' && c != 'u')
1175         n *= base;
1176       if (c >= '0' && c <= '9')
1177         n += i = c - '0';
1178       else
1179         {
1180           if (base > 10 && c >= 'a' && c <= 'f')
1181             n += i = c - 'a' + 10;
1182           else if (len == 0 && c == 'l')
1183             ;
1184           else if (len == 0 && c == 'u')
1185             unsigned_p = 1;
1186           else
1187             return ERROR;       /* Char not a digit */
1188         }
1189       if (i >= base)
1190         return ERROR;           /* Invalid digit in this base */
1191     }
1192
1193   if (unsigned_p)
1194     {
1195       putithere->ulval = n;
1196       return UINT;
1197     }
1198   else
1199     {
1200       putithere->lval = n;
1201       return INT;
1202     }
1203 }
1204
1205 struct token
1206 {
1207   char *operator;
1208   int token;
1209   enum exp_opcode opcode;
1210 };
1211
1212 const static struct token tokentab3[] =
1213   {
1214     {">>=", ASSIGN_MODIFY, BINOP_RSH},
1215     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1216   };
1217
1218 const static struct token tokentab2[] =
1219   {
1220     {"+=", ASSIGN_MODIFY, BINOP_ADD},
1221     {"-=", ASSIGN_MODIFY, BINOP_SUB},
1222     {"*=", ASSIGN_MODIFY, BINOP_MUL},
1223     {"/=", ASSIGN_MODIFY, BINOP_DIV},
1224     {"%=", ASSIGN_MODIFY, BINOP_REM},
1225     {"|=", ASSIGN_MODIFY, BINOP_LOGIOR},
1226     {"&=", ASSIGN_MODIFY, BINOP_LOGAND},
1227     {"^=", ASSIGN_MODIFY, BINOP_LOGXOR},
1228     {"++", INCREMENT, BINOP_END},
1229     {"--", DECREMENT, BINOP_END},
1230     {"->", ARROW, BINOP_END},
1231     {"&&", AND, BINOP_END},
1232     {"||", OR, BINOP_END},
1233     {"::", COLONCOLON, BINOP_END},
1234     {"<<", LSH, BINOP_END},
1235     {">>", RSH, BINOP_END},
1236     {"==", EQUAL, BINOP_END},
1237     {"!=", NOTEQUAL, BINOP_END},
1238     {"<=", LEQ, BINOP_END},
1239     {">=", GEQ, BINOP_END}
1240   };
1241
1242 /* assign machine-independent names to certain registers
1243  * (unless overridden by the REGISTER_NAMES table)
1244  */
1245 struct std_regs {
1246         char *name;
1247         int regnum;
1248 } std_regs[] = {
1249 #ifdef PC_REGNUM
1250         { "pc", PC_REGNUM },
1251 #endif
1252 #ifdef FP_REGNUM
1253         { "fp", FP_REGNUM },
1254 #endif
1255 #ifdef SP_REGNUM
1256         { "sp", SP_REGNUM },
1257 #endif
1258 #ifdef PS_REGNUM
1259         { "ps", PS_REGNUM },
1260 #endif
1261 };
1262
1263 #define NUM_STD_REGS (sizeof std_regs / sizeof std_regs[0])
1264
1265 /* Read one token, getting characters through lexptr.  */
1266
1267 static int
1268 yylex ()
1269 {
1270   register int c;
1271   register int namelen;
1272   register unsigned i;
1273   register char *tokstart;
1274
1275  retry:
1276
1277   tokstart = lexptr;
1278   /* See if it is a special token of length 3.  */
1279   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1280     if (!strncmp (tokstart, tokentab3[i].operator, 3))
1281       {
1282         lexptr += 3;
1283         yylval.opcode = tokentab3[i].opcode;
1284         return tokentab3[i].token;
1285       }
1286
1287   /* See if it is a special token of length 2.  */
1288   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1289     if (!strncmp (tokstart, tokentab2[i].operator, 2))
1290       {
1291         lexptr += 2;
1292         yylval.opcode = tokentab2[i].opcode;
1293         return tokentab2[i].token;
1294       }
1295
1296   switch (c = *tokstart)
1297     {
1298     case 0:
1299       return 0;
1300
1301     case ' ':
1302     case '\t':
1303     case '\n':
1304       lexptr++;
1305       goto retry;
1306
1307     case '\'':
1308       lexptr++;
1309       c = *lexptr++;
1310       if (c == '\\')
1311         c = parse_escape (&lexptr);
1312       yylval.lval = c;
1313       c = *lexptr++;
1314       if (c != '\'')
1315         error ("Invalid character constant.");
1316       return CHAR;
1317
1318     case '(':
1319       paren_depth++;
1320       lexptr++;
1321       return c;
1322
1323     case ')':
1324       if (paren_depth == 0)
1325         return 0;
1326       paren_depth--;
1327       lexptr++;
1328       return c;
1329
1330     case ',':
1331       if (comma_terminates && paren_depth == 0)
1332         return 0;
1333       lexptr++;
1334       return c;
1335
1336     case '.':
1337       /* Might be a floating point number.  */
1338       if (lexptr[1] < '0' || lexptr[1] > '9')
1339         goto symbol;            /* Nope, must be a symbol. */
1340       /* FALL THRU into number case.  */
1341
1342     case '0':
1343     case '1':
1344     case '2':
1345     case '3':
1346     case '4':
1347     case '5':
1348     case '6':
1349     case '7':
1350     case '8':
1351     case '9':
1352       {
1353         /* It's a number.  */
1354         int got_dot = 0, got_e = 0, toktype;
1355         register char *p = tokstart;
1356         int hex = input_radix > 10;
1357
1358         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1359           {
1360             p += 2;
1361             hex = 1;
1362           }
1363         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1364           {
1365             p += 2;
1366             hex = 0;
1367           }
1368
1369         for (;; ++p)
1370           {
1371             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1372               got_dot = got_e = 1;
1373             else if (!hex && !got_dot && *p == '.')
1374               got_dot = 1;
1375             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1376                      && (*p == '-' || *p == '+'))
1377               /* This is the sign of the exponent, not the end of the
1378                  number.  */
1379               continue;
1380             /* We will take any letters or digits.  parse_number will
1381                complain if past the radix, or if L or U are not final.  */
1382             else if ((*p < '0' || *p > '9')
1383                      && ((*p < 'a' || *p > 'z')
1384                                   && (*p < 'A' || *p > 'Z')))
1385               break;
1386           }
1387         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1388         if (toktype == ERROR)
1389           {
1390             char *err_copy = (char *) alloca (p - tokstart + 1);
1391
1392             bcopy (tokstart, err_copy, p - tokstart);
1393             err_copy[p - tokstart] = 0;
1394             error ("Invalid number \"%s\".", err_copy);
1395           }
1396         lexptr = p;
1397         return toktype;
1398       }
1399
1400     case '+':
1401     case '-':
1402     case '*':
1403     case '/':
1404     case '%':
1405     case '|':
1406     case '&':
1407     case '^':
1408     case '~':
1409     case '!':
1410     case '@':
1411     case '<':
1412     case '>':
1413     case '[':
1414     case ']':
1415     case '?':
1416     case ':':
1417     case '=':
1418     case '{':
1419     case '}':
1420     symbol:
1421       lexptr++;
1422       return c;
1423
1424     case '"':
1425       for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++)
1426         if (c == '\\')
1427           {
1428             c = tokstart[++namelen];
1429             if (c >= '0' && c <= '9')
1430               {
1431                 c = tokstart[++namelen];
1432                 if (c >= '0' && c <= '9')
1433                   c = tokstart[++namelen];
1434               }
1435           }
1436       yylval.sval.ptr = tokstart + 1;
1437       yylval.sval.length = namelen - 1;
1438       lexptr += namelen + 1;
1439       return STRING;
1440     }
1441
1442   if (!(c == '_' || c == '$'
1443         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1444     /* We must have come across a bad character (e.g. ';').  */
1445     error ("Invalid character '%c' in expression.", c);
1446
1447   /* It's a name.  See how long it is.  */
1448   namelen = 0;
1449   for (c = tokstart[namelen];
1450        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1451         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1452        c = tokstart[++namelen])
1453     ;
1454
1455   /* The token "if" terminates the expression and is NOT
1456      removed from the input stream.  */
1457   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1458     {
1459       return 0;
1460     }
1461
1462   lexptr += namelen;
1463
1464   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1465      and $$digits (equivalent to $<-digits> if you could type that).
1466      Make token type LAST, and put the number (the digits) in yylval.  */
1467
1468   if (*tokstart == '$')
1469     {
1470       register int negate = 0;
1471       c = 1;
1472       /* Double dollar means negate the number and add -1 as well.
1473          Thus $$ alone means -1.  */
1474       if (namelen >= 2 && tokstart[1] == '$')
1475         {
1476           negate = 1;
1477           c = 2;
1478         }
1479       if (c == namelen)
1480         {
1481           /* Just dollars (one or two) */
1482           yylval.lval = - negate;
1483           return LAST;
1484         }
1485       /* Is the rest of the token digits?  */
1486       for (; c < namelen; c++)
1487         if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1488           break;
1489       if (c == namelen)
1490         {
1491           yylval.lval = atoi (tokstart + 1 + negate);
1492           if (negate)
1493             yylval.lval = - yylval.lval;
1494           return LAST;
1495         }
1496     }
1497
1498   /* Handle tokens that refer to machine registers:
1499      $ followed by a register name.  */
1500
1501   if (*tokstart == '$') {
1502     for (c = 0; c < NUM_REGS; c++)
1503       if (namelen - 1 == strlen (reg_names[c])
1504           && !strncmp (tokstart + 1, reg_names[c], namelen - 1))
1505         {
1506           yylval.lval = c;
1507           return REGNAME;
1508         }
1509     for (c = 0; c < NUM_STD_REGS; c++)
1510      if (namelen - 1 == strlen (std_regs[c].name)
1511          && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1))
1512        {
1513          yylval.lval = std_regs[c].regnum;
1514          return REGNAME;
1515        }
1516   }
1517   /* Catch specific keywords.  Should be done with a data structure.  */
1518   switch (namelen)
1519     {
1520     case 8:
1521       if (!strncmp (tokstart, "unsigned", 8))
1522         return UNSIGNED;
1523       break;
1524     case 6:
1525       if (!strncmp (tokstart, "struct", 6))
1526         return STRUCT;
1527       if (!strncmp (tokstart, "signed", 6))
1528         return SIGNED;
1529       if (!strncmp (tokstart, "sizeof", 6))
1530         return SIZEOF;
1531       break;
1532     case 5:
1533       if (!strncmp (tokstart, "union", 5))
1534         return UNION;
1535       if (!strncmp (tokstart, "short", 5))
1536         return SHORT;
1537       break;
1538     case 4:
1539       if (!strncmp (tokstart, "enum", 4))
1540         return ENUM;
1541       if (!strncmp (tokstart, "long", 4))
1542         return LONG;
1543       if (!strncmp (tokstart, "this", 4))
1544         {
1545           static const char this_name[] =
1546                                  { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1547
1548           if (lookup_symbol (this_name, expression_context_block,
1549                              VAR_NAMESPACE, 0, NULL))
1550             return THIS;
1551         }
1552       break;
1553     case 3:
1554       if (!strncmp (tokstart, "int", 3))
1555         return INT_KEYWORD;
1556       break;
1557     default:
1558       break;
1559     }
1560
1561   yylval.sval.ptr = tokstart;
1562   yylval.sval.length = namelen;
1563
1564   /* Any other names starting in $ are debugger internal variables.  */
1565
1566   if (*tokstart == '$')
1567     {
1568       yylval.ivar =  lookup_internalvar (copy_name (yylval.sval) + 1);
1569       return VARIABLE;
1570     }
1571
1572   /* Use token-type BLOCKNAME for symbols that happen to be defined as
1573      functions or symtabs.  If this is not so, then ...
1574      Use token-type TYPENAME for symbols that happen to be defined
1575      currently as names of types; NAME for other symbols.
1576      The caller is not constrained to care about the distinction.  */
1577   {
1578     char *tmp = copy_name (yylval.sval);
1579     struct symbol *sym;
1580     int is_a_field_of_this = 0;
1581     int hextype;
1582
1583     sym = lookup_symbol (tmp, expression_context_block,
1584                          VAR_NAMESPACE, &is_a_field_of_this, NULL);
1585     if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1586         lookup_partial_symtab (tmp))
1587       {
1588         yylval.ssym.sym = sym;
1589         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1590         return BLOCKNAME;
1591       }
1592     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1593         {
1594           yylval.tsym.type = SYMBOL_TYPE (sym);
1595           return TYPENAME;
1596         }
1597     if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1598         return TYPENAME;
1599
1600     /* Input names that aren't symbols but ARE valid hex numbers,
1601        when the input radix permits them, can be names or numbers
1602        depending on the parse.  Note we support radixes > 16 here.  */
1603     if (!sym &&
1604         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1605          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1606       {
1607         YYSTYPE newlval;        /* Its value is ignored.  */
1608         hextype = parse_number (tokstart, namelen, 0, &newlval);
1609         if (hextype == INT)
1610           {
1611             yylval.ssym.sym = sym;
1612             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1613             return NAME_OR_INT;
1614           }
1615         if (hextype == UINT)
1616           {
1617             yylval.ssym.sym = sym;
1618             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1619             return NAME_OR_UINT;
1620           }
1621       }
1622
1623     /* Any other kind of symbol */
1624     yylval.ssym.sym = sym;
1625     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1626     return NAME;
1627   }
1628 }
1629
1630 static void
1631 yyerror (msg)
1632      char *msg;
1633 {
1634   error ("Invalid syntax in expression.");
1635 }
1636
1637 /* Return a null-terminated temporary copy of the name
1638    of a string token.  */
1639
1640 static char *
1641 copy_name (token)
1642      struct stoken token;
1643 {
1644   bcopy (token.ptr, namecopy, token.length);
1645   namecopy[token.length] = 0;
1646   return namecopy;
1647 }
1648 \f
1649 /* Reverse an expression from suffix form (in which it is constructed)
1650    to prefix form (in which we can conveniently print or execute it).  */
1651
1652 static void prefixify_subexp ();
1653
1654 static void
1655 prefixify_expression (expr)
1656      register struct expression *expr;
1657 {
1658   register int len = sizeof (struct expression) +
1659                                     expr->nelts * sizeof (union exp_element);
1660   register struct expression *temp;
1661   register int inpos = expr->nelts, outpos = 0;
1662
1663   temp = (struct expression *) alloca (len);
1664
1665   /* Copy the original expression into temp.  */
1666   bcopy (expr, temp, len);
1667
1668   prefixify_subexp (temp, expr, inpos, outpos);
1669 }
1670
1671 /* Return the number of exp_elements in the subexpression of EXPR
1672    whose last exp_element is at index ENDPOS - 1 in EXPR.  */
1673
1674 static int
1675 length_of_subexp (expr, endpos)
1676      register struct expression *expr;
1677      register int endpos;
1678 {
1679   register int oplen = 1;
1680   register int args = 0;
1681   register int i;
1682
1683   if (endpos < 0)
1684     error ("?error in length_of_subexp");
1685
1686   i = (int) expr->elts[endpos - 1].opcode;
1687
1688   switch (i)
1689     {
1690       /* C++  */
1691     case OP_SCOPE:
1692       oplen = 4 + ((expr->elts[endpos - 2].longconst
1693                     + sizeof (union exp_element))
1694                    / sizeof (union exp_element));
1695       break;
1696
1697     case OP_LONG:
1698     case OP_DOUBLE:
1699       oplen = 4;
1700       break;
1701
1702     case OP_VAR_VALUE:
1703     case OP_LAST:
1704     case OP_REGISTER:
1705     case OP_INTERNALVAR:
1706       oplen = 3;
1707       break;
1708
1709     case OP_FUNCALL:
1710       oplen = 3;
1711       args = 1 + expr->elts[endpos - 2].longconst;
1712       break;
1713
1714     case UNOP_CAST:
1715     case UNOP_MEMVAL:
1716       oplen = 3;
1717       args = 1;
1718       break;
1719
1720     case STRUCTOP_STRUCT:
1721     case STRUCTOP_PTR:
1722       args = 1;
1723     case OP_STRING:
1724       oplen = 3 + ((expr->elts[endpos - 2].longconst
1725                     + sizeof (union exp_element))
1726                    / sizeof (union exp_element));
1727       break;
1728
1729     case TERNOP_COND:
1730       args = 3;
1731       break;
1732
1733     case BINOP_ASSIGN_MODIFY:
1734       oplen = 3;
1735       args = 2;
1736       break;
1737
1738       /* C++ */
1739     case OP_THIS:
1740       oplen = 2;
1741       break;
1742
1743     default:
1744       args = 1 + (i < (int) BINOP_END);
1745     }
1746
1747   while (args > 0)
1748     {
1749       oplen += length_of_subexp (expr, endpos - oplen);
1750       args--;
1751     }
1752
1753   return oplen;
1754 }
1755
1756 /* Copy the subexpression ending just before index INEND in INEXPR
1757    into OUTEXPR, starting at index OUTBEG.
1758    In the process, convert it from suffix to prefix form.  */
1759
1760 static void
1761 prefixify_subexp (inexpr, outexpr, inend, outbeg)
1762      register struct expression *inexpr;
1763      struct expression *outexpr;
1764      register int inend;
1765      int outbeg;
1766 {
1767   register int oplen = 1;
1768   register int args = 0;
1769   register int i;
1770   int *arglens;
1771   enum exp_opcode opcode;
1772
1773   /* Compute how long the last operation is (in OPLEN),
1774      and also how many preceding subexpressions serve as
1775      arguments for it (in ARGS).  */
1776
1777   opcode = inexpr->elts[inend - 1].opcode;
1778   switch (opcode)
1779     {
1780       /* C++  */
1781     case OP_SCOPE:
1782       oplen = 4 + ((inexpr->elts[inend - 2].longconst
1783                     + sizeof (union exp_element))
1784                    / sizeof (union exp_element));
1785       break;
1786
1787     case OP_LONG:
1788     case OP_DOUBLE:
1789       oplen = 4;
1790       break;
1791
1792     case OP_VAR_VALUE:
1793     case OP_LAST:
1794     case OP_REGISTER:
1795     case OP_INTERNALVAR:
1796       oplen = 3;
1797       break;
1798
1799     case OP_FUNCALL:
1800       oplen = 3;
1801       args = 1 + inexpr->elts[inend - 2].longconst;
1802       break;
1803
1804     case UNOP_CAST:
1805     case UNOP_MEMVAL:
1806       oplen = 3;
1807       args = 1;
1808       break;
1809
1810     case STRUCTOP_STRUCT:
1811     case STRUCTOP_PTR:
1812       args = 1;
1813     case OP_STRING:
1814       oplen = 3 + ((inexpr->elts[inend - 2].longconst
1815                     + sizeof (union exp_element))
1816                    / sizeof (union exp_element));
1817
1818       break;
1819
1820     case TERNOP_COND:
1821       args = 3;
1822       break;
1823
1824     case BINOP_ASSIGN_MODIFY:
1825       oplen = 3;
1826       args = 2;
1827       break;
1828
1829       /* C++ */
1830     case OP_THIS:
1831       oplen = 2;
1832       break;
1833
1834     default:
1835       args = 1 + ((int) opcode < (int) BINOP_END);
1836     }
1837
1838   /* Copy the final operator itself, from the end of the input
1839      to the beginning of the output.  */
1840   inend -= oplen;
1841   bcopy (&inexpr->elts[inend], &outexpr->elts[outbeg],
1842          oplen * sizeof (union exp_element));
1843   outbeg += oplen;
1844
1845   /* Find the lengths of the arg subexpressions.  */
1846   arglens = (int *) alloca (args * sizeof (int));
1847   for (i = args - 1; i >= 0; i--)
1848     {
1849       oplen = length_of_subexp (inexpr, inend);
1850       arglens[i] = oplen;
1851       inend -= oplen;
1852     }
1853
1854   /* Now copy each subexpression, preserving the order of
1855      the subexpressions, but prefixifying each one.
1856      In this loop, inend starts at the beginning of
1857      the expression this level is working on
1858      and marches forward over the arguments.
1859      outbeg does similarly in the output.  */
1860   for (i = 0; i < args; i++)
1861     {
1862       oplen = arglens[i];
1863       inend += oplen;
1864       prefixify_subexp (inexpr, outexpr, inend, outbeg);
1865       outbeg += oplen;
1866     }
1867 }
1868 \f
1869 /* This page contains the two entry points to this file.  */
1870
1871 /* Read a C expression from the string *STRINGPTR points to,
1872    parse it, and return a pointer to a  struct expression  that we malloc.
1873    Use block BLOCK as the lexical context for variable names;
1874    if BLOCK is zero, use the block of the selected stack frame.
1875    Meanwhile, advance *STRINGPTR to point after the expression,
1876    at the first nonwhite character that is not part of the expression
1877    (possibly a null character).
1878
1879    If COMMA is nonzero, stop if a comma is reached.  */
1880
1881 struct expression *
1882 parse_c_1 (stringptr, block, comma)
1883      char **stringptr;
1884      struct block *block;
1885      int comma;
1886 {
1887   struct cleanup *old_chain;
1888
1889   lexptr = *stringptr;
1890
1891   paren_depth = 0;
1892   type_stack_depth = 0;
1893
1894   comma_terminates = comma;
1895
1896   if (lexptr == 0 || *lexptr == 0)
1897     error_no_arg ("expression to compute");
1898
1899   old_chain = make_cleanup (free_funcalls, 0);
1900   funcall_chain = 0;
1901
1902   expression_context_block = block ? block : get_selected_block ();
1903
1904   namecopy = (char *) alloca (strlen (lexptr) + 1);
1905   expout_size = 10;
1906   expout_ptr = 0;
1907   expout = (struct expression *)
1908     xmalloc (sizeof (struct expression)
1909              + expout_size * sizeof (union exp_element));
1910   make_cleanup (free_current_contents, &expout);
1911   if (yyparse ())
1912     yyerror (NULL);
1913   discard_cleanups (old_chain);
1914   expout->nelts = expout_ptr;
1915   expout = (struct expression *)
1916     xrealloc (expout,
1917               sizeof (struct expression)
1918               + expout_ptr * sizeof (union exp_element));
1919   prefixify_expression (expout);
1920   *stringptr = lexptr;
1921   return expout;
1922 }
1923
1924 /* Parse STRING as an expression, and complain if this fails
1925    to use up all of the contents of STRING.  */
1926
1927 struct expression *
1928 parse_c_expression (string)
1929      char *string;
1930 {
1931   register struct expression *exp;
1932   exp = parse_c_1 (&string, 0, 0);
1933   if (*string)
1934     error ("Junk after end of expression.");
1935   return exp;
1936 }
1937
1938 static void
1939 push_type (tp)
1940      enum type_pieces tp;
1941 {
1942   if (type_stack_depth == type_stack_size)
1943     {
1944       type_stack_size *= 2;
1945       type_stack = (union type_stack_elt *)
1946         xrealloc (type_stack, type_stack_size * sizeof (*type_stack));
1947     }
1948   type_stack[type_stack_depth++].piece = tp;
1949 }
1950
1951 static void
1952 push_type_int (n)
1953      int n;
1954 {
1955   if (type_stack_depth == type_stack_size)
1956     {
1957       type_stack_size *= 2;
1958       type_stack = (union type_stack_elt *)
1959         xrealloc (type_stack, type_stack_size * sizeof (*type_stack));
1960     }
1961   type_stack[type_stack_depth++].int_val = n;
1962 }
1963
1964 static enum type_pieces
1965 pop_type ()
1966 {
1967   if (type_stack_depth)
1968     return type_stack[--type_stack_depth].piece;
1969   return tp_end;
1970 }
1971
1972 static int
1973 pop_type_int ()
1974 {
1975   if (type_stack_depth)
1976     return type_stack[--type_stack_depth].int_val;
1977   /* "Can't happen".  */
1978   return 0;
1979 }
1980
1981 void
1982 _initialize_expread ()
1983 {
1984   type_stack_size = 80;
1985   type_stack_depth = 0;
1986   type_stack = (union type_stack_elt *)
1987     xmalloc (type_stack_size * sizeof (*type_stack));
1988 }