gdb/parse.c

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