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