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