gdb/parse.c

   1 /* Parse expressions for GDB.
   2
   3    Copyright (C) 1986, 1989-2001, 2004-2005, 2007-2012 Free Software
   4    Foundation, Inc.
   5
   6    Modified from expread.y by the Department of Computer Science at the
   7    State University of New York at Buffalo, 1991.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 /* Parse an expression from text in a string,
  25    and return the result as a struct expression pointer.
  26    That structure contains arithmetic operations in reverse polish,
  27    with constants represented by operations that are followed by special data.
  28    See expression.h for the details of the format.
  29    What is important here is that it can be built up sequentially
  30    during the process of parsing; the lower levels of the tree always
  31    come first in the result.  */
  32
  33 #include "defs.h"
  34 #include <ctype.h>
  35 #include "arch-utils.h"
  36 #include "gdb_string.h"
  37 #include "symtab.h"
  38 #include "gdbtypes.h"
  39 #include "frame.h"
  40 #include "expression.h"
  41 #include "value.h"
  42 #include "command.h"
  43 #include "language.h"
  44 #include "f-lang.h"
  45 #include "parser-defs.h"
  46 #include "gdbcmd.h"
  47 #include "symfile.h"            /* for overlay functions */
  48 #include "inferior.h"
  49 #include "doublest.h"
  50 #include "gdb_assert.h"
  51 #include "block.h"
  52 #include "source.h"
  53 #include "objfiles.h"
  54 #include "exceptions.h"
  55 #include "user-regs.h"
  56
  57 /* Standard set of definitions for printing, dumping, prefixifying,
  58  * and evaluating expressions.  */
  59
  60 const struct exp_descriptor exp_descriptor_standard =
  61   {
  62     print_subexp_standard,
  63     operator_length_standard,
  64     operator_check_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
 171   funcall_chain = call->next;
 172   arglist_len = call->arglist_len;
 173   xfree (call);
 174   return val;
 175 }
 176
 177 /* Free everything in the funcall chain.
 178    Used when there is an error inside parsing.  */
 179
 180 static void
 181 free_funcalls (void *ignore)
 182 {
 183   struct funcall *call, *next;
 184
 185   for (call = funcall_chain; call; call = next)
 186     {
 187       next = call->next;
 188       xfree (call);
 189     }
 190 }
 191 \f
 192 /* This page contains the functions for adding data to the struct expression
 193    being constructed.  */
 194
 195 /* Add one element to the end of the expression.  */
 196
 197 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
 198    a register through here.  */
 199
 200 static void
 201 write_exp_elt (const union exp_element *expelt)
 202 {
 203   if (expout_ptr >= expout_size)
 204     {
 205       expout_size *= 2;
 206       expout = (struct expression *)
 207         xrealloc ((char *) expout, sizeof (struct expression)
 208                   + EXP_ELEM_TO_BYTES (expout_size));
 209     }
 210   expout->elts[expout_ptr++] = *expelt;
 211 }
 212
 213 void
 214 write_exp_elt_opcode (enum exp_opcode expelt)
 215 {
 216   union exp_element tmp;
 217
 218   memset (&tmp, 0, sizeof (union exp_element));
 219   tmp.opcode = expelt;
 220   write_exp_elt (&tmp);
 221 }
 222
 223 void
 224 write_exp_elt_sym (struct symbol *expelt)
 225 {
 226   union exp_element tmp;
 227
 228   memset (&tmp, 0, sizeof (union exp_element));
 229   tmp.symbol = expelt;
 230   write_exp_elt (&tmp);
 231 }
 232
 233 void
 234 write_exp_elt_block (struct block *b)
 235 {
 236   union exp_element tmp;
 237
 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
 248   memset (&tmp, 0, sizeof (union exp_element));
 249   tmp.objfile = objfile;
 250   write_exp_elt (&tmp);
 251 }
 252
 253 void
 254 write_exp_elt_longcst (LONGEST expelt)
 255 {
 256   union exp_element tmp;
 257
 258   memset (&tmp, 0, sizeof (union exp_element));
 259   tmp.longconst = expelt;
 260   write_exp_elt (&tmp);
 261 }
 262
 263 void
 264 write_exp_elt_dblcst (DOUBLEST expelt)
 265 {
 266   union exp_element tmp;
 267
 268   memset (&tmp, 0, sizeof (union exp_element));
 269   tmp.doubleconst = expelt;
 270   write_exp_elt (&tmp);
 271 }
 272
 273 void
 274 write_exp_elt_decfloatcst (gdb_byte expelt[16])
 275 {
 276   union exp_element tmp;
 277   int index;
 278
 279   for (index = 0; index < 16; index++)
 280     tmp.decfloatconst[index] = expelt[index];
 281
 282   write_exp_elt (&tmp);
 283 }
 284
 285 void
 286 write_exp_elt_type (struct type *expelt)
 287 {
 288   union exp_element tmp;
 289
 290   memset (&tmp, 0, sizeof (union exp_element));
 291   tmp.type = expelt;
 292   write_exp_elt (&tmp);
 293 }
 294
 295 void
 296 write_exp_elt_intern (struct internalvar *expelt)
 297 {
 298   union exp_element tmp;
 299
 300   memset (&tmp, 0, sizeof (union exp_element));
 301   tmp.internalvar = expelt;
 302   write_exp_elt (&tmp);
 303 }
 304
 305 /* Add a string constant to the end of the expression.
 306
 307    String constants are stored by first writing an expression element
 308    that contains the length of the string, then stuffing the string
 309    constant itself into however many expression elements are needed
 310    to hold it, and then writing another expression element that contains
 311    the length of the string.  I.e. an expression element at each end of
 312    the string records the string length, so you can skip over the
 313    expression elements containing the actual string bytes from either
 314    end of the string.  Note that this also allows gdb to handle
 315    strings with embedded null bytes, as is required for some languages.
 316
 317    Don't be fooled by the fact that the string is null byte terminated,
 318    this is strictly for the convenience of debugging gdb itself.
 319    Gdb does not depend up the string being null terminated, since the
 320    actual length is recorded in expression elements at each end of the
 321    string.  The null byte is taken into consideration when computing how
 322    many expression elements are required to hold the string constant, of
 323    course.  */
 324
 325
 326 void
 327 write_exp_string (struct stoken str)
 328 {
 329   int len = str.length;
 330   int lenelt;
 331   char *strdata;
 332
 333   /* Compute the number of expression elements required to hold the string
 334      (including a null byte terminator), along with one expression element
 335      at each end to record the actual string length (not including the
 336      null byte terminator).  */
 337
 338   lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
 339
 340   /* Ensure that we have enough available expression elements to store
 341      everything.  */
 342
 343   if ((expout_ptr + lenelt) >= expout_size)
 344     {
 345       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 346       expout = (struct expression *)
 347         xrealloc ((char *) expout, (sizeof (struct expression)
 348                                     + EXP_ELEM_TO_BYTES (expout_size)));
 349     }
 350
 351   /* Write the leading length expression element (which advances the current
 352      expression element index), then write the string constant followed by a
 353      terminating null byte, and then write the trailing length expression
 354      element.  */
 355
 356   write_exp_elt_longcst ((LONGEST) len);
 357   strdata = (char *) &expout->elts[expout_ptr];
 358   memcpy (strdata, str.ptr, len);
 359   *(strdata + len) = '\0';
 360   expout_ptr += lenelt - 2;
 361   write_exp_elt_longcst ((LONGEST) len);
 362 }
 363
 364 /* Add a vector of string constants to the end of the expression.
 365
 366    This adds an OP_STRING operation, but encodes the contents
 367    differently from write_exp_string.  The language is expected to
 368    handle evaluation of this expression itself.
 369
 370    After the usual OP_STRING header, TYPE is written into the
 371    expression as a long constant.  The interpretation of this field is
 372    up to the language evaluator.
 373
 374    Next, each string in VEC is written.  The length is written as a
 375    long constant, followed by the contents of the string.  */
 376
 377 void
 378 write_exp_string_vector (int type, struct stoken_vector *vec)
 379 {
 380   int i, n_slots, len;
 381
 382   /* Compute the size.  We compute the size in number of slots to
 383      avoid issues with string padding.  */
 384   n_slots = 0;
 385   for (i = 0; i < vec->len; ++i)
 386     {
 387       /* One slot for the length of this element, plus the number of
 388          slots needed for this string.  */
 389       n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length);
 390     }
 391
 392   /* One more slot for the type of the string.  */
 393   ++n_slots;
 394
 395   /* Now compute a phony string length.  */
 396   len = EXP_ELEM_TO_BYTES (n_slots) - 1;
 397
 398   n_slots += 4;
 399   if ((expout_ptr + n_slots) >= expout_size)
 400     {
 401       expout_size = max (expout_size * 2, expout_ptr + n_slots + 10);
 402       expout = (struct expression *)
 403         xrealloc ((char *) expout, (sizeof (struct expression)
 404                                     + EXP_ELEM_TO_BYTES (expout_size)));
 405     }
 406
 407   write_exp_elt_opcode (OP_STRING);
 408   write_exp_elt_longcst (len);
 409   write_exp_elt_longcst (type);
 410
 411   for (i = 0; i < vec->len; ++i)
 412     {
 413       write_exp_elt_longcst (vec->tokens[i].length);
 414       memcpy (&expout->elts[expout_ptr], vec->tokens[i].ptr,
 415               vec->tokens[i].length);
 416       expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length);
 417     }
 418
 419   write_exp_elt_longcst (len);
 420   write_exp_elt_opcode (OP_STRING);
 421 }
 422
 423 /* Add a bitstring constant to the end of the expression.
 424
 425    Bitstring constants are stored by first writing an expression element
 426    that contains the length of the bitstring (in bits), then stuffing the
 427    bitstring constant itself into however many expression elements are
 428    needed to hold it, and then writing another expression element that
 429    contains the length of the bitstring.  I.e. an expression element at
 430    each end of the bitstring records the bitstring length, so you can skip
 431    over the expression elements containing the actual bitstring bytes from
 432    either end of the bitstring.  */
 433
 434 void
 435 write_exp_bitstring (struct stoken str)
 436 {
 437   int bits = str.length;        /* length in bits */
 438   int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 439   int lenelt;
 440   char *strdata;
 441
 442   /* Compute the number of expression elements required to hold the bitstring,
 443      along with one expression element at each end to record the actual
 444      bitstring length in bits.  */
 445
 446   lenelt = 2 + BYTES_TO_EXP_ELEM (len);
 447
 448   /* Ensure that we have enough available expression elements to store
 449      everything.  */
 450
 451   if ((expout_ptr + lenelt) >= expout_size)
 452     {
 453       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 454       expout = (struct expression *)
 455         xrealloc ((char *) expout, (sizeof (struct expression)
 456                                     + EXP_ELEM_TO_BYTES (expout_size)));
 457     }
 458
 459   /* Write the leading length expression element (which advances the current
 460      expression element index), then write the bitstring constant, and then
 461      write the trailing length expression element.  */
 462
 463   write_exp_elt_longcst ((LONGEST) bits);
 464   strdata = (char *) &expout->elts[expout_ptr];
 465   memcpy (strdata, str.ptr, len);
 466   expout_ptr += lenelt - 2;
 467   write_exp_elt_longcst ((LONGEST) bits);
 468 }
 469
 470 /* Add the appropriate elements for a minimal symbol to the end of
 471    the expression.  */
 472
 473 void
 474 write_exp_msymbol (struct minimal_symbol *msymbol)
 475 {
 476   struct objfile *objfile = msymbol_objfile (msymbol);
 477   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 478
 479   CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
 480   struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol);
 481   enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
 482   CORE_ADDR pc;
 483
 484   /* The minimal symbol might point to a function descriptor;
 485      resolve it to the actual code address instead.  */
 486   pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
 487   if (pc != addr)
 488     {
 489       struct minimal_symbol *ifunc_msym = lookup_minimal_symbol_by_pc (pc);
 490
 491       /* In this case, assume we have a code symbol instead of
 492          a data symbol.  */
 493
 494       if (ifunc_msym != NULL && MSYMBOL_TYPE (ifunc_msym) == mst_text_gnu_ifunc
 495           && SYMBOL_VALUE_ADDRESS (ifunc_msym) == pc)
 496         {
 497           /* A function descriptor has been resolved but PC is still in the
 498              STT_GNU_IFUNC resolver body (such as because inferior does not
 499              run to be able to call it).  */
 500
 501           type = mst_text_gnu_ifunc;
 502         }
 503       else
 504         type = mst_text;
 505       section = NULL;
 506       addr = pc;
 507     }
 508
 509   if (overlay_debugging)
 510     addr = symbol_overlayed_address (addr, section);
 511
 512   write_exp_elt_opcode (OP_LONG);
 513   /* Let's make the type big enough to hold a 64-bit address.  */
 514   write_exp_elt_type (objfile_type (objfile)->builtin_core_addr);
 515   write_exp_elt_longcst ((LONGEST) addr);
 516   write_exp_elt_opcode (OP_LONG);
 517
 518   if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
 519     {
 520       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 521       write_exp_elt_objfile (objfile);
 522       write_exp_elt_type (objfile_type (objfile)->nodebug_tls_symbol);
 523       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 524       return;
 525     }
 526
 527   write_exp_elt_opcode (UNOP_MEMVAL);
 528   switch (type)
 529     {
 530     case mst_text:
 531     case mst_file_text:
 532     case mst_solib_trampoline:
 533       write_exp_elt_type (objfile_type (objfile)->nodebug_text_symbol);
 534       break;
 535
 536     case mst_text_gnu_ifunc:
 537       write_exp_elt_type (objfile_type (objfile)
 538                                                ->nodebug_text_gnu_ifunc_symbol);
 539       break;
 540
 541     case mst_data:
 542     case mst_file_data:
 543     case mst_bss:
 544     case mst_file_bss:
 545       write_exp_elt_type (objfile_type (objfile)->nodebug_data_symbol);
 546       break;
 547
 548     case mst_slot_got_plt:
 549       write_exp_elt_type (objfile_type (objfile)->nodebug_got_plt_symbol);
 550       break;
 551
 552     default:
 553       write_exp_elt_type (objfile_type (objfile)->nodebug_unknown_symbol);
 554       break;
 555     }
 556   write_exp_elt_opcode (UNOP_MEMVAL);
 557 }
 558
 559 /* Mark the current index as the starting location of a structure
 560    expression.  This is used when completing on field names.  */
 561
 562 void
 563 mark_struct_expression (void)
 564 {
 565   expout_last_struct = expout_ptr;
 566 }
 567
 568 \f
 569 /* Recognize tokens that start with '$'.  These include:
 570
 571    $regname     A native register name or a "standard
 572    register name".
 573
 574    $variable    A convenience variable with a name chosen
 575    by the user.
 576
 577    $digits              Value history with index <digits>, starting
 578    from the first value which has index 1.
 579
 580    $$digits     Value history with index <digits> relative
 581    to the last value.  I.e. $$0 is the last
 582    value, $$1 is the one previous to that, $$2
 583    is the one previous to $$1, etc.
 584
 585    $ | $0 | $$0 The last value in the value history.
 586
 587    $$           An abbreviation for the second to the last
 588    value in the value history, I.e. $$1  */
 589
 590 void
 591 write_dollar_variable (struct stoken str)
 592 {
 593   struct symbol *sym = NULL;
 594   struct minimal_symbol *msym = NULL;
 595   struct internalvar *isym = NULL;
 596
 597   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
 598      and $$digits (equivalent to $<-digits> if you could type that).  */
 599
 600   int negate = 0;
 601   int i = 1;
 602   /* Double dollar means negate the number and add -1 as well.
 603      Thus $$ alone means -1.  */
 604   if (str.length >= 2 && str.ptr[1] == '$')
 605     {
 606       negate = 1;
 607       i = 2;
 608     }
 609   if (i == str.length)
 610     {
 611       /* Just dollars (one or two).  */
 612       i = -negate;
 613       goto handle_last;
 614     }
 615   /* Is the rest of the token digits?  */
 616   for (; i < str.length; i++)
 617     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
 618       break;
 619   if (i == str.length)
 620     {
 621       i = atoi (str.ptr + 1 + negate);
 622       if (negate)
 623         i = -i;
 624       goto handle_last;
 625     }
 626
 627   /* Handle tokens that refer to machine registers:
 628      $ followed by a register name.  */
 629   i = user_reg_map_name_to_regnum (parse_gdbarch,
 630                                    str.ptr + 1, str.length - 1);
 631   if (i >= 0)
 632     goto handle_register;
 633
 634   /* Any names starting with $ are probably debugger internal variables.  */
 635
 636   isym = lookup_only_internalvar (copy_name (str) + 1);
 637   if (isym)
 638     {
 639       write_exp_elt_opcode (OP_INTERNALVAR);
 640       write_exp_elt_intern (isym);
 641       write_exp_elt_opcode (OP_INTERNALVAR);
 642       return;
 643     }
 644
 645   /* On some systems, such as HP-UX and hppa-linux, certain system routines
 646      have names beginning with $ or $$.  Check for those, first.  */
 647
 648   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
 649                        VAR_DOMAIN, (int *) NULL);
 650   if (sym)
 651     {
 652       write_exp_elt_opcode (OP_VAR_VALUE);
 653       write_exp_elt_block (block_found);        /* set by lookup_symbol */
 654       write_exp_elt_sym (sym);
 655       write_exp_elt_opcode (OP_VAR_VALUE);
 656       return;
 657     }
 658   msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
 659   if (msym)
 660     {
 661       write_exp_msymbol (msym);
 662       return;
 663     }
 664
 665   /* Any other names are assumed to be debugger internal variables.  */
 666
 667   write_exp_elt_opcode (OP_INTERNALVAR);
 668   write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
 669   write_exp_elt_opcode (OP_INTERNALVAR);
 670   return;
 671 handle_last:
 672   write_exp_elt_opcode (OP_LAST);
 673   write_exp_elt_longcst ((LONGEST) i);
 674   write_exp_elt_opcode (OP_LAST);
 675   return;
 676 handle_register:
 677   write_exp_elt_opcode (OP_REGISTER);
 678   str.length--;
 679   str.ptr++;
 680   write_exp_string (str);
 681   write_exp_elt_opcode (OP_REGISTER);
 682   return;
 683 }
 684
 685
 686 char *
 687 find_template_name_end (char *p)
 688 {
 689   int depth = 1;
 690   int just_seen_right = 0;
 691   int just_seen_colon = 0;
 692   int just_seen_space = 0;
 693
 694   if (!p || (*p != '<'))
 695     return 0;
 696
 697   while (*++p)
 698     {
 699       switch (*p)
 700         {
 701         case '\'':
 702         case '\"':
 703         case '{':
 704         case '}':
 705           /* In future, may want to allow these??  */
 706           return 0;
 707         case '<':
 708           depth++;              /* start nested template */
 709           if (just_seen_colon || just_seen_right || just_seen_space)
 710             return 0;           /* but not after : or :: or > or space */
 711           break;
 712         case '>':
 713           if (just_seen_colon || just_seen_right)
 714             return 0;           /* end a (nested?) template */
 715           just_seen_right = 1;  /* but not after : or :: */
 716           if (--depth == 0)     /* also disallow >>, insist on > > */
 717             return ++p;         /* if outermost ended, return */
 718           break;
 719         case ':':
 720           if (just_seen_space || (just_seen_colon > 1))
 721             return 0;           /* nested class spec coming up */
 722           just_seen_colon++;    /* we allow :: but not :::: */
 723           break;
 724         case ' ':
 725           break;
 726         default:
 727           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
 728                 (*p >= 'A' && *p <= 'Z') ||
 729                 (*p >= '0' && *p <= '9') ||
 730                 (*p == '_') || (*p == ',') ||   /* commas for template args */
 731                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
 732                 (*p == '(') || (*p == ')') ||   /* function types */
 733                 (*p == '[') || (*p == ']')))    /* array types */
 734             return 0;
 735         }
 736       if (*p != ' ')
 737         just_seen_space = 0;
 738       if (*p != ':')
 739         just_seen_colon = 0;
 740       if (*p != '>')
 741         just_seen_right = 0;
 742     }
 743   return 0;
 744 }
 745 \f
 746
 747
 748 /* Return a null-terminated temporary copy of the name
 749    of a string token.  */
 750
 751 char *
 752 copy_name (struct stoken token)
 753 {
 754   /* Make sure there's enough space for the token.  */
 755   if (namecopy_size < token.length + 1)
 756     {
 757       namecopy_size = token.length + 1;
 758       namecopy = xrealloc (namecopy, token.length + 1);
 759     }
 760
 761   memcpy (namecopy, token.ptr, token.length);
 762   namecopy[token.length] = 0;
 763
 764   return namecopy;
 765 }
 766 \f
 767 /* Reverse an expression from suffix form (in which it is constructed)
 768    to prefix form (in which we can conveniently print or execute it).
 769    Ordinarily this always returns -1.  However, if EXPOUT_LAST_STRUCT
 770    is not -1 (i.e., we are trying to complete a field name), it will
 771    return the index of the subexpression which is the left-hand-side
 772    of the struct operation at EXPOUT_LAST_STRUCT.  */
 773
 774 static int
 775 prefixify_expression (struct expression *expr)
 776 {
 777   int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
 778   struct expression *temp;
 779   int inpos = expr->nelts, outpos = 0;
 780
 781   temp = (struct expression *) alloca (len);
 782
 783   /* Copy the original expression into temp.  */
 784   memcpy (temp, expr, len);
 785
 786   return prefixify_subexp (temp, expr, inpos, outpos);
 787 }
 788
 789 /* Return the number of exp_elements in the postfix subexpression
 790    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
 791
 792 int
 793 length_of_subexp (struct expression *expr, int endpos)
 794 {
 795   int oplen, args;
 796
 797   operator_length (expr, endpos, &oplen, &args);
 798
 799   while (args > 0)
 800     {
 801       oplen += length_of_subexp (expr, endpos - oplen);
 802       args--;
 803     }
 804
 805   return oplen;
 806 }
 807
 808 /* Sets *OPLENP to the length of the operator whose (last) index is
 809    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
 810    operator takes.  */
 811
 812 void
 813 operator_length (const struct expression *expr, int endpos, int *oplenp,
 814                  int *argsp)
 815 {
 816   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
 817                                                      oplenp, argsp);
 818 }
 819
 820 /* Default value for operator_length in exp_descriptor vectors.  */
 821
 822 void
 823 operator_length_standard (const struct expression *expr, int endpos,
 824                           int *oplenp, int *argsp)
 825 {
 826   int oplen = 1;
 827   int args = 0;
 828   enum f90_range_type range_type;
 829   int i;
 830
 831   if (endpos < 1)
 832     error (_("?error in operator_length_standard"));
 833
 834   i = (int) expr->elts[endpos - 1].opcode;
 835
 836   switch (i)
 837     {
 838       /* C++  */
 839     case OP_SCOPE:
 840       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 841       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 842       break;
 843
 844     case OP_LONG:
 845     case OP_DOUBLE:
 846     case OP_DECFLOAT:
 847     case OP_VAR_VALUE:
 848       oplen = 4;
 849       break;
 850
 851     case OP_TYPE:
 852     case OP_BOOL:
 853     case OP_LAST:
 854     case OP_INTERNALVAR:
 855     case OP_VAR_ENTRY_VALUE:
 856       oplen = 3;
 857       break;
 858
 859     case OP_COMPLEX:
 860       oplen = 3;
 861       args = 2;
 862       break;
 863
 864     case OP_FUNCALL:
 865     case OP_F77_UNDETERMINED_ARGLIST:
 866       oplen = 3;
 867       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 868       break;
 869
 870     case TYPE_INSTANCE:
 871       oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst);
 872       args = 1;
 873       break;
 874
 875     case OP_OBJC_MSGCALL:       /* Objective C message (method) call.  */
 876       oplen = 4;
 877       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 878       break;
 879
 880     case UNOP_MAX:
 881     case UNOP_MIN:
 882       oplen = 3;
 883       break;
 884
 885     case BINOP_VAL:
 886     case UNOP_CAST:
 887     case UNOP_DYNAMIC_CAST:
 888     case UNOP_REINTERPRET_CAST:
 889     case UNOP_MEMVAL:
 890       oplen = 3;
 891       args = 1;
 892       break;
 893
 894     case UNOP_MEMVAL_TLS:
 895       oplen = 4;
 896       args = 1;
 897       break;
 898
 899     case UNOP_ABS:
 900     case UNOP_CAP:
 901     case UNOP_CHR:
 902     case UNOP_FLOAT:
 903     case UNOP_HIGH:
 904     case UNOP_ODD:
 905     case UNOP_ORD:
 906     case UNOP_TRUNC:
 907       oplen = 1;
 908       args = 1;
 909       break;
 910
 911     case OP_ADL_FUNC:
 912       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 913       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 914       oplen++;
 915       oplen++;
 916       break;
 917
 918     case OP_LABELED:
 919     case STRUCTOP_STRUCT:
 920     case STRUCTOP_PTR:
 921       args = 1;
 922       /* fall through */
 923     case OP_REGISTER:
 924     case OP_M2_STRING:
 925     case OP_STRING:
 926     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class
 927                                    NSString constant.  */
 928     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op.  */
 929     case OP_NAME:
 930       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 931       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 932       break;
 933
 934     case OP_BITSTRING:
 935       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 936       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 937       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 938       break;
 939
 940     case OP_ARRAY:
 941       oplen = 4;
 942       args = longest_to_int (expr->elts[endpos - 2].longconst);
 943       args -= longest_to_int (expr->elts[endpos - 3].longconst);
 944       args += 1;
 945       break;
 946
 947     case TERNOP_COND:
 948     case TERNOP_SLICE:
 949     case TERNOP_SLICE_COUNT:
 950       args = 3;
 951       break;
 952
 953       /* Modula-2 */
 954     case MULTI_SUBSCRIPT:
 955       oplen = 3;
 956       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 957       break;
 958
 959     case BINOP_ASSIGN_MODIFY:
 960       oplen = 3;
 961       args = 2;
 962       break;
 963
 964       /* C++ */
 965     case OP_THIS:
 966       oplen = 2;
 967       break;
 968
 969     case OP_F90_RANGE:
 970       oplen = 3;
 971
 972       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
 973       switch (range_type)
 974         {
 975         case LOW_BOUND_DEFAULT:
 976         case HIGH_BOUND_DEFAULT:
 977           args = 1;
 978           break;
 979         case BOTH_BOUND_DEFAULT:
 980           args = 0;
 981           break;
 982         case NONE_BOUND_DEFAULT:
 983           args = 2;
 984           break;
 985         }
 986
 987       break;
 988
 989     default:
 990       args = 1 + (i < (int) BINOP_END);
 991     }
 992
 993   *oplenp = oplen;
 994   *argsp = args;
 995 }
 996
 997 /* Copy the subexpression ending just before index INEND in INEXPR
 998    into OUTEXPR, starting at index OUTBEG.
 999    In the process, convert it from suffix to prefix form.
1000    If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
1001    Otherwise, it returns the index of the subexpression which is the
1002    left-hand-side of the expression at EXPOUT_LAST_STRUCT.  */
1003
1004 static int
1005 prefixify_subexp (struct expression *inexpr,
1006                   struct expression *outexpr, int inend, int outbeg)
1007 {
1008   int oplen;
1009   int args;
1010   int i;
1011   int *arglens;
1012   int result = -1;
1013
1014   operator_length (inexpr, inend, &oplen, &args);
1015
1016   /* Copy the final operator itself, from the end of the input
1017      to the beginning of the output.  */
1018   inend -= oplen;
1019   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1020           EXP_ELEM_TO_BYTES (oplen));
1021   outbeg += oplen;
1022
1023   if (expout_last_struct == inend)
1024     result = outbeg - oplen;
1025
1026   /* Find the lengths of the arg subexpressions.  */
1027   arglens = (int *) alloca (args * sizeof (int));
1028   for (i = args - 1; i >= 0; i--)
1029     {
1030       oplen = length_of_subexp (inexpr, inend);
1031       arglens[i] = oplen;
1032       inend -= oplen;
1033     }
1034
1035   /* Now copy each subexpression, preserving the order of
1036      the subexpressions, but prefixifying each one.
1037      In this loop, inend starts at the beginning of
1038      the expression this level is working on
1039      and marches forward over the arguments.
1040      outbeg does similarly in the output.  */
1041   for (i = 0; i < args; i++)
1042     {
1043       int r;
1044
1045       oplen = arglens[i];
1046       inend += oplen;
1047       r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
1048       if (r != -1)
1049         {
1050           /* Return immediately.  We probably have only parsed a
1051              partial expression, so we don't want to try to reverse
1052              the other operands.  */
1053           return r;
1054         }
1055       outbeg += oplen;
1056     }
1057
1058   return result;
1059 }
1060 \f
1061 /* Read an expression from the string *STRINGPTR points to,
1062    parse it, and return a pointer to a struct expression that we malloc.
1063    Use block BLOCK as the lexical context for variable names;
1064    if BLOCK is zero, use the block of the selected stack frame.
1065    Meanwhile, advance *STRINGPTR to point after the expression,
1066    at the first nonwhite character that is not part of the expression
1067    (possibly a null character).
1068
1069    If COMMA is nonzero, stop if a comma is reached.  */
1070
1071 struct expression *
1072 parse_exp_1 (char **stringptr, struct block *block, int comma)
1073 {
1074   return parse_exp_in_context (stringptr, block, comma, 0, NULL);
1075 }
1076
1077 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1078    no value is expected from the expression.
1079    OUT_SUBEXP is set when attempting to complete a field name; in this
1080    case it is set to the index of the subexpression on the
1081    left-hand-side of the struct op.  If not doing such completion, it
1082    is left untouched.  */
1083
1084 static struct expression *
1085 parse_exp_in_context (char **stringptr, struct block *block, int comma,
1086                       int void_context_p, int *out_subexp)
1087 {
1088   volatile struct gdb_exception except;
1089   struct cleanup *old_chain;
1090   const struct language_defn *lang = NULL;
1091   int subexp;
1092
1093   lexptr = *stringptr;
1094   prev_lexptr = NULL;
1095
1096   paren_depth = 0;
1097   type_stack_depth = 0;
1098   expout_last_struct = -1;
1099
1100   comma_terminates = comma;
1101
1102   if (lexptr == 0 || *lexptr == 0)
1103     error_no_arg (_("expression to compute"));
1104
1105   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1106   funcall_chain = 0;
1107
1108   expression_context_block = block;
1109
1110   /* If no context specified, try using the current frame, if any.  */
1111   if (!expression_context_block)
1112     expression_context_block = get_selected_block (&expression_context_pc);
1113   else
1114     expression_context_pc = BLOCK_START (expression_context_block);
1115
1116   /* Fall back to using the current source static context, if any.  */
1117
1118   if (!expression_context_block)
1119     {
1120       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1121       if (cursal.symtab)
1122         expression_context_block
1123           = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1124       if (expression_context_block)
1125         expression_context_pc = BLOCK_START (expression_context_block);
1126     }
1127
1128   if (language_mode == language_mode_auto && block != NULL)
1129     {
1130       /* Find the language associated to the given context block.
1131          Default to the current language if it can not be determined.
1132
1133          Note that using the language corresponding to the current frame
1134          can sometimes give unexpected results.  For instance, this
1135          routine is often called several times during the inferior
1136          startup phase to re-parse breakpoint expressions after
1137          a new shared library has been loaded.  The language associated
1138          to the current frame at this moment is not relevant for
1139          the breakpoint.  Using it would therefore be silly, so it seems
1140          better to rely on the current language rather than relying on
1141          the current frame language to parse the expression.  That's why
1142          we do the following language detection only if the context block
1143          has been specifically provided.  */
1144       struct symbol *func = block_linkage_function (block);
1145
1146       if (func != NULL)
1147         lang = language_def (SYMBOL_LANGUAGE (func));
1148       if (lang == NULL || lang->la_language == language_unknown)
1149         lang = current_language;
1150     }
1151   else
1152     lang = current_language;
1153
1154   expout_size = 10;
1155   expout_ptr = 0;
1156   expout = (struct expression *)
1157     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1158   expout->language_defn = lang;
1159   expout->gdbarch = get_current_arch ();
1160
1161   TRY_CATCH (except, RETURN_MASK_ALL)
1162     {
1163       if (lang->la_parser ())
1164         lang->la_error (NULL);
1165     }
1166   if (except.reason < 0)
1167     {
1168       if (! in_parse_field)
1169         {
1170           xfree (expout);
1171           throw_exception (except);
1172         }
1173     }
1174
1175   discard_cleanups (old_chain);
1176
1177   /* Record the actual number of expression elements, and then
1178      reallocate the expression memory so that we free up any
1179      excess elements.  */
1180
1181   expout->nelts = expout_ptr;
1182   expout = (struct expression *)
1183     xrealloc ((char *) expout,
1184               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));
1185
1186   /* Convert expression from postfix form as generated by yacc
1187      parser, to a prefix form.  */
1188
1189   if (expressiondebug)
1190     dump_raw_expression (expout, gdb_stdlog,
1191                          "before conversion to prefix form");
1192
1193   subexp = prefixify_expression (expout);
1194   if (out_subexp)
1195     *out_subexp = subexp;
1196
1197   lang->la_post_parser (&expout, void_context_p);
1198
1199   if (expressiondebug)
1200     dump_prefix_expression (expout, gdb_stdlog);
1201
1202   *stringptr = lexptr;
1203   return expout;
1204 }
1205
1206 /* Parse STRING as an expression, and complain if this fails
1207    to use up all of the contents of STRING.  */
1208
1209 struct expression *
1210 parse_expression (char *string)
1211 {
1212   struct expression *exp;
1213
1214   exp = parse_exp_1 (&string, 0, 0);
1215   if (*string)
1216     error (_("Junk after end of expression."));
1217   return exp;
1218 }
1219
1220 /* Parse STRING as an expression.  If parsing ends in the middle of a
1221    field reference, return the type of the left-hand-side of the
1222    reference; furthermore, if the parsing ends in the field name,
1223    return the field name in *NAME.  If the parsing ends in the middle
1224    of a field reference, but the reference is somehow invalid, throw
1225    an exception.  In all other cases, return NULL.  Returned non-NULL
1226    *NAME must be freed by the caller.  */
1227
1228 struct type *
1229 parse_field_expression (char *string, char **name)
1230 {
1231   struct expression *exp = NULL;
1232   struct value *val;
1233   int subexp;
1234   volatile struct gdb_exception except;
1235
1236   TRY_CATCH (except, RETURN_MASK_ERROR)
1237     {
1238       in_parse_field = 1;
1239       exp = parse_exp_in_context (&string, 0, 0, 0, &subexp);
1240     }
1241   in_parse_field = 0;
1242   if (except.reason < 0 || ! exp)
1243     return NULL;
1244   if (expout_last_struct == -1)
1245     {
1246       xfree (exp);
1247       return NULL;
1248     }
1249
1250   *name = extract_field_op (exp, &subexp);
1251   if (!*name)
1252     {
1253       xfree (exp);
1254       return NULL;
1255     }
1256
1257   /* This might throw an exception.  If so, we want to let it
1258      propagate.  */
1259   val = evaluate_subexpression_type (exp, subexp);
1260   /* (*NAME) is a part of the EXP memory block freed below.  */
1261   *name = xstrdup (*name);
1262   xfree (exp);
1263
1264   return value_type (val);
1265 }
1266
1267 /* A post-parser that does nothing.  */
1268
1269 void
1270 null_post_parser (struct expression **exp, int void_context_p)
1271 {
1272 }
1273
1274 /* Parse floating point value P of length LEN.
1275    Return 0 (false) if invalid, 1 (true) if valid.
1276    The successfully parsed number is stored in D.
1277    *SUFFIX points to the suffix of the number in P.
1278
1279    NOTE: This accepts the floating point syntax that sscanf accepts.  */
1280
1281 int
1282 parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
1283 {
1284   char *copy;
1285   char *s;
1286   int n, num;
1287
1288   copy = xmalloc (len + 1);
1289   memcpy (copy, p, len);
1290   copy[len] = 0;
1291
1292   num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n);
1293   xfree (copy);
1294
1295   /* The sscanf man page suggests not making any assumptions on the effect
1296      of %n on the result, so we don't.
1297      That is why we simply test num == 0.  */
1298   if (num == 0)
1299     return 0;
1300
1301   *suffix = p + n;
1302   return 1;
1303 }
1304
1305 /* Parse floating point value P of length LEN, using the C syntax for floats.
1306    Return 0 (false) if invalid, 1 (true) if valid.
1307    The successfully parsed number is stored in *D.
1308    Its type is taken from builtin_type (gdbarch) and is stored in *T.  */
1309
1310 int
1311 parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
1312                DOUBLEST *d, struct type **t)
1313 {
1314   const char *suffix;
1315   int suffix_len;
1316   const struct builtin_type *builtin_types = builtin_type (gdbarch);
1317
1318   if (! parse_float (p, len, d, &suffix))
1319     return 0;
1320
1321   suffix_len = p + len - suffix;
1322
1323   if (suffix_len == 0)
1324     *t = builtin_types->builtin_double;
1325   else if (suffix_len == 1)
1326     {
1327       /* Handle suffixes: 'f' for float, 'l' for long double.  */
1328       if (tolower (*suffix) == 'f')
1329         *t = builtin_types->builtin_float;
1330       else if (tolower (*suffix) == 'l')
1331         *t = builtin_types->builtin_long_double;
1332       else
1333         return 0;
1334     }
1335   else
1336     return 0;
1337
1338   return 1;
1339 }
1340 \f
1341 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1342    probably useful for any language which declares its types "backwards".  */
1343
1344 static void
1345 check_type_stack_depth (void)
1346 {
1347   if (type_stack_depth == type_stack_size)
1348     {
1349       type_stack_size *= 2;
1350       type_stack = (union type_stack_elt *)
1351         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1352     }
1353 }
1354
1355 void
1356 push_type (enum type_pieces tp)
1357 {
1358   check_type_stack_depth ();
1359   type_stack[type_stack_depth++].piece = tp;
1360 }
1361
1362 void
1363 push_type_int (int n)
1364 {
1365   check_type_stack_depth ();
1366   type_stack[type_stack_depth++].int_val = n;
1367 }
1368
1369 void
1370 push_type_address_space (char *string)
1371 {
1372   push_type_int (address_space_name_to_int (parse_gdbarch, string));
1373 }
1374
1375 enum type_pieces
1376 pop_type (void)
1377 {
1378   if (type_stack_depth)
1379     return type_stack[--type_stack_depth].piece;
1380   return tp_end;
1381 }
1382
1383 int
1384 pop_type_int (void)
1385 {
1386   if (type_stack_depth)
1387     return type_stack[--type_stack_depth].int_val;
1388   /* "Can't happen".  */
1389   return 0;
1390 }
1391
1392 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1393    as modified by all the stuff on the stack.  */
1394 struct type *
1395 follow_types (struct type *follow_type)
1396 {
1397   int done = 0;
1398   int make_const = 0;
1399   int make_volatile = 0;
1400   int make_addr_space = 0;
1401   int array_size;
1402
1403   while (!done)
1404     switch (pop_type ())
1405       {
1406       case tp_end:
1407         done = 1;
1408         if (make_const)
1409           follow_type = make_cv_type (make_const,
1410                                       TYPE_VOLATILE (follow_type),
1411                                       follow_type, 0);
1412         if (make_volatile)
1413           follow_type = make_cv_type (TYPE_CONST (follow_type),
1414                                       make_volatile,
1415                                       follow_type, 0);
1416         if (make_addr_space)
1417           follow_type = make_type_with_address_space (follow_type,
1418                                                       make_addr_space);
1419         make_const = make_volatile = 0;
1420         make_addr_space = 0;
1421         break;
1422       case tp_const:
1423         make_const = 1;
1424         break;
1425       case tp_volatile:
1426         make_volatile = 1;
1427         break;
1428       case tp_space_identifier:
1429         make_addr_space = pop_type_int ();
1430         break;
1431       case tp_pointer:
1432         follow_type = lookup_pointer_type (follow_type);
1433         if (make_const)
1434           follow_type = make_cv_type (make_const,
1435                                       TYPE_VOLATILE (follow_type),
1436                                       follow_type, 0);
1437         if (make_volatile)
1438           follow_type = make_cv_type (TYPE_CONST (follow_type),
1439                                       make_volatile,
1440                                       follow_type, 0);
1441         if (make_addr_space)
1442           follow_type = make_type_with_address_space (follow_type,
1443                                                       make_addr_space);
1444         make_const = make_volatile = 0;
1445         make_addr_space = 0;
1446         break;
1447       case tp_reference:
1448         follow_type = lookup_reference_type (follow_type);
1449         if (make_const)
1450           follow_type = make_cv_type (make_const,
1451                                       TYPE_VOLATILE (follow_type),
1452                                       follow_type, 0);
1453         if (make_volatile)
1454           follow_type = make_cv_type (TYPE_CONST (follow_type),
1455                                       make_volatile,
1456                                       follow_type, 0);
1457         if (make_addr_space)
1458           follow_type = make_type_with_address_space (follow_type,
1459                                                       make_addr_space);
1460         make_const = make_volatile = 0;
1461         make_addr_space = 0;
1462         break;
1463       case tp_array:
1464         array_size = pop_type_int ();
1465         /* FIXME-type-allocation: need a way to free this type when we are
1466            done with it.  */
1467         follow_type =
1468           lookup_array_range_type (follow_type,
1469                                    0, array_size >= 0 ? array_size - 1 : 0);
1470         if (array_size < 0)
1471           TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type) = 1;
1472         break;
1473       case tp_function:
1474         /* FIXME-type-allocation: need a way to free this type when we are
1475            done with it.  */
1476         follow_type = lookup_function_type (follow_type);
1477         break;
1478       }
1479   return follow_type;
1480 }
1481 \f
1482 /* This function avoids direct calls to fprintf
1483    in the parser generated debug code.  */
1484 void
1485 parser_fprintf (FILE *x, const char *y, ...)
1486 {
1487   va_list args;
1488
1489   va_start (args, y);
1490   if (x == stderr)
1491     vfprintf_unfiltered (gdb_stderr, y, args);
1492   else
1493     {
1494       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1495       vfprintf_unfiltered (gdb_stderr, y, args);
1496     }
1497   va_end (args);
1498 }
1499
1500 /* Implementation of the exp_descriptor method operator_check.  */
1501
1502 int
1503 operator_check_standard (struct expression *exp, int pos,
1504                          int (*objfile_func) (struct objfile *objfile,
1505                                               void *data),
1506                          void *data)
1507 {
1508   const union exp_element *const elts = exp->elts;
1509   struct type *type = NULL;
1510   struct objfile *objfile = NULL;
1511
1512   /* Extended operators should have been already handled by exp_descriptor
1513      iterate method of its specific language.  */
1514   gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1515
1516   /* Track the callers of write_exp_elt_type for this table.  */
1517
1518   switch (elts[pos].opcode)
1519     {
1520     case BINOP_VAL:
1521     case OP_COMPLEX:
1522     case OP_DECFLOAT:
1523     case OP_DOUBLE:
1524     case OP_LONG:
1525     case OP_SCOPE:
1526     case OP_TYPE:
1527     case UNOP_CAST:
1528     case UNOP_DYNAMIC_CAST:
1529     case UNOP_REINTERPRET_CAST:
1530     case UNOP_MAX:
1531     case UNOP_MEMVAL:
1532     case UNOP_MIN:
1533       type = elts[pos + 1].type;
1534       break;
1535
1536     case TYPE_INSTANCE:
1537       {
1538         LONGEST arg, nargs = elts[pos + 1].longconst;
1539
1540         for (arg = 0; arg < nargs; arg++)
1541           {
1542             struct type *type = elts[pos + 2 + arg].type;
1543             struct objfile *objfile = TYPE_OBJFILE (type);
1544
1545             if (objfile && (*objfile_func) (objfile, data))
1546               return 1;
1547           }
1548       }
1549       break;
1550
1551     case UNOP_MEMVAL_TLS:
1552       objfile = elts[pos + 1].objfile;
1553       type = elts[pos + 2].type;
1554       break;
1555
1556     case OP_VAR_VALUE:
1557       {
1558         const struct block *const block = elts[pos + 1].block;
1559         const struct symbol *const symbol = elts[pos + 2].symbol;
1560
1561         /* Check objfile where the variable itself is placed.
1562            SYMBOL_OBJ_SECTION (symbol) may be NULL.  */
1563         if ((*objfile_func) (SYMBOL_SYMTAB (symbol)->objfile, data))
1564           return 1;
1565
1566         /* Check objfile where is placed the code touching the variable.  */
1567         objfile = lookup_objfile_from_block (block);
1568
1569         type = SYMBOL_TYPE (symbol);
1570       }
1571       break;
1572     }
1573
1574   /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL.  */
1575
1576   if (type && TYPE_OBJFILE (type)
1577       && (*objfile_func) (TYPE_OBJFILE (type), data))
1578     return 1;
1579   if (objfile && (*objfile_func) (objfile, data))
1580     return 1;
1581
1582   return 0;
1583 }
1584
1585 /* Call OBJFILE_FUNC for any TYPE and OBJFILE found being referenced by EXP.
1586    The functions are never called with NULL OBJFILE.  Functions get passed an
1587    arbitrary caller supplied DATA pointer.  If any of the functions returns
1588    non-zero value then (any other) non-zero value is immediately returned to
1589    the caller.  Otherwise zero is returned after iterating through whole EXP.
1590    */
1591
1592 static int
1593 exp_iterate (struct expression *exp,
1594              int (*objfile_func) (struct objfile *objfile, void *data),
1595              void *data)
1596 {
1597   int endpos;
1598
1599   for (endpos = exp->nelts; endpos > 0; )
1600     {
1601       int pos, args, oplen = 0;
1602
1603       operator_length (exp, endpos, &oplen, &args);
1604       gdb_assert (oplen > 0);
1605
1606       pos = endpos - oplen;
1607       if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1608                                                            objfile_func, data))
1609         return 1;
1610
1611       endpos = pos;
1612     }
1613
1614   return 0;
1615 }
1616
1617 /* Helper for exp_uses_objfile.  */
1618
1619 static int
1620 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1621 {
1622   struct objfile *objfile = objfile_voidp;
1623
1624   if (exp_objfile->separate_debug_objfile_backlink)
1625     exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1626
1627   return exp_objfile == objfile;
1628 }
1629
1630 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1631    is unloaded), otherwise return 0.  OBJFILE must not be a separate debug info
1632    file.  */
1633
1634 int
1635 exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1636 {
1637   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1638
1639   return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1640 }
1641
1642 void
1643 _initialize_parse (void)
1644 {
1645   type_stack_size = 80;
1646   type_stack_depth = 0;
1647   type_stack = (union type_stack_elt *)
1648     xmalloc (type_stack_size * sizeof (*type_stack));
1649
1650   add_setshow_zinteger_cmd ("expression", class_maintenance,
1651                             &expressiondebug,
1652                             _("Set expression debugging."),
1653                             _("Show expression debugging."),
1654                             _("When non-zero, the internal representation "
1655                               "of expressions will be printed."),
1656                             NULL,
1657                             show_expressiondebug,
1658                             &setdebuglist, &showdebuglist);
1659   add_setshow_boolean_cmd ("parser", class_maintenance,
1660                             &parser_debug,
1661                            _("Set parser debugging."),
1662                            _("Show parser debugging."),
1663                            _("When non-zero, expression parser "
1664                              "tracing will be enabled."),
1665                             NULL,
1666                             show_parserdebug,
1667                             &setdebuglist, &showdebuglist);
1668 }