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