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