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