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