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