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