gdb/parse.c

   1 /* Parse expressions for GDB.
   2    Copyright (C) 1986, 1989, 1990, 1991, 1994 Free Software Foundation, Inc.
   3    Modified from expread.y by the Department of Computer Science at the
   4    State University of New York at Buffalo, 1991.
   5
   6 This file is part of GDB.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /* Parse an expression from text in a string,
  23    and return the result as a  struct expression  pointer.
  24    That structure contains arithmetic operations in reverse polish,
  25    with constants represented by operations that are followed by special data.
  26    See expression.h for the details of the format.
  27    What is important here is that it can be built up sequentially
  28    during the process of parsing; the lower levels of the tree always
  29    come first in the result.  */
  30
  31 #include "defs.h"
  32 #include "gdb_string.h"
  33 #include "symtab.h"
  34 #include "gdbtypes.h"
  35 #include "frame.h"
  36 #include "expression.h"
  37 #include "value.h"
  38 #include "command.h"
  39 #include "language.h"
  40 #include "parser-defs.h"
  41 \f
  42 /* Global variables declared in parser-defs.h (and commented there).  */
  43 struct expression *expout;
  44 int expout_size;
  45 int expout_ptr;
  46 struct block *expression_context_block;
  47 struct block *innermost_block;
  48 int arglist_len;
  49 union type_stack_elt *type_stack;
  50 int type_stack_depth, type_stack_size;
  51 char *lexptr;
  52 char *namecopy;
  53 int paren_depth;
  54 int comma_terminates;
  55 \f
  56 static void
  57 free_funcalls PARAMS ((void));
  58
  59 static void
  60 prefixify_expression PARAMS ((struct expression *));
  61
  62 static void
  63 prefixify_subexp PARAMS ((struct expression *, struct expression *, int, int));
  64
  65 /* Data structure for saving values of arglist_len for function calls whose
  66    arguments contain other function calls.  */
  67
  68 struct funcall
  69   {
  70     struct funcall *next;
  71     int arglist_len;
  72   };
  73
  74 static struct funcall *funcall_chain;
  75
  76 /* Assign machine-independent names to certain registers
  77    (unless overridden by the REGISTER_NAMES table) */
  78
  79 #ifdef NO_STD_REGS
  80 unsigned num_std_regs = 0;
  81 struct std_regs std_regs[1];
  82 #else
  83 struct std_regs std_regs[] = {
  84
  85 #ifdef PC_REGNUM
  86         { "pc", PC_REGNUM },
  87 #endif
  88 #ifdef FP_REGNUM
  89         { "fp", FP_REGNUM },
  90 #endif
  91 #ifdef SP_REGNUM
  92         { "sp", SP_REGNUM },
  93 #endif
  94 #ifdef PS_REGNUM
  95         { "ps", PS_REGNUM },
  96 #endif
  97
  98 };
  99
 100 unsigned num_std_regs = (sizeof std_regs / sizeof std_regs[0]);
 101
 102 #endif
 103
 104
 105 /* Begin counting arguments for a function call,
 106    saving the data about any containing call.  */
 107
 108 void
 109 start_arglist ()
 110 {
 111   register struct funcall *new;
 112
 113   new = (struct funcall *) xmalloc (sizeof (struct funcall));
 114   new->next = funcall_chain;
 115   new->arglist_len = arglist_len;
 116   arglist_len = 0;
 117   funcall_chain = new;
 118 }
 119
 120 /* Return the number of arguments in a function call just terminated,
 121    and restore the data for the containing function call.  */
 122
 123 int
 124 end_arglist ()
 125 {
 126   register int val = arglist_len;
 127   register struct funcall *call = funcall_chain;
 128   funcall_chain = call->next;
 129   arglist_len = call->arglist_len;
 130   free ((PTR)call);
 131   return val;
 132 }
 133
 134 /* Free everything in the funcall chain.
 135    Used when there is an error inside parsing.  */
 136
 137 static void
 138 free_funcalls ()
 139 {
 140   register struct funcall *call, *next;
 141
 142   for (call = funcall_chain; call; call = next)
 143     {
 144       next = call->next;
 145       free ((PTR)call);
 146     }
 147 }
 148 \f
 149 /* This page contains the functions for adding data to the  struct expression
 150    being constructed.  */
 151
 152 /* Add one element to the end of the expression.  */
 153
 154 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
 155    a register through here */
 156
 157 void
 158 write_exp_elt (expelt)
 159      union exp_element expelt;
 160 {
 161   if (expout_ptr >= expout_size)
 162     {
 163       expout_size *= 2;
 164       expout = (struct expression *)
 165         xrealloc ((char *) expout, sizeof (struct expression)
 166                   + EXP_ELEM_TO_BYTES (expout_size));
 167     }
 168   expout->elts[expout_ptr++] = expelt;
 169 }
 170
 171 void
 172 write_exp_elt_opcode (expelt)
 173      enum exp_opcode expelt;
 174 {
 175   union exp_element tmp;
 176
 177   tmp.opcode = expelt;
 178
 179   write_exp_elt (tmp);
 180 }
 181
 182 void
 183 write_exp_elt_sym (expelt)
 184      struct symbol *expelt;
 185 {
 186   union exp_element tmp;
 187
 188   tmp.symbol = expelt;
 189
 190   write_exp_elt (tmp);
 191 }
 192
 193 void
 194 write_exp_elt_block (b)
 195      struct block *b;
 196 {
 197   union exp_element tmp;
 198   tmp.block = b;
 199   write_exp_elt (tmp);
 200 }
 201
 202 void
 203 write_exp_elt_longcst (expelt)
 204      LONGEST expelt;
 205 {
 206   union exp_element tmp;
 207
 208   tmp.longconst = expelt;
 209
 210   write_exp_elt (tmp);
 211 }
 212
 213 void
 214 write_exp_elt_dblcst (expelt)
 215      DOUBLEST expelt;
 216 {
 217   union exp_element tmp;
 218
 219   tmp.doubleconst = expelt;
 220
 221   write_exp_elt (tmp);
 222 }
 223
 224 void
 225 write_exp_elt_type (expelt)
 226      struct type *expelt;
 227 {
 228   union exp_element tmp;
 229
 230   tmp.type = expelt;
 231
 232   write_exp_elt (tmp);
 233 }
 234
 235 void
 236 write_exp_elt_intern (expelt)
 237      struct internalvar *expelt;
 238 {
 239   union exp_element tmp;
 240
 241   tmp.internalvar = expelt;
 242
 243   write_exp_elt (tmp);
 244 }
 245
 246 /* Add a string constant to the end of the expression.
 247
 248    String constants are stored by first writing an expression element
 249    that contains the length of the string, then stuffing the string
 250    constant itself into however many expression elements are needed
 251    to hold it, and then writing another expression element that contains
 252    the length of the string.  I.E. an expression element at each end of
 253    the string records the string length, so you can skip over the
 254    expression elements containing the actual string bytes from either
 255    end of the string.  Note that this also allows gdb to handle
 256    strings with embedded null bytes, as is required for some languages.
 257
 258    Don't be fooled by the fact that the string is null byte terminated,
 259    this is strictly for the convenience of debugging gdb itself.  Gdb
 260    Gdb does not depend up the string being null terminated, since the
 261    actual length is recorded in expression elements at each end of the
 262    string.  The null byte is taken into consideration when computing how
 263    many expression elements are required to hold the string constant, of
 264    course. */
 265
 266
 267 void
 268 write_exp_string (str)
 269      struct stoken str;
 270 {
 271   register int len = str.length;
 272   register int lenelt;
 273   register char *strdata;
 274
 275   /* Compute the number of expression elements required to hold the string
 276      (including a null byte terminator), along with one expression element
 277      at each end to record the actual string length (not including the
 278      null byte terminator). */
 279
 280   lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
 281
 282   /* Ensure that we have enough available expression elements to store
 283      everything. */
 284
 285   if ((expout_ptr + lenelt) >= expout_size)
 286     {
 287       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 288       expout = (struct expression *)
 289         xrealloc ((char *) expout, (sizeof (struct expression)
 290                                     + EXP_ELEM_TO_BYTES (expout_size)));
 291     }
 292
 293   /* Write the leading length expression element (which advances the current
 294      expression element index), then write the string constant followed by a
 295      terminating null byte, and then write the trailing length expression
 296      element. */
 297
 298   write_exp_elt_longcst ((LONGEST) len);
 299   strdata = (char *) &expout->elts[expout_ptr];
 300   memcpy (strdata, str.ptr, len);
 301   *(strdata + len) = '\0';
 302   expout_ptr += lenelt - 2;
 303   write_exp_elt_longcst ((LONGEST) len);
 304 }
 305
 306 /* Add a bitstring constant to the end of the expression.
 307
 308    Bitstring constants are stored by first writing an expression element
 309    that contains the length of the bitstring (in bits), then stuffing the
 310    bitstring constant itself into however many expression elements are
 311    needed to hold it, and then writing another expression element that
 312    contains the length of the bitstring.  I.E. an expression element at
 313    each end of the bitstring records the bitstring length, so you can skip
 314    over the expression elements containing the actual bitstring bytes from
 315    either end of the bitstring. */
 316
 317 void
 318 write_exp_bitstring (str)
 319      struct stoken str;
 320 {
 321   register int bits = str.length;       /* length in bits */
 322   register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 323   register int lenelt;
 324   register char *strdata;
 325
 326   /* Compute the number of expression elements required to hold the bitstring,
 327      along with one expression element at each end to record the actual
 328      bitstring length in bits. */
 329
 330   lenelt = 2 + BYTES_TO_EXP_ELEM (len);
 331
 332   /* Ensure that we have enough available expression elements to store
 333      everything. */
 334
 335   if ((expout_ptr + lenelt) >= expout_size)
 336     {
 337       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 338       expout = (struct expression *)
 339         xrealloc ((char *) expout, (sizeof (struct expression)
 340                                     + EXP_ELEM_TO_BYTES (expout_size)));
 341     }
 342
 343   /* Write the leading length expression element (which advances the current
 344      expression element index), then write the bitstring constant, and then
 345      write the trailing length expression element. */
 346
 347   write_exp_elt_longcst ((LONGEST) bits);
 348   strdata = (char *) &expout->elts[expout_ptr];
 349   memcpy (strdata, str.ptr, len);
 350   expout_ptr += lenelt - 2;
 351   write_exp_elt_longcst ((LONGEST) bits);
 352 }
 353
 354 /* Add the appropriate elements for a minimal symbol to the end of
 355    the expression.  The rationale behind passing in text_symbol_type and
 356    data_symbol_type was so that Modula-2 could pass in WORD for
 357    data_symbol_type.  Perhaps it still is useful to have those types vary
 358    based on the language, but they no longer have names like "int", so
 359    the initial rationale is gone.  */
 360
 361 static struct type *msym_text_symbol_type;
 362 static struct type *msym_data_symbol_type;
 363 static struct type *msym_unknown_symbol_type;
 364
 365 void
 366 write_exp_msymbol (msymbol, text_symbol_type, data_symbol_type)
 367      struct minimal_symbol *msymbol;
 368      struct type *text_symbol_type;
 369      struct type *data_symbol_type;
 370 {
 371   write_exp_elt_opcode (OP_LONG);
 372   write_exp_elt_type (lookup_pointer_type (builtin_type_void));
 373   write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
 374   write_exp_elt_opcode (OP_LONG);
 375
 376   write_exp_elt_opcode (UNOP_MEMVAL);
 377   switch (msymbol -> type)
 378     {
 379     case mst_text:
 380     case mst_file_text:
 381     case mst_solib_trampoline:
 382       write_exp_elt_type (msym_text_symbol_type);
 383       break;
 384
 385     case mst_data:
 386     case mst_file_data:
 387     case mst_bss:
 388     case mst_file_bss:
 389       write_exp_elt_type (msym_data_symbol_type);
 390       break;
 391
 392     default:
 393       write_exp_elt_type (msym_unknown_symbol_type);
 394       break;
 395     }
 396   write_exp_elt_opcode (UNOP_MEMVAL);
 397 }
 398 \f
 399 /* Recognize tokens that start with '$'.  These include:
 400
 401         $regname        A native register name or a "standard
 402                         register name".
 403
 404         $variable       A convenience variable with a name chosen
 405                         by the user.
 406
 407         $digits         Value history with index <digits>, starting
 408                         from the first value which has index 1.
 409
 410         $$digits        Value history with index <digits> relative
 411                         to the last value.  I.E. $$0 is the last
 412                         value, $$1 is the one previous to that, $$2
 413                         is the one previous to $$1, etc.
 414
 415         $ | $0 | $$0    The last value in the value history.
 416
 417         $$              An abbreviation for the second to the last
 418                         value in the value history, I.E. $$1
 419
 420    */
 421
 422 void
 423 write_dollar_variable (str)
 424      struct stoken str;
 425 {
 426   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
 427      and $$digits (equivalent to $<-digits> if you could type that). */
 428
 429   int negate = 0;
 430   int i = 1;
 431   /* Double dollar means negate the number and add -1 as well.
 432      Thus $$ alone means -1.  */
 433   if (str.length >= 2 && str.ptr[1] == '$')
 434     {
 435       negate = 1;
 436       i = 2;
 437     }
 438   if (i == str.length)
 439     {
 440       /* Just dollars (one or two) */
 441       i = - negate;
 442       goto handle_last;
 443     }
 444   /* Is the rest of the token digits?  */
 445   for (; i < str.length; i++)
 446     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
 447       break;
 448   if (i == str.length)
 449     {
 450       i = atoi (str.ptr + 1 + negate);
 451       if (negate)
 452         i = - i;
 453       goto handle_last;
 454     }
 455
 456   /* Handle tokens that refer to machine registers:
 457      $ followed by a register name.  */
 458   for (i = 0; i < NUM_REGS; i++)
 459     if (reg_names[i] && str.length - 1 == strlen (reg_names[i])
 460         && STREQN (str.ptr + 1, reg_names[i], str.length - 1))
 461       {
 462         goto handle_register;
 463       }
 464   for (i = 0; i < num_std_regs; i++)
 465     if (std_regs[i].name && str.length - 1 == strlen (std_regs[i].name)
 466         && STREQN (str.ptr + 1, std_regs[i].name, str.length - 1))
 467       {
 468         i = std_regs[i].regnum;
 469         goto handle_register;
 470       }
 471
 472   /* Any other names starting in $ are debugger internal variables.  */
 473
 474   write_exp_elt_opcode (OP_INTERNALVAR);
 475   write_exp_elt_intern (lookup_internalvar (copy_name (str) + 1));
 476   write_exp_elt_opcode (OP_INTERNALVAR);
 477   return;
 478  handle_last:
 479   write_exp_elt_opcode (OP_LAST);
 480   write_exp_elt_longcst ((LONGEST) i);
 481   write_exp_elt_opcode (OP_LAST);
 482   return;
 483  handle_register:
 484   write_exp_elt_opcode (OP_REGISTER);
 485   write_exp_elt_longcst (i);
 486   write_exp_elt_opcode (OP_REGISTER);
 487   return;
 488 }
 489 \f
 490 /* Return a null-terminated temporary copy of the name
 491    of a string token.  */
 492
 493 char *
 494 copy_name (token)
 495      struct stoken token;
 496 {
 497   memcpy (namecopy, token.ptr, token.length);
 498   namecopy[token.length] = 0;
 499   return namecopy;
 500 }
 501 \f
 502 /* Reverse an expression from suffix form (in which it is constructed)
 503    to prefix form (in which we can conveniently print or execute it).  */
 504
 505 static void
 506 prefixify_expression (expr)
 507      register struct expression *expr;
 508 {
 509   register int len =
 510     sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
 511   register struct expression *temp;
 512   register int inpos = expr->nelts, outpos = 0;
 513
 514   temp = (struct expression *) alloca (len);
 515
 516   /* Copy the original expression into temp.  */
 517   memcpy (temp, expr, len);
 518
 519   prefixify_subexp (temp, expr, inpos, outpos);
 520 }
 521
 522 /* Return the number of exp_elements in the subexpression of EXPR
 523    whose last exp_element is at index ENDPOS - 1 in EXPR.  */
 524
 525 int
 526 length_of_subexp (expr, endpos)
 527      register struct expression *expr;
 528      register int endpos;
 529 {
 530   register int oplen = 1;
 531   register int args = 0;
 532   register int i;
 533
 534   if (endpos < 1)
 535     error ("?error in length_of_subexp");
 536
 537   i = (int) expr->elts[endpos - 1].opcode;
 538
 539   switch (i)
 540     {
 541       /* C++  */
 542     case OP_SCOPE:
 543       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 544       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 545       break;
 546
 547     case OP_LONG:
 548     case OP_DOUBLE:
 549     case OP_VAR_VALUE:
 550       oplen = 4;
 551       break;
 552
 553     case OP_TYPE:
 554     case OP_BOOL:
 555     case OP_LAST:
 556     case OP_REGISTER:
 557     case OP_INTERNALVAR:
 558       oplen = 3;
 559       break;
 560
 561     case OP_COMPLEX:
 562       oplen = 1;
 563       args = 2;
 564       break;
 565
 566     case OP_FUNCALL:
 567     case OP_F77_UNDETERMINED_ARGLIST:
 568       oplen = 3;
 569       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 570       break;
 571
 572     case UNOP_MAX:
 573     case UNOP_MIN:
 574       oplen = 3;
 575       break;
 576
 577    case BINOP_VAL:
 578    case UNOP_CAST:
 579    case UNOP_MEMVAL:
 580       oplen = 3;
 581       args = 1;
 582       break;
 583
 584     case UNOP_ABS:
 585     case UNOP_CAP:
 586     case UNOP_CHR:
 587     case UNOP_FLOAT:
 588     case UNOP_HIGH:
 589     case UNOP_ODD:
 590     case UNOP_ORD:
 591     case UNOP_TRUNC:
 592       oplen = 1;
 593       args = 1;
 594       break;
 595
 596     case OP_LABELED:
 597     case STRUCTOP_STRUCT:
 598     case STRUCTOP_PTR:
 599 /* start-sanitize-gm */
 600 #ifdef GENERAL_MAGIC
 601     case STRUCTOP_FIELD:
 602 #endif /* GENERAL_MAGIC */
 603 /* end-sanitize-gm */
 604       args = 1;
 605       /* fall through */
 606     case OP_M2_STRING:
 607     case OP_STRING:
 608     case OP_NAME:
 609     case OP_EXPRSTRING:
 610       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 611       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 612       break;
 613
 614     case OP_BITSTRING:
 615       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 616       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 617       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 618       break;
 619
 620     case OP_ARRAY:
 621       oplen = 4;
 622       args = longest_to_int (expr->elts[endpos - 2].longconst);
 623       args -= longest_to_int (expr->elts[endpos - 3].longconst);
 624       args += 1;
 625       break;
 626
 627     case TERNOP_COND:
 628     case TERNOP_SLICE:
 629     case TERNOP_SLICE_COUNT:
 630       args = 3;
 631       break;
 632
 633       /* Modula-2 */
 634    case MULTI_SUBSCRIPT:
 635       oplen = 3;
 636       args = 1 + longest_to_int (expr->elts[endpos- 2].longconst);
 637       break;
 638
 639     case BINOP_ASSIGN_MODIFY:
 640       oplen = 3;
 641       args = 2;
 642       break;
 643
 644       /* C++ */
 645     case OP_THIS:
 646       oplen = 2;
 647       break;
 648
 649     default:
 650       args = 1 + (i < (int) BINOP_END);
 651     }
 652
 653   while (args > 0)
 654     {
 655       oplen += length_of_subexp (expr, endpos - oplen);
 656       args--;
 657     }
 658
 659   return oplen;
 660 }
 661
 662 /* Copy the subexpression ending just before index INEND in INEXPR
 663    into OUTEXPR, starting at index OUTBEG.
 664    In the process, convert it from suffix to prefix form.  */
 665
 666 static void
 667 prefixify_subexp (inexpr, outexpr, inend, outbeg)
 668      register struct expression *inexpr;
 669      struct expression *outexpr;
 670      register int inend;
 671      int outbeg;
 672 {
 673   register int oplen = 1;
 674   register int args = 0;
 675   register int i;
 676   int *arglens;
 677   enum exp_opcode opcode;
 678
 679   /* Compute how long the last operation is (in OPLEN),
 680      and also how many preceding subexpressions serve as
 681      arguments for it (in ARGS).  */
 682
 683   opcode = inexpr->elts[inend - 1].opcode;
 684   switch (opcode)
 685     {
 686       /* C++  */
 687     case OP_SCOPE:
 688       oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
 689       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 690       break;
 691
 692     case OP_LONG:
 693     case OP_DOUBLE:
 694     case OP_VAR_VALUE:
 695       oplen = 4;
 696       break;
 697
 698     case OP_TYPE:
 699     case OP_BOOL:
 700     case OP_LAST:
 701     case OP_REGISTER:
 702     case OP_INTERNALVAR:
 703       oplen = 3;
 704       break;
 705
 706     case OP_COMPLEX:
 707       oplen = 1;
 708       args = 2;
 709       break;
 710
 711     case OP_FUNCALL:
 712     case OP_F77_UNDETERMINED_ARGLIST:
 713       oplen = 3;
 714       args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
 715       break;
 716
 717     case UNOP_MIN:
 718     case UNOP_MAX:
 719       oplen = 3;
 720       break;
 721
 722     case UNOP_CAST:
 723     case UNOP_MEMVAL:
 724       oplen = 3;
 725       args = 1;
 726       break;
 727
 728     case UNOP_ABS:
 729     case UNOP_CAP:
 730     case UNOP_CHR:
 731     case UNOP_FLOAT:
 732     case UNOP_HIGH:
 733     case UNOP_ODD:
 734     case UNOP_ORD:
 735     case UNOP_TRUNC:
 736       oplen=1;
 737       args=1;
 738       break;
 739
 740     case STRUCTOP_STRUCT:
 741     case STRUCTOP_PTR:
 742     case OP_LABELED:
 743       args = 1;
 744       /* fall through */
 745     case OP_M2_STRING:
 746     case OP_STRING:
 747     case OP_NAME:
 748     case OP_EXPRSTRING:
 749       oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
 750       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 751       break;
 752
 753     case OP_BITSTRING:
 754       oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
 755       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 756       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 757       break;
 758
 759     case OP_ARRAY:
 760       oplen = 4;
 761       args = longest_to_int (inexpr->elts[inend - 2].longconst);
 762       args -= longest_to_int (inexpr->elts[inend - 3].longconst);
 763       args += 1;
 764       break;
 765
 766     case TERNOP_COND:
 767     case TERNOP_SLICE:
 768     case TERNOP_SLICE_COUNT:
 769       args = 3;
 770       break;
 771
 772     case BINOP_ASSIGN_MODIFY:
 773       oplen = 3;
 774       args = 2;
 775       break;
 776
 777       /* Modula-2 */
 778    case MULTI_SUBSCRIPT:
 779       oplen = 3;
 780       args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
 781       break;
 782
 783       /* C++ */
 784     case OP_THIS:
 785       oplen = 2;
 786       break;
 787
 788     default:
 789       args = 1 + ((int) opcode < (int) BINOP_END);
 790     }
 791
 792   /* Copy the final operator itself, from the end of the input
 793      to the beginning of the output.  */
 794   inend -= oplen;
 795   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
 796           EXP_ELEM_TO_BYTES (oplen));
 797   outbeg += oplen;
 798
 799   /* Find the lengths of the arg subexpressions.  */
 800   arglens = (int *) alloca (args * sizeof (int));
 801   for (i = args - 1; i >= 0; i--)
 802     {
 803       oplen = length_of_subexp (inexpr, inend);
 804       arglens[i] = oplen;
 805       inend -= oplen;
 806     }
 807
 808   /* Now copy each subexpression, preserving the order of
 809      the subexpressions, but prefixifying each one.
 810      In this loop, inend starts at the beginning of
 811      the expression this level is working on
 812      and marches forward over the arguments.
 813      outbeg does similarly in the output.  */
 814   for (i = 0; i < args; i++)
 815     {
 816       oplen = arglens[i];
 817       inend += oplen;
 818       prefixify_subexp (inexpr, outexpr, inend, outbeg);
 819       outbeg += oplen;
 820     }
 821 }
 822 \f
 823 /* This page contains the two entry points to this file.  */
 824
 825 /* Read an expression from the string *STRINGPTR points to,
 826    parse it, and return a pointer to a  struct expression  that we malloc.
 827    Use block BLOCK as the lexical context for variable names;
 828    if BLOCK is zero, use the block of the selected stack frame.
 829    Meanwhile, advance *STRINGPTR to point after the expression,
 830    at the first nonwhite character that is not part of the expression
 831    (possibly a null character).
 832
 833    If COMMA is nonzero, stop if a comma is reached.  */
 834
 835 struct expression *
 836 parse_exp_1 (stringptr, block, comma)
 837      char **stringptr;
 838      struct block *block;
 839      int comma;
 840 {
 841   struct cleanup *old_chain;
 842
 843   lexptr = *stringptr;
 844
 845   paren_depth = 0;
 846   type_stack_depth = 0;
 847
 848   comma_terminates = comma;
 849
 850   if (lexptr == 0 || *lexptr == 0)
 851     error_no_arg ("expression to compute");
 852
 853   old_chain = make_cleanup (free_funcalls, 0);
 854   funcall_chain = 0;
 855
 856   expression_context_block = block ? block : get_selected_block ();
 857
 858   namecopy = (char *) alloca (strlen (lexptr) + 1);
 859   expout_size = 10;
 860   expout_ptr = 0;
 861   expout = (struct expression *)
 862     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
 863   expout->language_defn = current_language;
 864   make_cleanup (free_current_contents, &expout);
 865
 866   if (current_language->la_parser ())
 867     current_language->la_error (NULL);
 868
 869   discard_cleanups (old_chain);
 870
 871   /* Record the actual number of expression elements, and then
 872      reallocate the expression memory so that we free up any
 873      excess elements. */
 874
 875   expout->nelts = expout_ptr;
 876   expout = (struct expression *)
 877     xrealloc ((char *) expout,
 878               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
 879
 880   /* Convert expression from postfix form as generated by yacc
 881      parser, to a prefix form. */
 882
 883   DUMP_EXPRESSION (expout, gdb_stdout, "before conversion to prefix form");
 884   prefixify_expression (expout);
 885   DUMP_EXPRESSION (expout, gdb_stdout, "after conversion to prefix form");
 886
 887   *stringptr = lexptr;
 888   return expout;
 889 }
 890
 891 /* Parse STRING as an expression, and complain if this fails
 892    to use up all of the contents of STRING.  */
 893
 894 struct expression *
 895 parse_expression (string)
 896      char *string;
 897 {
 898   register struct expression *exp;
 899   exp = parse_exp_1 (&string, 0, 0);
 900   if (*string)
 901     error ("Junk after end of expression.");
 902   return exp;
 903 }
 904 \f
 905 /* Stuff for maintaining a stack of types.  Currently just used by C, but
 906    probably useful for any language which declares its types "backwards".  */
 907
 908 void
 909 push_type (tp)
 910      enum type_pieces tp;
 911 {
 912   if (type_stack_depth == type_stack_size)
 913     {
 914       type_stack_size *= 2;
 915       type_stack = (union type_stack_elt *)
 916         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
 917     }
 918   type_stack[type_stack_depth++].piece = tp;
 919 }
 920
 921 void
 922 push_type_int (n)
 923      int n;
 924 {
 925   if (type_stack_depth == type_stack_size)
 926     {
 927       type_stack_size *= 2;
 928       type_stack = (union type_stack_elt *)
 929         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
 930     }
 931   type_stack[type_stack_depth++].int_val = n;
 932 }
 933
 934 enum type_pieces
 935 pop_type ()
 936 {
 937   if (type_stack_depth)
 938     return type_stack[--type_stack_depth].piece;
 939   return tp_end;
 940 }
 941
 942 int
 943 pop_type_int ()
 944 {
 945   if (type_stack_depth)
 946     return type_stack[--type_stack_depth].int_val;
 947   /* "Can't happen".  */
 948   return 0;
 949 }
 950
 951 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
 952    as modified by all the stuff on the stack.  */
 953 struct type *
 954 follow_types (follow_type)
 955      struct type *follow_type;
 956 {
 957   int done = 0;
 958   int array_size;
 959   struct type *range_type;
 960
 961   while (!done)
 962     switch (pop_type ())
 963       {
 964       case tp_end:
 965         done = 1;
 966         break;
 967       case tp_pointer:
 968         follow_type = lookup_pointer_type (follow_type);
 969         break;
 970       case tp_reference:
 971         follow_type = lookup_reference_type (follow_type);
 972         break;
 973       case tp_array:
 974         array_size = pop_type_int ();
 975         /* FIXME-type-allocation: need a way to free this type when we are
 976            done with it.  */
 977         range_type =
 978           create_range_type ((struct type *) NULL,
 979                              builtin_type_int, 0,
 980                              array_size >= 0 ? array_size - 1 : 0);
 981         follow_type =
 982           create_array_type ((struct type *) NULL,
 983                              follow_type, range_type);
 984         if (array_size < 0)
 985           TYPE_ARRAY_UPPER_BOUND_TYPE(follow_type)
 986             = BOUND_CANNOT_BE_DETERMINED;
 987         break;
 988       case tp_function:
 989         /* FIXME-type-allocation: need a way to free this type when we are
 990            done with it.  */
 991         follow_type = lookup_function_type (follow_type);
 992         break;
 993       }
 994   return follow_type;
 995 }
 996 \f
 997 void
 998 _initialize_parse ()
 999 {
1000   type_stack_size = 80;
1001   type_stack_depth = 0;
1002   type_stack = (union type_stack_elt *)
1003     xmalloc (type_stack_size * sizeof (*type_stack));
1004
1005   msym_text_symbol_type =
1006     init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
1007   TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
1008   msym_data_symbol_type =
1009     init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1010                "<data variable, no debug info>", NULL);
1011   msym_unknown_symbol_type =
1012     init_type (TYPE_CODE_INT, 1, 0,
1013                "<variable (not text or data), no debug info>",
1014                NULL);
1015 }