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