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