gdb/parse.c

   1 /* Parse expressions for GDB.
   2
   3    Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2004, 2005, 2007 Free Software Foundation, Inc.
   5
   6    Modified from expread.y by the Department of Computer Science at the
   7    State University of New York at Buffalo, 1991.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 /* Parse an expression from text in a string,
  25    and return the result as a  struct expression  pointer.
  26    That structure contains arithmetic operations in reverse polish,
  27    with constants represented by operations that are followed by special data.
  28    See expression.h for the details of the format.
  29    What is important here is that it can be built up sequentially
  30    during the process of parsing; the lower levels of the tree always
  31    come first in the result.  */
  32
  33 #include <ctype.h>
  34
  35 #include "defs.h"
  36 #include "gdb_string.h"
  37 #include "symtab.h"
  38 #include "gdbtypes.h"
  39 #include "frame.h"
  40 #include "expression.h"
  41 #include "value.h"
  42 #include "command.h"
  43 #include "language.h"
  44 #include "f-lang.h"
  45 #include "parser-defs.h"
  46 #include "gdbcmd.h"
  47 #include "symfile.h"            /* for overlay functions */
  48 #include "inferior.h"
  49 #include "doublest.h"
  50 #include "gdb_assert.h"
  51 #include "block.h"
  52 #include "source.h"
  53 #include "objfiles.h"
  54
  55 /* Standard set of definitions for printing, dumping, prefixifying,
  56  * and evaluating expressions.  */
  57
  58 const struct exp_descriptor exp_descriptor_standard =
  59   {
  60     print_subexp_standard,
  61     operator_length_standard,
  62     op_name_standard,
  63     dump_subexp_body_standard,
  64     evaluate_subexp_standard
  65   };
  66 \f
  67 /* Global variables declared in parser-defs.h (and commented there).  */
  68 struct expression *expout;
  69 int expout_size;
  70 int expout_ptr;
  71 struct block *expression_context_block;
  72 CORE_ADDR expression_context_pc;
  73 struct block *innermost_block;
  74 int arglist_len;
  75 union type_stack_elt *type_stack;
  76 int type_stack_depth, type_stack_size;
  77 char *lexptr;
  78 char *prev_lexptr;
  79 int paren_depth;
  80 int comma_terminates;
  81
  82 /* A temporary buffer for identifiers, so we can null-terminate them.
  83
  84    We allocate this with xrealloc.  parse_exp_1 used to allocate with
  85    alloca, using the size of the whole expression as a conservative
  86    estimate of the space needed.  However, macro expansion can
  87    introduce names longer than the original expression; there's no
  88    practical way to know beforehand how large that might be.  */
  89 char *namecopy;
  90 size_t namecopy_size;
  91 \f
  92 static int expressiondebug = 0;
  93 static void
  94 show_expressiondebug (struct ui_file *file, int from_tty,
  95                       struct cmd_list_element *c, const char *value)
  96 {
  97   fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
  98 }
  99
 100 static void free_funcalls (void *ignore);
 101
 102 static void prefixify_expression (struct expression *);
 103
 104 static void prefixify_subexp (struct expression *, struct expression *, int,
 105                               int);
 106
 107 static struct expression *parse_exp_in_context (char **, struct block *, int,
 108                                                 int);
 109
 110 void _initialize_parse (void);
 111
 112 /* Data structure for saving values of arglist_len for function calls whose
 113    arguments contain other function calls.  */
 114
 115 struct funcall
 116   {
 117     struct funcall *next;
 118     int arglist_len;
 119   };
 120
 121 static struct funcall *funcall_chain;
 122
 123 /* Begin counting arguments for a function call,
 124    saving the data about any containing call.  */
 125
 126 void
 127 start_arglist (void)
 128 {
 129   struct funcall *new;
 130
 131   new = (struct funcall *) xmalloc (sizeof (struct funcall));
 132   new->next = funcall_chain;
 133   new->arglist_len = arglist_len;
 134   arglist_len = 0;
 135   funcall_chain = new;
 136 }
 137
 138 /* Return the number of arguments in a function call just terminated,
 139    and restore the data for the containing function call.  */
 140
 141 int
 142 end_arglist (void)
 143 {
 144   int val = arglist_len;
 145   struct funcall *call = funcall_chain;
 146   funcall_chain = call->next;
 147   arglist_len = call->arglist_len;
 148   xfree (call);
 149   return val;
 150 }
 151
 152 /* Free everything in the funcall chain.
 153    Used when there is an error inside parsing.  */
 154
 155 static void
 156 free_funcalls (void *ignore)
 157 {
 158   struct funcall *call, *next;
 159
 160   for (call = funcall_chain; call; call = next)
 161     {
 162       next = call->next;
 163       xfree (call);
 164     }
 165 }
 166 \f
 167 /* This page contains the functions for adding data to the  struct expression
 168    being constructed.  */
 169
 170 /* Add one element to the end of the expression.  */
 171
 172 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
 173    a register through here */
 174
 175 void
 176 write_exp_elt (union exp_element expelt)
 177 {
 178   if (expout_ptr >= expout_size)
 179     {
 180       expout_size *= 2;
 181       expout = (struct expression *)
 182         xrealloc ((char *) expout, sizeof (struct expression)
 183                   + EXP_ELEM_TO_BYTES (expout_size));
 184     }
 185   expout->elts[expout_ptr++] = expelt;
 186 }
 187
 188 void
 189 write_exp_elt_opcode (enum exp_opcode expelt)
 190 {
 191   union exp_element tmp;
 192   memset (&tmp, 0, sizeof (union exp_element));
 193
 194   tmp.opcode = expelt;
 195
 196   write_exp_elt (tmp);
 197 }
 198
 199 void
 200 write_exp_elt_sym (struct symbol *expelt)
 201 {
 202   union exp_element tmp;
 203   memset (&tmp, 0, sizeof (union exp_element));
 204
 205   tmp.symbol = expelt;
 206
 207   write_exp_elt (tmp);
 208 }
 209
 210 void
 211 write_exp_elt_block (struct block *b)
 212 {
 213   union exp_element tmp;
 214   memset (&tmp, 0, sizeof (union exp_element));
 215   tmp.block = b;
 216   write_exp_elt (tmp);
 217 }
 218
 219 void
 220 write_exp_elt_objfile (struct objfile *objfile)
 221 {
 222   union exp_element tmp;
 223   memset (&tmp, 0, sizeof (union exp_element));
 224   tmp.objfile = objfile;
 225   write_exp_elt (tmp);
 226 }
 227
 228 void
 229 write_exp_elt_longcst (LONGEST expelt)
 230 {
 231   union exp_element tmp;
 232   memset (&tmp, 0, sizeof (union exp_element));
 233
 234   tmp.longconst = expelt;
 235
 236   write_exp_elt (tmp);
 237 }
 238
 239 void
 240 write_exp_elt_dblcst (DOUBLEST expelt)
 241 {
 242   union exp_element tmp;
 243   memset (&tmp, 0, sizeof (union exp_element));
 244
 245   tmp.doubleconst = expelt;
 246
 247   write_exp_elt (tmp);
 248 }
 249
 250 void
 251 write_exp_elt_type (struct type *expelt)
 252 {
 253   union exp_element tmp;
 254   memset (&tmp, 0, sizeof (union exp_element));
 255
 256   tmp.type = expelt;
 257
 258   write_exp_elt (tmp);
 259 }
 260
 261 void
 262 write_exp_elt_intern (struct internalvar *expelt)
 263 {
 264   union exp_element tmp;
 265   memset (&tmp, 0, sizeof (union exp_element));
 266
 267   tmp.internalvar = expelt;
 268
 269   write_exp_elt (tmp);
 270 }
 271
 272 /* Add a string constant to the end of the expression.
 273
 274    String constants are stored by first writing an expression element
 275    that contains the length of the string, then stuffing the string
 276    constant itself into however many expression elements are needed
 277    to hold it, and then writing another expression element that contains
 278    the length of the string.  I.E. an expression element at each end of
 279    the string records the string length, so you can skip over the
 280    expression elements containing the actual string bytes from either
 281    end of the string.  Note that this also allows gdb to handle
 282    strings with embedded null bytes, as is required for some languages.
 283
 284    Don't be fooled by the fact that the string is null byte terminated,
 285    this is strictly for the convenience of debugging gdb itself.  Gdb
 286    Gdb does not depend up the string being null terminated, since the
 287    actual length is recorded in expression elements at each end of the
 288    string.  The null byte is taken into consideration when computing how
 289    many expression elements are required to hold the string constant, of
 290    course. */
 291
 292
 293 void
 294 write_exp_string (struct stoken str)
 295 {
 296   int len = str.length;
 297   int lenelt;
 298   char *strdata;
 299
 300   /* Compute the number of expression elements required to hold the string
 301      (including a null byte terminator), along with one expression element
 302      at each end to record the actual string length (not including the
 303      null byte terminator). */
 304
 305   lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
 306
 307   /* Ensure that we have enough available expression elements to store
 308      everything. */
 309
 310   if ((expout_ptr + lenelt) >= expout_size)
 311     {
 312       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 313       expout = (struct expression *)
 314         xrealloc ((char *) expout, (sizeof (struct expression)
 315                                     + EXP_ELEM_TO_BYTES (expout_size)));
 316     }
 317
 318   /* Write the leading length expression element (which advances the current
 319      expression element index), then write the string constant followed by a
 320      terminating null byte, and then write the trailing length expression
 321      element. */
 322
 323   write_exp_elt_longcst ((LONGEST) len);
 324   strdata = (char *) &expout->elts[expout_ptr];
 325   memcpy (strdata, str.ptr, len);
 326   *(strdata + len) = '\0';
 327   expout_ptr += lenelt - 2;
 328   write_exp_elt_longcst ((LONGEST) len);
 329 }
 330
 331 /* Add a bitstring constant to the end of the expression.
 332
 333    Bitstring constants are stored by first writing an expression element
 334    that contains the length of the bitstring (in bits), then stuffing the
 335    bitstring constant itself into however many expression elements are
 336    needed to hold it, and then writing another expression element that
 337    contains the length of the bitstring.  I.E. an expression element at
 338    each end of the bitstring records the bitstring length, so you can skip
 339    over the expression elements containing the actual bitstring bytes from
 340    either end of the bitstring. */
 341
 342 void
 343 write_exp_bitstring (struct stoken str)
 344 {
 345   int bits = str.length;        /* length in bits */
 346   int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 347   int lenelt;
 348   char *strdata;
 349
 350   /* Compute the number of expression elements required to hold the bitstring,
 351      along with one expression element at each end to record the actual
 352      bitstring length in bits. */
 353
 354   lenelt = 2 + BYTES_TO_EXP_ELEM (len);
 355
 356   /* Ensure that we have enough available expression elements to store
 357      everything. */
 358
 359   if ((expout_ptr + lenelt) >= expout_size)
 360     {
 361       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 362       expout = (struct expression *)
 363         xrealloc ((char *) expout, (sizeof (struct expression)
 364                                     + EXP_ELEM_TO_BYTES (expout_size)));
 365     }
 366
 367   /* Write the leading length expression element (which advances the current
 368      expression element index), then write the bitstring constant, and then
 369      write the trailing length expression element. */
 370
 371   write_exp_elt_longcst ((LONGEST) bits);
 372   strdata = (char *) &expout->elts[expout_ptr];
 373   memcpy (strdata, str.ptr, len);
 374   expout_ptr += lenelt - 2;
 375   write_exp_elt_longcst ((LONGEST) bits);
 376 }
 377
 378 /* Add the appropriate elements for a minimal symbol to the end of
 379    the expression.  The rationale behind passing in text_symbol_type and
 380    data_symbol_type was so that Modula-2 could pass in WORD for
 381    data_symbol_type.  Perhaps it still is useful to have those types vary
 382    based on the language, but they no longer have names like "int", so
 383    the initial rationale is gone.  */
 384
 385 void
 386 write_exp_msymbol (struct minimal_symbol *msymbol,
 387                    struct type *text_symbol_type,
 388                    struct type *data_symbol_type)
 389 {
 390   struct gdbarch *gdbarch = current_gdbarch;
 391   CORE_ADDR addr;
 392
 393   write_exp_elt_opcode (OP_LONG);
 394   /* Let's make the type big enough to hold a 64-bit address.  */
 395   write_exp_elt_type (builtin_type_CORE_ADDR);
 396
 397   addr = SYMBOL_VALUE_ADDRESS (msymbol);
 398   if (overlay_debugging)
 399     addr = symbol_overlayed_address (addr, SYMBOL_BFD_SECTION (msymbol));
 400   write_exp_elt_longcst ((LONGEST) addr);
 401
 402   write_exp_elt_opcode (OP_LONG);
 403
 404   if (SYMBOL_BFD_SECTION (msymbol)
 405       && SYMBOL_BFD_SECTION (msymbol)->flags & SEC_THREAD_LOCAL)
 406     {
 407       bfd *bfd = SYMBOL_BFD_SECTION (msymbol)->owner;
 408       struct objfile *ofp;
 409
 410       ALL_OBJFILES (ofp)
 411         if (ofp->obfd == bfd)
 412           break;
 413
 414       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 415       write_exp_elt_objfile (ofp);
 416       write_exp_elt_type (builtin_type (gdbarch)->nodebug_tls_symbol);
 417       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 418       return;
 419     }
 420
 421   write_exp_elt_opcode (UNOP_MEMVAL);
 422   switch (msymbol->type)
 423     {
 424     case mst_text:
 425     case mst_file_text:
 426     case mst_solib_trampoline:
 427       write_exp_elt_type (builtin_type (gdbarch)->nodebug_text_symbol);
 428       break;
 429
 430     case mst_data:
 431     case mst_file_data:
 432     case mst_bss:
 433     case mst_file_bss:
 434       write_exp_elt_type (builtin_type (gdbarch)->nodebug_data_symbol);
 435       break;
 436
 437     default:
 438       write_exp_elt_type (builtin_type (gdbarch)->nodebug_unknown_symbol);
 439       break;
 440     }
 441   write_exp_elt_opcode (UNOP_MEMVAL);
 442 }
 443 \f
 444 /* Recognize tokens that start with '$'.  These include:
 445
 446    $regname     A native register name or a "standard
 447    register name".
 448
 449    $variable    A convenience variable with a name chosen
 450    by the user.
 451
 452    $digits              Value history with index <digits>, starting
 453    from the first value which has index 1.
 454
 455    $$digits     Value history with index <digits> relative
 456    to the last value.  I.E. $$0 is the last
 457    value, $$1 is the one previous to that, $$2
 458    is the one previous to $$1, etc.
 459
 460    $ | $0 | $$0 The last value in the value history.
 461
 462    $$           An abbreviation for the second to the last
 463    value in the value history, I.E. $$1
 464
 465  */
 466
 467 void
 468 write_dollar_variable (struct stoken str)
 469 {
 470   struct symbol *sym = NULL;
 471   struct minimal_symbol *msym = NULL;
 472   struct internalvar *isym = NULL;
 473
 474   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
 475      and $$digits (equivalent to $<-digits> if you could type that). */
 476
 477   int negate = 0;
 478   int i = 1;
 479   /* Double dollar means negate the number and add -1 as well.
 480      Thus $$ alone means -1.  */
 481   if (str.length >= 2 && str.ptr[1] == '$')
 482     {
 483       negate = 1;
 484       i = 2;
 485     }
 486   if (i == str.length)
 487     {
 488       /* Just dollars (one or two) */
 489       i = -negate;
 490       goto handle_last;
 491     }
 492   /* Is the rest of the token digits?  */
 493   for (; i < str.length; i++)
 494     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
 495       break;
 496   if (i == str.length)
 497     {
 498       i = atoi (str.ptr + 1 + negate);
 499       if (negate)
 500         i = -i;
 501       goto handle_last;
 502     }
 503
 504   /* Handle tokens that refer to machine registers:
 505      $ followed by a register name.  */
 506   i = frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
 507                                 str.ptr + 1, str.length - 1);
 508   if (i >= 0)
 509     goto handle_register;
 510
 511   /* Any names starting with $ are probably debugger internal variables.  */
 512
 513   isym = lookup_only_internalvar (copy_name (str) + 1);
 514   if (isym)
 515     {
 516       write_exp_elt_opcode (OP_INTERNALVAR);
 517       write_exp_elt_intern (isym);
 518       write_exp_elt_opcode (OP_INTERNALVAR);
 519       return;
 520     }
 521
 522   /* On some systems, such as HP-UX and hppa-linux, certain system routines
 523      have names beginning with $ or $$.  Check for those, first. */
 524
 525   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
 526                        VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL);
 527   if (sym)
 528     {
 529       write_exp_elt_opcode (OP_VAR_VALUE);
 530       write_exp_elt_block (block_found);        /* set by lookup_symbol */
 531       write_exp_elt_sym (sym);
 532       write_exp_elt_opcode (OP_VAR_VALUE);
 533       return;
 534     }
 535   msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
 536   if (msym)
 537     {
 538       write_exp_msymbol (msym,
 539                          lookup_function_type (builtin_type_int),
 540                          builtin_type_int);
 541       return;
 542     }
 543
 544   /* Any other names are assumed to be debugger internal variables.  */
 545
 546   write_exp_elt_opcode (OP_INTERNALVAR);
 547   write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
 548   write_exp_elt_opcode (OP_INTERNALVAR);
 549   return;
 550 handle_last:
 551   write_exp_elt_opcode (OP_LAST);
 552   write_exp_elt_longcst ((LONGEST) i);
 553   write_exp_elt_opcode (OP_LAST);
 554   return;
 555 handle_register:
 556   write_exp_elt_opcode (OP_REGISTER);
 557   str.length--;
 558   str.ptr++;
 559   write_exp_string (str);
 560   write_exp_elt_opcode (OP_REGISTER);
 561   return;
 562 }
 563
 564
 565 char *
 566 find_template_name_end (char *p)
 567 {
 568   int depth = 1;
 569   int just_seen_right = 0;
 570   int just_seen_colon = 0;
 571   int just_seen_space = 0;
 572
 573   if (!p || (*p != '<'))
 574     return 0;
 575
 576   while (*++p)
 577     {
 578       switch (*p)
 579         {
 580         case '\'':
 581         case '\"':
 582         case '{':
 583         case '}':
 584           /* In future, may want to allow these?? */
 585           return 0;
 586         case '<':
 587           depth++;              /* start nested template */
 588           if (just_seen_colon || just_seen_right || just_seen_space)
 589             return 0;           /* but not after : or :: or > or space */
 590           break;
 591         case '>':
 592           if (just_seen_colon || just_seen_right)
 593             return 0;           /* end a (nested?) template */
 594           just_seen_right = 1;  /* but not after : or :: */
 595           if (--depth == 0)     /* also disallow >>, insist on > > */
 596             return ++p;         /* if outermost ended, return */
 597           break;
 598         case ':':
 599           if (just_seen_space || (just_seen_colon > 1))
 600             return 0;           /* nested class spec coming up */
 601           just_seen_colon++;    /* we allow :: but not :::: */
 602           break;
 603         case ' ':
 604           break;
 605         default:
 606           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
 607                 (*p >= 'A' && *p <= 'Z') ||
 608                 (*p >= '0' && *p <= '9') ||
 609                 (*p == '_') || (*p == ',') ||   /* commas for template args */
 610                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
 611                 (*p == '(') || (*p == ')') ||   /* function types */
 612                 (*p == '[') || (*p == ']')))    /* array types */
 613             return 0;
 614         }
 615       if (*p != ' ')
 616         just_seen_space = 0;
 617       if (*p != ':')
 618         just_seen_colon = 0;
 619       if (*p != '>')
 620         just_seen_right = 0;
 621     }
 622   return 0;
 623 }
 624 \f
 625
 626
 627 /* Return a null-terminated temporary copy of the name
 628    of a string token.  */
 629
 630 char *
 631 copy_name (struct stoken token)
 632 {
 633   /* Make sure there's enough space for the token.  */
 634   if (namecopy_size < token.length + 1)
 635     {
 636       namecopy_size = token.length + 1;
 637       namecopy = xrealloc (namecopy, token.length + 1);
 638     }
 639
 640   memcpy (namecopy, token.ptr, token.length);
 641   namecopy[token.length] = 0;
 642
 643   return namecopy;
 644 }
 645 \f
 646 /* Reverse an expression from suffix form (in which it is constructed)
 647    to prefix form (in which we can conveniently print or execute it).  */
 648
 649 static void
 650 prefixify_expression (struct expression *expr)
 651 {
 652   int len =
 653   sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
 654   struct expression *temp;
 655   int inpos = expr->nelts, outpos = 0;
 656
 657   temp = (struct expression *) alloca (len);
 658
 659   /* Copy the original expression into temp.  */
 660   memcpy (temp, expr, len);
 661
 662   prefixify_subexp (temp, expr, inpos, outpos);
 663 }
 664
 665 /* Return the number of exp_elements in the postfix subexpression
 666    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
 667
 668 int
 669 length_of_subexp (struct expression *expr, int endpos)
 670 {
 671   int oplen, args, i;
 672
 673   operator_length (expr, endpos, &oplen, &args);
 674
 675   while (args > 0)
 676     {
 677       oplen += length_of_subexp (expr, endpos - oplen);
 678       args--;
 679     }
 680
 681   return oplen;
 682 }
 683
 684 /* Sets *OPLENP to the length of the operator whose (last) index is
 685    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
 686    operator takes.  */
 687
 688 void
 689 operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp)
 690 {
 691   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
 692                                                      oplenp, argsp);
 693 }
 694
 695 /* Default value for operator_length in exp_descriptor vectors.  */
 696
 697 void
 698 operator_length_standard (struct expression *expr, int endpos,
 699                           int *oplenp, int *argsp)
 700 {
 701   int oplen = 1;
 702   int args = 0;
 703   enum f90_range_type range_type;
 704   int i;
 705
 706   if (endpos < 1)
 707     error (_("?error in operator_length_standard"));
 708
 709   i = (int) expr->elts[endpos - 1].opcode;
 710
 711   switch (i)
 712     {
 713       /* C++  */
 714     case OP_SCOPE:
 715       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 716       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 717       break;
 718
 719     case OP_LONG:
 720     case OP_DOUBLE:
 721     case OP_VAR_VALUE:
 722       oplen = 4;
 723       break;
 724
 725     case OP_TYPE:
 726     case OP_BOOL:
 727     case OP_LAST:
 728     case OP_INTERNALVAR:
 729       oplen = 3;
 730       break;
 731
 732     case OP_COMPLEX:
 733       oplen = 1;
 734       args = 2;
 735       break;
 736
 737     case OP_FUNCALL:
 738     case OP_F77_UNDETERMINED_ARGLIST:
 739       oplen = 3;
 740       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 741       break;
 742
 743     case OP_OBJC_MSGCALL:       /* Objective C message (method) call */
 744       oplen = 4;
 745       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 746       break;
 747
 748     case UNOP_MAX:
 749     case UNOP_MIN:
 750       oplen = 3;
 751       break;
 752
 753     case BINOP_VAL:
 754     case UNOP_CAST:
 755     case UNOP_MEMVAL:
 756       oplen = 3;
 757       args = 1;
 758       break;
 759
 760     case UNOP_MEMVAL_TLS:
 761       oplen = 4;
 762       args = 1;
 763       break;
 764
 765     case UNOP_ABS:
 766     case UNOP_CAP:
 767     case UNOP_CHR:
 768     case UNOP_FLOAT:
 769     case UNOP_HIGH:
 770     case UNOP_ODD:
 771     case UNOP_ORD:
 772     case UNOP_TRUNC:
 773       oplen = 1;
 774       args = 1;
 775       break;
 776
 777     case OP_LABELED:
 778     case STRUCTOP_STRUCT:
 779     case STRUCTOP_PTR:
 780       args = 1;
 781       /* fall through */
 782     case OP_REGISTER:
 783     case OP_M2_STRING:
 784     case OP_STRING:
 785     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class NSString constant */
 786     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op */
 787     case OP_NAME:
 788       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 789       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 790       break;
 791
 792     case OP_BITSTRING:
 793       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 794       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 795       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 796       break;
 797
 798     case OP_ARRAY:
 799       oplen = 4;
 800       args = longest_to_int (expr->elts[endpos - 2].longconst);
 801       args -= longest_to_int (expr->elts[endpos - 3].longconst);
 802       args += 1;
 803       break;
 804
 805     case TERNOP_COND:
 806     case TERNOP_SLICE:
 807     case TERNOP_SLICE_COUNT:
 808       args = 3;
 809       break;
 810
 811       /* Modula-2 */
 812     case MULTI_SUBSCRIPT:
 813       oplen = 3;
 814       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 815       break;
 816
 817     case BINOP_ASSIGN_MODIFY:
 818       oplen = 3;
 819       args = 2;
 820       break;
 821
 822       /* C++ */
 823     case OP_THIS:
 824     case OP_OBJC_SELF:
 825       oplen = 2;
 826       break;
 827
 828     case OP_F90_RANGE:
 829       oplen = 3;
 830
 831       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
 832       switch (range_type)
 833         {
 834         case LOW_BOUND_DEFAULT:
 835         case HIGH_BOUND_DEFAULT:
 836           args = 1;
 837           break;
 838         case BOTH_BOUND_DEFAULT:
 839           args = 0;
 840           break;
 841         case NONE_BOUND_DEFAULT:
 842           args = 2;
 843           break;
 844         }
 845
 846       break;
 847
 848     default:
 849       args = 1 + (i < (int) BINOP_END);
 850     }
 851
 852   *oplenp = oplen;
 853   *argsp = args;
 854 }
 855
 856 /* Copy the subexpression ending just before index INEND in INEXPR
 857    into OUTEXPR, starting at index OUTBEG.
 858    In the process, convert it from suffix to prefix form.  */
 859
 860 static void
 861 prefixify_subexp (struct expression *inexpr,
 862                   struct expression *outexpr, int inend, int outbeg)
 863 {
 864   int oplen;
 865   int args;
 866   int i;
 867   int *arglens;
 868   enum exp_opcode opcode;
 869
 870   operator_length (inexpr, inend, &oplen, &args);
 871
 872   /* Copy the final operator itself, from the end of the input
 873      to the beginning of the output.  */
 874   inend -= oplen;
 875   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
 876           EXP_ELEM_TO_BYTES (oplen));
 877   outbeg += oplen;
 878
 879   /* Find the lengths of the arg subexpressions.  */
 880   arglens = (int *) alloca (args * sizeof (int));
 881   for (i = args - 1; i >= 0; i--)
 882     {
 883       oplen = length_of_subexp (inexpr, inend);
 884       arglens[i] = oplen;
 885       inend -= oplen;
 886     }
 887
 888   /* Now copy each subexpression, preserving the order of
 889      the subexpressions, but prefixifying each one.
 890      In this loop, inend starts at the beginning of
 891      the expression this level is working on
 892      and marches forward over the arguments.
 893      outbeg does similarly in the output.  */
 894   for (i = 0; i < args; i++)
 895     {
 896       oplen = arglens[i];
 897       inend += oplen;
 898       prefixify_subexp (inexpr, outexpr, inend, outbeg);
 899       outbeg += oplen;
 900     }
 901 }
 902 \f
 903 /* This page contains the two entry points to this file.  */
 904
 905 /* Read an expression from the string *STRINGPTR points to,
 906    parse it, and return a pointer to a  struct expression  that we malloc.
 907    Use block BLOCK as the lexical context for variable names;
 908    if BLOCK is zero, use the block of the selected stack frame.
 909    Meanwhile, advance *STRINGPTR to point after the expression,
 910    at the first nonwhite character that is not part of the expression
 911    (possibly a null character).
 912
 913    If COMMA is nonzero, stop if a comma is reached.  */
 914
 915 struct expression *
 916 parse_exp_1 (char **stringptr, struct block *block, int comma)
 917 {
 918   return parse_exp_in_context (stringptr, block, comma, 0);
 919 }
 920
 921 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
 922    no value is expected from the expression.  */
 923
 924 static struct expression *
 925 parse_exp_in_context (char **stringptr, struct block *block, int comma,
 926                       int void_context_p)
 927 {
 928   struct cleanup *old_chain;
 929
 930   lexptr = *stringptr;
 931   prev_lexptr = NULL;
 932
 933   paren_depth = 0;
 934   type_stack_depth = 0;
 935
 936   comma_terminates = comma;
 937
 938   if (lexptr == 0 || *lexptr == 0)
 939     error_no_arg (_("expression to compute"));
 940
 941   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
 942   funcall_chain = 0;
 943
 944   /* If no context specified, try using the current frame, if any. */
 945
 946   if (!block)
 947     block = get_selected_block (&expression_context_pc);
 948
 949   /* Fall back to using the current source static context, if any. */
 950
 951   if (!block)
 952     {
 953       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 954       if (cursal.symtab)
 955         block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
 956     }
 957
 958   /* Save the context, if specified by caller, or found above. */
 959
 960   if (block)
 961     {
 962       expression_context_block = block;
 963       expression_context_pc = BLOCK_START (block);
 964     }
 965
 966   expout_size = 10;
 967   expout_ptr = 0;
 968   expout = (struct expression *)
 969     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
 970   expout->language_defn = current_language;
 971   make_cleanup (free_current_contents, &expout);
 972
 973   if (current_language->la_parser ())
 974     current_language->la_error (NULL);
 975
 976   discard_cleanups (old_chain);
 977
 978   /* Record the actual number of expression elements, and then
 979      reallocate the expression memory so that we free up any
 980      excess elements. */
 981
 982   expout->nelts = expout_ptr;
 983   expout = (struct expression *)
 984     xrealloc ((char *) expout,
 985               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
 986
 987   /* Convert expression from postfix form as generated by yacc
 988      parser, to a prefix form. */
 989
 990   if (expressiondebug)
 991     dump_raw_expression (expout, gdb_stdlog,
 992                          "before conversion to prefix form");
 993
 994   prefixify_expression (expout);
 995
 996   current_language->la_post_parser (&expout, void_context_p);
 997
 998   if (expressiondebug)
 999     dump_prefix_expression (expout, gdb_stdlog);
1000
1001   *stringptr = lexptr;
1002   return expout;
1003 }
1004
1005 /* Parse STRING as an expression, and complain if this fails
1006    to use up all of the contents of STRING.  */
1007
1008 struct expression *
1009 parse_expression (char *string)
1010 {
1011   struct expression *exp;
1012   exp = parse_exp_1 (&string, 0, 0);
1013   if (*string)
1014     error (_("Junk after end of expression."));
1015   return exp;
1016 }
1017
1018
1019 /* As for parse_expression, except that if VOID_CONTEXT_P, then
1020    no value is expected from the expression.  */
1021
1022 struct expression *
1023 parse_expression_in_context (char *string, int void_context_p)
1024 {
1025   struct expression *exp;
1026   exp = parse_exp_in_context (&string, 0, 0, void_context_p);
1027   if (*string != '\000')
1028     error (_("Junk after end of expression."));
1029   return exp;
1030 }
1031
1032 /* A post-parser that does nothing */
1033
1034 void
1035 null_post_parser (struct expression **exp, int void_context_p)
1036 {
1037 }
1038 \f
1039 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1040    probably useful for any language which declares its types "backwards".  */
1041
1042 static void
1043 check_type_stack_depth (void)
1044 {
1045   if (type_stack_depth == type_stack_size)
1046     {
1047       type_stack_size *= 2;
1048       type_stack = (union type_stack_elt *)
1049         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1050     }
1051 }
1052
1053 void
1054 push_type (enum type_pieces tp)
1055 {
1056   check_type_stack_depth ();
1057   type_stack[type_stack_depth++].piece = tp;
1058 }
1059
1060 void
1061 push_type_int (int n)
1062 {
1063   check_type_stack_depth ();
1064   type_stack[type_stack_depth++].int_val = n;
1065 }
1066
1067 void
1068 push_type_address_space (char *string)
1069 {
1070   push_type_int (address_space_name_to_int (string));
1071 }
1072
1073 enum type_pieces
1074 pop_type (void)
1075 {
1076   if (type_stack_depth)
1077     return type_stack[--type_stack_depth].piece;
1078   return tp_end;
1079 }
1080
1081 int
1082 pop_type_int (void)
1083 {
1084   if (type_stack_depth)
1085     return type_stack[--type_stack_depth].int_val;
1086   /* "Can't happen".  */
1087   return 0;
1088 }
1089
1090 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1091    as modified by all the stuff on the stack.  */
1092 struct type *
1093 follow_types (struct type *follow_type)
1094 {
1095   int done = 0;
1096   int make_const = 0;
1097   int make_volatile = 0;
1098   int make_addr_space = 0;
1099   int array_size;
1100   struct type *range_type;
1101
1102   while (!done)
1103     switch (pop_type ())
1104       {
1105       case tp_end:
1106         done = 1;
1107         if (make_const)
1108           follow_type = make_cv_type (make_const,
1109                                       TYPE_VOLATILE (follow_type),
1110                                       follow_type, 0);
1111         if (make_volatile)
1112           follow_type = make_cv_type (TYPE_CONST (follow_type),
1113                                       make_volatile,
1114                                       follow_type, 0);
1115         if (make_addr_space)
1116           follow_type = make_type_with_address_space (follow_type,
1117                                                       make_addr_space);
1118         make_const = make_volatile = 0;
1119         make_addr_space = 0;
1120         break;
1121       case tp_const:
1122         make_const = 1;
1123         break;
1124       case tp_volatile:
1125         make_volatile = 1;
1126         break;
1127       case tp_space_identifier:
1128         make_addr_space = pop_type_int ();
1129         break;
1130       case tp_pointer:
1131         follow_type = lookup_pointer_type (follow_type);
1132         if (make_const)
1133           follow_type = make_cv_type (make_const,
1134                                       TYPE_VOLATILE (follow_type),
1135                                       follow_type, 0);
1136         if (make_volatile)
1137           follow_type = make_cv_type (TYPE_CONST (follow_type),
1138                                       make_volatile,
1139                                       follow_type, 0);
1140         if (make_addr_space)
1141           follow_type = make_type_with_address_space (follow_type,
1142                                                       make_addr_space);
1143         make_const = make_volatile = 0;
1144         make_addr_space = 0;
1145         break;
1146       case tp_reference:
1147         follow_type = lookup_reference_type (follow_type);
1148         if (make_const)
1149           follow_type = make_cv_type (make_const,
1150                                       TYPE_VOLATILE (follow_type),
1151                                       follow_type, 0);
1152         if (make_volatile)
1153           follow_type = make_cv_type (TYPE_CONST (follow_type),
1154                                       make_volatile,
1155                                       follow_type, 0);
1156         if (make_addr_space)
1157           follow_type = make_type_with_address_space (follow_type,
1158                                                       make_addr_space);
1159         make_const = make_volatile = 0;
1160         make_addr_space = 0;
1161         break;
1162       case tp_array:
1163         array_size = pop_type_int ();
1164         /* FIXME-type-allocation: need a way to free this type when we are
1165            done with it.  */
1166         range_type =
1167           create_range_type ((struct type *) NULL,
1168                              builtin_type_int, 0,
1169                              array_size >= 0 ? array_size - 1 : 0);
1170         follow_type =
1171           create_array_type ((struct type *) NULL,
1172                              follow_type, range_type);
1173         if (array_size < 0)
1174           TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1175             = BOUND_CANNOT_BE_DETERMINED;
1176         break;
1177       case tp_function:
1178         /* FIXME-type-allocation: need a way to free this type when we are
1179            done with it.  */
1180         follow_type = lookup_function_type (follow_type);
1181         break;
1182       }
1183   return follow_type;
1184 }
1185 \f
1186 /* This function avoids direct calls to fprintf
1187    in the parser generated debug code.  */
1188 void
1189 parser_fprintf (FILE *x, const char *y, ...)
1190 {
1191   va_list args;
1192   va_start (args, y);
1193   if (x == stderr)
1194     vfprintf_unfiltered (gdb_stderr, y, args);
1195   else
1196     {
1197       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1198       vfprintf_unfiltered (gdb_stderr, y, args);
1199     }
1200   va_end (args);
1201 }
1202
1203 void
1204 _initialize_parse (void)
1205 {
1206   type_stack_size = 80;
1207   type_stack_depth = 0;
1208   type_stack = (union type_stack_elt *)
1209     xmalloc (type_stack_size * sizeof (*type_stack));
1210
1211   add_setshow_zinteger_cmd ("expression", class_maintenance,
1212                             &expressiondebug, _("\
1213 Set expression debugging."), _("\
1214 Show expression debugging."), _("\
1215 When non-zero, the internal representation of expressions will be printed."),
1216                             NULL,
1217                             show_expressiondebug,
1218                             &setdebuglist, &showdebuglist);
1219 }