gdb/expread.y

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