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 objfile *objfile = msymbol_objfile (msymbol);
 404   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 405
 406   CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
 407   asection *bfd_section = SYMBOL_BFD_SECTION (msymbol);
 408   enum minimal_symbol_type type = msymbol->type;
 409   CORE_ADDR pc;
 410
 411   /* The minimal symbol might point to a function descriptor;
 412      resolve it to the actual code address instead.  */
 413   pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
 414   if (pc != addr)
 415     {
 416       /* In this case, assume we have a code symbol instead of
 417          a data symbol.  */
 418       type = mst_text;
 419       bfd_section = NULL;
 420       addr = pc;
 421     }
 422
 423   if (overlay_debugging)
 424     addr = symbol_overlayed_address (addr, bfd_section);
 425
 426   write_exp_elt_opcode (OP_LONG);
 427   /* Let's make the type big enough to hold a 64-bit address.  */
 428   write_exp_elt_type (builtin_type_CORE_ADDR);
 429   write_exp_elt_longcst ((LONGEST) addr);
 430   write_exp_elt_opcode (OP_LONG);
 431
 432   if (bfd_section && bfd_section->flags & SEC_THREAD_LOCAL)
 433     {
 434       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 435       write_exp_elt_objfile (objfile);
 436       write_exp_elt_type (builtin_type (gdbarch)->nodebug_tls_symbol);
 437       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 438       return;
 439     }
 440
 441   write_exp_elt_opcode (UNOP_MEMVAL);
 442   switch (type)
 443     {
 444     case mst_text:
 445     case mst_file_text:
 446     case mst_solib_trampoline:
 447       write_exp_elt_type (builtin_type (gdbarch)->nodebug_text_symbol);
 448       break;
 449
 450     case mst_data:
 451     case mst_file_data:
 452     case mst_bss:
 453     case mst_file_bss:
 454       write_exp_elt_type (builtin_type (gdbarch)->nodebug_data_symbol);
 455       break;
 456
 457     default:
 458       write_exp_elt_type (builtin_type (gdbarch)->nodebug_unknown_symbol);
 459       break;
 460     }
 461   write_exp_elt_opcode (UNOP_MEMVAL);
 462 }
 463 \f
 464 /* Recognize tokens that start with '$'.  These include:
 465
 466    $regname     A native register name or a "standard
 467    register name".
 468
 469    $variable    A convenience variable with a name chosen
 470    by the user.
 471
 472    $digits              Value history with index <digits>, starting
 473    from the first value which has index 1.
 474
 475    $$digits     Value history with index <digits> relative
 476    to the last value.  I.E. $$0 is the last
 477    value, $$1 is the one previous to that, $$2
 478    is the one previous to $$1, etc.
 479
 480    $ | $0 | $$0 The last value in the value history.
 481
 482    $$           An abbreviation for the second to the last
 483    value in the value history, I.E. $$1
 484
 485  */
 486
 487 void
 488 write_dollar_variable (struct stoken str)
 489 {
 490   struct symbol *sym = NULL;
 491   struct minimal_symbol *msym = NULL;
 492   struct internalvar *isym = NULL;
 493
 494   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
 495      and $$digits (equivalent to $<-digits> if you could type that). */
 496
 497   int negate = 0;
 498   int i = 1;
 499   /* Double dollar means negate the number and add -1 as well.
 500      Thus $$ alone means -1.  */
 501   if (str.length >= 2 && str.ptr[1] == '$')
 502     {
 503       negate = 1;
 504       i = 2;
 505     }
 506   if (i == str.length)
 507     {
 508       /* Just dollars (one or two) */
 509       i = -negate;
 510       goto handle_last;
 511     }
 512   /* Is the rest of the token digits?  */
 513   for (; i < str.length; i++)
 514     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
 515       break;
 516   if (i == str.length)
 517     {
 518       i = atoi (str.ptr + 1 + negate);
 519       if (negate)
 520         i = -i;
 521       goto handle_last;
 522     }
 523
 524   /* Handle tokens that refer to machine registers:
 525      $ followed by a register name.  */
 526   i = frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
 527                                 str.ptr + 1, str.length - 1);
 528   if (i >= 0)
 529     goto handle_register;
 530
 531   /* Any names starting with $ are probably debugger internal variables.  */
 532
 533   isym = lookup_only_internalvar (copy_name (str) + 1);
 534   if (isym)
 535     {
 536       write_exp_elt_opcode (OP_INTERNALVAR);
 537       write_exp_elt_intern (isym);
 538       write_exp_elt_opcode (OP_INTERNALVAR);
 539       return;
 540     }
 541
 542   /* On some systems, such as HP-UX and hppa-linux, certain system routines
 543      have names beginning with $ or $$.  Check for those, first. */
 544
 545   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
 546                        VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL);
 547   if (sym)
 548     {
 549       write_exp_elt_opcode (OP_VAR_VALUE);
 550       write_exp_elt_block (block_found);        /* set by lookup_symbol */
 551       write_exp_elt_sym (sym);
 552       write_exp_elt_opcode (OP_VAR_VALUE);
 553       return;
 554     }
 555   msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
 556   if (msym)
 557     {
 558       write_exp_msymbol (msym,
 559                          lookup_function_type (builtin_type_int),
 560                          builtin_type_int);
 561       return;
 562     }
 563
 564   /* Any other names are assumed to be debugger internal variables.  */
 565
 566   write_exp_elt_opcode (OP_INTERNALVAR);
 567   write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
 568   write_exp_elt_opcode (OP_INTERNALVAR);
 569   return;
 570 handle_last:
 571   write_exp_elt_opcode (OP_LAST);
 572   write_exp_elt_longcst ((LONGEST) i);
 573   write_exp_elt_opcode (OP_LAST);
 574   return;
 575 handle_register:
 576   write_exp_elt_opcode (OP_REGISTER);
 577   str.length--;
 578   str.ptr++;
 579   write_exp_string (str);
 580   write_exp_elt_opcode (OP_REGISTER);
 581   return;
 582 }
 583
 584
 585 char *
 586 find_template_name_end (char *p)
 587 {
 588   int depth = 1;
 589   int just_seen_right = 0;
 590   int just_seen_colon = 0;
 591   int just_seen_space = 0;
 592
 593   if (!p || (*p != '<'))
 594     return 0;
 595
 596   while (*++p)
 597     {
 598       switch (*p)
 599         {
 600         case '\'':
 601         case '\"':
 602         case '{':
 603         case '}':
 604           /* In future, may want to allow these?? */
 605           return 0;
 606         case '<':
 607           depth++;              /* start nested template */
 608           if (just_seen_colon || just_seen_right || just_seen_space)
 609             return 0;           /* but not after : or :: or > or space */
 610           break;
 611         case '>':
 612           if (just_seen_colon || just_seen_right)
 613             return 0;           /* end a (nested?) template */
 614           just_seen_right = 1;  /* but not after : or :: */
 615           if (--depth == 0)     /* also disallow >>, insist on > > */
 616             return ++p;         /* if outermost ended, return */
 617           break;
 618         case ':':
 619           if (just_seen_space || (just_seen_colon > 1))
 620             return 0;           /* nested class spec coming up */
 621           just_seen_colon++;    /* we allow :: but not :::: */
 622           break;
 623         case ' ':
 624           break;
 625         default:
 626           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
 627                 (*p >= 'A' && *p <= 'Z') ||
 628                 (*p >= '0' && *p <= '9') ||
 629                 (*p == '_') || (*p == ',') ||   /* commas for template args */
 630                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
 631                 (*p == '(') || (*p == ')') ||   /* function types */
 632                 (*p == '[') || (*p == ']')))    /* array types */
 633             return 0;
 634         }
 635       if (*p != ' ')
 636         just_seen_space = 0;
 637       if (*p != ':')
 638         just_seen_colon = 0;
 639       if (*p != '>')
 640         just_seen_right = 0;
 641     }
 642   return 0;
 643 }
 644 \f
 645
 646
 647 /* Return a null-terminated temporary copy of the name
 648    of a string token.  */
 649
 650 char *
 651 copy_name (struct stoken token)
 652 {
 653   /* Make sure there's enough space for the token.  */
 654   if (namecopy_size < token.length + 1)
 655     {
 656       namecopy_size = token.length + 1;
 657       namecopy = xrealloc (namecopy, token.length + 1);
 658     }
 659
 660   memcpy (namecopy, token.ptr, token.length);
 661   namecopy[token.length] = 0;
 662
 663   return namecopy;
 664 }
 665 \f
 666 /* Reverse an expression from suffix form (in which it is constructed)
 667    to prefix form (in which we can conveniently print or execute it).  */
 668
 669 static void
 670 prefixify_expression (struct expression *expr)
 671 {
 672   int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
 673   struct expression *temp;
 674   int inpos = expr->nelts, outpos = 0;
 675
 676   temp = (struct expression *) alloca (len);
 677
 678   /* Copy the original expression into temp.  */
 679   memcpy (temp, expr, len);
 680
 681   prefixify_subexp (temp, expr, inpos, outpos);
 682 }
 683
 684 /* Return the number of exp_elements in the postfix subexpression
 685    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
 686
 687 int
 688 length_of_subexp (struct expression *expr, int endpos)
 689 {
 690   int oplen, args, i;
 691
 692   operator_length (expr, endpos, &oplen, &args);
 693
 694   while (args > 0)
 695     {
 696       oplen += length_of_subexp (expr, endpos - oplen);
 697       args--;
 698     }
 699
 700   return oplen;
 701 }
 702
 703 /* Sets *OPLENP to the length of the operator whose (last) index is
 704    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
 705    operator takes.  */
 706
 707 void
 708 operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp)
 709 {
 710   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
 711                                                      oplenp, argsp);
 712 }
 713
 714 /* Default value for operator_length in exp_descriptor vectors.  */
 715
 716 void
 717 operator_length_standard (struct expression *expr, int endpos,
 718                           int *oplenp, int *argsp)
 719 {
 720   int oplen = 1;
 721   int args = 0;
 722   enum f90_range_type range_type;
 723   int i;
 724
 725   if (endpos < 1)
 726     error (_("?error in operator_length_standard"));
 727
 728   i = (int) expr->elts[endpos - 1].opcode;
 729
 730   switch (i)
 731     {
 732       /* C++  */
 733     case OP_SCOPE:
 734       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 735       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 736       break;
 737
 738     case OP_LONG:
 739     case OP_DOUBLE:
 740     case OP_DECFLOAT:
 741     case OP_VAR_VALUE:
 742       oplen = 4;
 743       break;
 744
 745     case OP_TYPE:
 746     case OP_BOOL:
 747     case OP_LAST:
 748     case OP_INTERNALVAR:
 749       oplen = 3;
 750       break;
 751
 752     case OP_COMPLEX:
 753       oplen = 1;
 754       args = 2;
 755       break;
 756
 757     case OP_FUNCALL:
 758     case OP_F77_UNDETERMINED_ARGLIST:
 759       oplen = 3;
 760       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 761       break;
 762
 763     case OP_OBJC_MSGCALL:       /* Objective C message (method) call */
 764       oplen = 4;
 765       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 766       break;
 767
 768     case UNOP_MAX:
 769     case UNOP_MIN:
 770       oplen = 3;
 771       break;
 772
 773     case BINOP_VAL:
 774     case UNOP_CAST:
 775     case UNOP_MEMVAL:
 776       oplen = 3;
 777       args = 1;
 778       break;
 779
 780     case UNOP_MEMVAL_TLS:
 781       oplen = 4;
 782       args = 1;
 783       break;
 784
 785     case UNOP_ABS:
 786     case UNOP_CAP:
 787     case UNOP_CHR:
 788     case UNOP_FLOAT:
 789     case UNOP_HIGH:
 790     case UNOP_ODD:
 791     case UNOP_ORD:
 792     case UNOP_TRUNC:
 793       oplen = 1;
 794       args = 1;
 795       break;
 796
 797     case OP_LABELED:
 798     case STRUCTOP_STRUCT:
 799     case STRUCTOP_PTR:
 800       args = 1;
 801       /* fall through */
 802     case OP_REGISTER:
 803     case OP_M2_STRING:
 804     case OP_STRING:
 805     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class NSString constant */
 806     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op */
 807     case OP_NAME:
 808       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 809       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 810       break;
 811
 812     case OP_BITSTRING:
 813       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 814       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 815       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 816       break;
 817
 818     case OP_ARRAY:
 819       oplen = 4;
 820       args = longest_to_int (expr->elts[endpos - 2].longconst);
 821       args -= longest_to_int (expr->elts[endpos - 3].longconst);
 822       args += 1;
 823       break;
 824
 825     case TERNOP_COND:
 826     case TERNOP_SLICE:
 827     case TERNOP_SLICE_COUNT:
 828       args = 3;
 829       break;
 830
 831       /* Modula-2 */
 832     case MULTI_SUBSCRIPT:
 833       oplen = 3;
 834       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 835       break;
 836
 837     case BINOP_ASSIGN_MODIFY:
 838       oplen = 3;
 839       args = 2;
 840       break;
 841
 842       /* C++ */
 843     case OP_THIS:
 844     case OP_OBJC_SELF:
 845       oplen = 2;
 846       break;
 847
 848     case OP_F90_RANGE:
 849       oplen = 3;
 850
 851       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
 852       switch (range_type)
 853         {
 854         case LOW_BOUND_DEFAULT:
 855         case HIGH_BOUND_DEFAULT:
 856           args = 1;
 857           break;
 858         case BOTH_BOUND_DEFAULT:
 859           args = 0;
 860           break;
 861         case NONE_BOUND_DEFAULT:
 862           args = 2;
 863           break;
 864         }
 865
 866       break;
 867
 868     default:
 869       args = 1 + (i < (int) BINOP_END);
 870     }
 871
 872   *oplenp = oplen;
 873   *argsp = args;
 874 }
 875
 876 /* Copy the subexpression ending just before index INEND in INEXPR
 877    into OUTEXPR, starting at index OUTBEG.
 878    In the process, convert it from suffix to prefix form.  */
 879
 880 static void
 881 prefixify_subexp (struct expression *inexpr,
 882                   struct expression *outexpr, int inend, int outbeg)
 883 {
 884   int oplen;
 885   int args;
 886   int i;
 887   int *arglens;
 888   enum exp_opcode opcode;
 889
 890   operator_length (inexpr, inend, &oplen, &args);
 891
 892   /* Copy the final operator itself, from the end of the input
 893      to the beginning of the output.  */
 894   inend -= oplen;
 895   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
 896           EXP_ELEM_TO_BYTES (oplen));
 897   outbeg += oplen;
 898
 899   /* Find the lengths of the arg subexpressions.  */
 900   arglens = (int *) alloca (args * sizeof (int));
 901   for (i = args - 1; i >= 0; i--)
 902     {
 903       oplen = length_of_subexp (inexpr, inend);
 904       arglens[i] = oplen;
 905       inend -= oplen;
 906     }
 907
 908   /* Now copy each subexpression, preserving the order of
 909      the subexpressions, but prefixifying each one.
 910      In this loop, inend starts at the beginning of
 911      the expression this level is working on
 912      and marches forward over the arguments.
 913      outbeg does similarly in the output.  */
 914   for (i = 0; i < args; i++)
 915     {
 916       oplen = arglens[i];
 917       inend += oplen;
 918       prefixify_subexp (inexpr, outexpr, inend, outbeg);
 919       outbeg += oplen;
 920     }
 921 }
 922 \f
 923 /* This page contains the two entry points to this file.  */
 924
 925 /* Read an expression from the string *STRINGPTR points to,
 926    parse it, and return a pointer to a  struct expression  that we malloc.
 927    Use block BLOCK as the lexical context for variable names;
 928    if BLOCK is zero, use the block of the selected stack frame.
 929    Meanwhile, advance *STRINGPTR to point after the expression,
 930    at the first nonwhite character that is not part of the expression
 931    (possibly a null character).
 932
 933    If COMMA is nonzero, stop if a comma is reached.  */
 934
 935 struct expression *
 936 parse_exp_1 (char **stringptr, struct block *block, int comma)
 937 {
 938   return parse_exp_in_context (stringptr, block, comma, 0);
 939 }
 940
 941 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
 942    no value is expected from the expression.  */
 943
 944 static struct expression *
 945 parse_exp_in_context (char **stringptr, struct block *block, int comma,
 946                       int void_context_p)
 947 {
 948   struct cleanup *old_chain;
 949
 950   lexptr = *stringptr;
 951   prev_lexptr = NULL;
 952
 953   paren_depth = 0;
 954   type_stack_depth = 0;
 955
 956   comma_terminates = comma;
 957
 958   if (lexptr == 0 || *lexptr == 0)
 959     error_no_arg (_("expression to compute"));
 960
 961   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
 962   funcall_chain = 0;
 963
 964   expression_context_block = block;
 965
 966   /* If no context specified, try using the current frame, if any.  */
 967   if (!expression_context_block)
 968     expression_context_block = get_selected_block (&expression_context_pc);
 969   else
 970     expression_context_pc = BLOCK_START (expression_context_block);
 971
 972   /* Fall back to using the current source static context, if any.  */
 973
 974   if (!expression_context_block)
 975     {
 976       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 977       if (cursal.symtab)
 978         expression_context_block
 979           = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
 980       if (expression_context_block)
 981         expression_context_pc = BLOCK_START (expression_context_block);
 982     }
 983
 984   expout_size = 10;
 985   expout_ptr = 0;
 986   expout = (struct expression *)
 987     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
 988   expout->language_defn = current_language;
 989   make_cleanup (free_current_contents, &expout);
 990
 991   if (current_language->la_parser ())
 992     current_language->la_error (NULL);
 993
 994   discard_cleanups (old_chain);
 995
 996   /* Record the actual number of expression elements, and then
 997      reallocate the expression memory so that we free up any
 998      excess elements. */
 999
1000   expout->nelts = expout_ptr;
1001   expout = (struct expression *)
1002     xrealloc ((char *) expout,
1003               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1004
1005   /* Convert expression from postfix form as generated by yacc
1006      parser, to a prefix form. */
1007
1008   if (expressiondebug)
1009     dump_raw_expression (expout, gdb_stdlog,
1010                          "before conversion to prefix form");
1011
1012   prefixify_expression (expout);
1013
1014   current_language->la_post_parser (&expout, void_context_p);
1015
1016   if (expressiondebug)
1017     dump_prefix_expression (expout, gdb_stdlog);
1018
1019   *stringptr = lexptr;
1020   return expout;
1021 }
1022
1023 /* Parse STRING as an expression, and complain if this fails
1024    to use up all of the contents of STRING.  */
1025
1026 struct expression *
1027 parse_expression (char *string)
1028 {
1029   struct expression *exp;
1030   exp = parse_exp_1 (&string, 0, 0);
1031   if (*string)
1032     error (_("Junk after end of expression."));
1033   return exp;
1034 }
1035
1036 /* A post-parser that does nothing */
1037
1038 void
1039 null_post_parser (struct expression **exp, int void_context_p)
1040 {
1041 }
1042 \f
1043 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1044    probably useful for any language which declares its types "backwards".  */
1045
1046 static void
1047 check_type_stack_depth (void)
1048 {
1049   if (type_stack_depth == type_stack_size)
1050     {
1051       type_stack_size *= 2;
1052       type_stack = (union type_stack_elt *)
1053         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1054     }
1055 }
1056
1057 void
1058 push_type (enum type_pieces tp)
1059 {
1060   check_type_stack_depth ();
1061   type_stack[type_stack_depth++].piece = tp;
1062 }
1063
1064 void
1065 push_type_int (int n)
1066 {
1067   check_type_stack_depth ();
1068   type_stack[type_stack_depth++].int_val = n;
1069 }
1070
1071 void
1072 push_type_address_space (char *string)
1073 {
1074   push_type_int (address_space_name_to_int (string));
1075 }
1076
1077 enum type_pieces
1078 pop_type (void)
1079 {
1080   if (type_stack_depth)
1081     return type_stack[--type_stack_depth].piece;
1082   return tp_end;
1083 }
1084
1085 int
1086 pop_type_int (void)
1087 {
1088   if (type_stack_depth)
1089     return type_stack[--type_stack_depth].int_val;
1090   /* "Can't happen".  */
1091   return 0;
1092 }
1093
1094 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1095    as modified by all the stuff on the stack.  */
1096 struct type *
1097 follow_types (struct type *follow_type)
1098 {
1099   int done = 0;
1100   int make_const = 0;
1101   int make_volatile = 0;
1102   int make_addr_space = 0;
1103   int array_size;
1104   struct type *range_type;
1105
1106   while (!done)
1107     switch (pop_type ())
1108       {
1109       case tp_end:
1110         done = 1;
1111         if (make_const)
1112           follow_type = make_cv_type (make_const,
1113                                       TYPE_VOLATILE (follow_type),
1114                                       follow_type, 0);
1115         if (make_volatile)
1116           follow_type = make_cv_type (TYPE_CONST (follow_type),
1117                                       make_volatile,
1118                                       follow_type, 0);
1119         if (make_addr_space)
1120           follow_type = make_type_with_address_space (follow_type,
1121                                                       make_addr_space);
1122         make_const = make_volatile = 0;
1123         make_addr_space = 0;
1124         break;
1125       case tp_const:
1126         make_const = 1;
1127         break;
1128       case tp_volatile:
1129         make_volatile = 1;
1130         break;
1131       case tp_space_identifier:
1132         make_addr_space = pop_type_int ();
1133         break;
1134       case tp_pointer:
1135         follow_type = lookup_pointer_type (follow_type);
1136         if (make_const)
1137           follow_type = make_cv_type (make_const,
1138                                       TYPE_VOLATILE (follow_type),
1139                                       follow_type, 0);
1140         if (make_volatile)
1141           follow_type = make_cv_type (TYPE_CONST (follow_type),
1142                                       make_volatile,
1143                                       follow_type, 0);
1144         if (make_addr_space)
1145           follow_type = make_type_with_address_space (follow_type,
1146                                                       make_addr_space);
1147         make_const = make_volatile = 0;
1148         make_addr_space = 0;
1149         break;
1150       case tp_reference:
1151         follow_type = lookup_reference_type (follow_type);
1152         if (make_const)
1153           follow_type = make_cv_type (make_const,
1154                                       TYPE_VOLATILE (follow_type),
1155                                       follow_type, 0);
1156         if (make_volatile)
1157           follow_type = make_cv_type (TYPE_CONST (follow_type),
1158                                       make_volatile,
1159                                       follow_type, 0);
1160         if (make_addr_space)
1161           follow_type = make_type_with_address_space (follow_type,
1162                                                       make_addr_space);
1163         make_const = make_volatile = 0;
1164         make_addr_space = 0;
1165         break;
1166       case tp_array:
1167         array_size = pop_type_int ();
1168         /* FIXME-type-allocation: need a way to free this type when we are
1169            done with it.  */
1170         range_type =
1171           create_range_type ((struct type *) NULL,
1172                              builtin_type_int, 0,
1173                              array_size >= 0 ? array_size - 1 : 0);
1174         follow_type =
1175           create_array_type ((struct type *) NULL,
1176                              follow_type, range_type);
1177         if (array_size < 0)
1178           TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1179             = BOUND_CANNOT_BE_DETERMINED;
1180         break;
1181       case tp_function:
1182         /* FIXME-type-allocation: need a way to free this type when we are
1183            done with it.  */
1184         follow_type = lookup_function_type (follow_type);
1185         break;
1186       }
1187   return follow_type;
1188 }
1189 \f
1190 /* This function avoids direct calls to fprintf
1191    in the parser generated debug code.  */
1192 void
1193 parser_fprintf (FILE *x, const char *y, ...)
1194 {
1195   va_list args;
1196   va_start (args, y);
1197   if (x == stderr)
1198     vfprintf_unfiltered (gdb_stderr, y, args);
1199   else
1200     {
1201       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1202       vfprintf_unfiltered (gdb_stderr, y, args);
1203     }
1204   va_end (args);
1205 }
1206
1207 void
1208 _initialize_parse (void)
1209 {
1210   type_stack_size = 80;
1211   type_stack_depth = 0;
1212   type_stack = (union type_stack_elt *)
1213     xmalloc (type_stack_size * sizeof (*type_stack));
1214
1215   add_setshow_zinteger_cmd ("expression", class_maintenance,
1216                             &expressiondebug, _("\
1217 Set expression debugging."), _("\
1218 Show expression debugging."), _("\
1219 When non-zero, the internal representation of expressions will be printed."),
1220                             NULL,
1221                             show_expressiondebug,
1222                             &setdebuglist, &showdebuglist);
1223 }