gdb/parse.c

   1 /* Parse expressions for GDB.
   2
   3    Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2004, 2005, 2007, 2008, 2009, 2010
   5    Free Software Foundation, Inc.
   6
   7    Modified from expread.y by the Department of Computer Science at the
   8    State University of New York at Buffalo, 1991.
   9
  10    This file is part of GDB.
  11
  12    This program is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 3 of the License, or
  15    (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  24
  25 /* Parse an expression from text in a string,
  26    and return the result as a  struct expression  pointer.
  27    That structure contains arithmetic operations in reverse polish,
  28    with constants represented by operations that are followed by special data.
  29    See expression.h for the details of the format.
  30    What is important here is that it can be built up sequentially
  31    during the process of parsing; the lower levels of the tree always
  32    come first in the result.  */
  33
  34 #include "defs.h"
  35 #include <ctype.h>
  36 #include "arch-utils.h"
  37 #include "gdb_string.h"
  38 #include "symtab.h"
  39 #include "gdbtypes.h"
  40 #include "frame.h"
  41 #include "expression.h"
  42 #include "value.h"
  43 #include "command.h"
  44 #include "language.h"
  45 #include "f-lang.h"
  46 #include "parser-defs.h"
  47 #include "gdbcmd.h"
  48 #include "symfile.h"            /* for overlay functions */
  49 #include "inferior.h"
  50 #include "doublest.h"
  51 #include "gdb_assert.h"
  52 #include "block.h"
  53 #include "source.h"
  54 #include "objfiles.h"
  55 #include "exceptions.h"
  56 #include "user-regs.h"
  57
  58 /* Standard set of definitions for printing, dumping, prefixifying,
  59  * and evaluating expressions.  */
  60
  61 const struct exp_descriptor exp_descriptor_standard =
  62   {
  63     print_subexp_standard,
  64     operator_length_standard,
  65     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
  94 /* A temporary buffer for identifiers, so we can null-terminate them.
  95
  96    We allocate this with xrealloc.  parse_exp_1 used to allocate with
  97    alloca, using the size of the whole expression as a conservative
  98    estimate of the space needed.  However, macro expansion can
  99    introduce names longer than the original expression; there's no
 100    practical way to know beforehand how large that might be.  */
 101 char *namecopy;
 102 size_t namecopy_size;
 103 \f
 104 static int expressiondebug = 0;
 105 static void
 106 show_expressiondebug (struct ui_file *file, int from_tty,
 107                       struct cmd_list_element *c, const char *value)
 108 {
 109   fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
 110 }
 111
 112 static void free_funcalls (void *ignore);
 113
 114 static int prefixify_expression (struct expression *);
 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   funcall_chain = call->next;
 159   arglist_len = call->arglist_len;
 160   xfree (call);
 161   return val;
 162 }
 163
 164 /* Free everything in the funcall chain.
 165    Used when there is an error inside parsing.  */
 166
 167 static void
 168 free_funcalls (void *ignore)
 169 {
 170   struct funcall *call, *next;
 171
 172   for (call = funcall_chain; call; call = next)
 173     {
 174       next = call->next;
 175       xfree (call);
 176     }
 177 }
 178 \f
 179 /* This page contains the functions for adding data to the  struct expression
 180    being constructed.  */
 181
 182 /* Add one element to the end of the expression.  */
 183
 184 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
 185    a register through here */
 186
 187 void
 188 write_exp_elt (union exp_element expelt)
 189 {
 190   if (expout_ptr >= expout_size)
 191     {
 192       expout_size *= 2;
 193       expout = (struct expression *)
 194         xrealloc ((char *) expout, sizeof (struct expression)
 195                   + EXP_ELEM_TO_BYTES (expout_size));
 196     }
 197   expout->elts[expout_ptr++] = expelt;
 198 }
 199
 200 void
 201 write_exp_elt_opcode (enum exp_opcode expelt)
 202 {
 203   union exp_element tmp;
 204   memset (&tmp, 0, sizeof (union exp_element));
 205
 206   tmp.opcode = expelt;
 207
 208   write_exp_elt (tmp);
 209 }
 210
 211 void
 212 write_exp_elt_sym (struct symbol *expelt)
 213 {
 214   union exp_element tmp;
 215   memset (&tmp, 0, sizeof (union exp_element));
 216
 217   tmp.symbol = expelt;
 218
 219   write_exp_elt (tmp);
 220 }
 221
 222 void
 223 write_exp_elt_block (struct block *b)
 224 {
 225   union exp_element tmp;
 226   memset (&tmp, 0, sizeof (union exp_element));
 227   tmp.block = b;
 228   write_exp_elt (tmp);
 229 }
 230
 231 void
 232 write_exp_elt_objfile (struct objfile *objfile)
 233 {
 234   union exp_element tmp;
 235   memset (&tmp, 0, sizeof (union exp_element));
 236   tmp.objfile = objfile;
 237   write_exp_elt (tmp);
 238 }
 239
 240 void
 241 write_exp_elt_longcst (LONGEST expelt)
 242 {
 243   union exp_element tmp;
 244   memset (&tmp, 0, sizeof (union exp_element));
 245
 246   tmp.longconst = expelt;
 247
 248   write_exp_elt (tmp);
 249 }
 250
 251 void
 252 write_exp_elt_dblcst (DOUBLEST expelt)
 253 {
 254   union exp_element tmp;
 255   memset (&tmp, 0, sizeof (union exp_element));
 256
 257   tmp.doubleconst = expelt;
 258
 259   write_exp_elt (tmp);
 260 }
 261
 262 void
 263 write_exp_elt_decfloatcst (gdb_byte expelt[16])
 264 {
 265   union exp_element tmp;
 266   int index;
 267
 268   for (index = 0; index < 16; index++)
 269     tmp.decfloatconst[index] = expelt[index];
 270
 271   write_exp_elt (tmp);
 272 }
 273
 274 void
 275 write_exp_elt_type (struct type *expelt)
 276 {
 277   union exp_element tmp;
 278   memset (&tmp, 0, sizeof (union exp_element));
 279
 280   tmp.type = expelt;
 281
 282   write_exp_elt (tmp);
 283 }
 284
 285 void
 286 write_exp_elt_intern (struct internalvar *expelt)
 287 {
 288   union exp_element tmp;
 289   memset (&tmp, 0, sizeof (union exp_element));
 290
 291   tmp.internalvar = expelt;
 292
 293   write_exp_elt (tmp);
 294 }
 295
 296 /* Add a string constant to the end of the expression.
 297
 298    String constants are stored by first writing an expression element
 299    that contains the length of the string, then stuffing the string
 300    constant itself into however many expression elements are needed
 301    to hold it, and then writing another expression element that contains
 302    the length of the string.  I.E. an expression element at each end of
 303    the string records the string length, so you can skip over the
 304    expression elements containing the actual string bytes from either
 305    end of the string.  Note that this also allows gdb to handle
 306    strings with embedded null bytes, as is required for some languages.
 307
 308    Don't be fooled by the fact that the string is null byte terminated,
 309    this is strictly for the convenience of debugging gdb itself.
 310    Gdb does not depend up the string being null terminated, since the
 311    actual length is recorded in expression elements at each end of the
 312    string.  The null byte is taken into consideration when computing how
 313    many expression elements are required to hold the string constant, of
 314    course. */
 315
 316
 317 void
 318 write_exp_string (struct stoken str)
 319 {
 320   int len = str.length;
 321   int lenelt;
 322   char *strdata;
 323
 324   /* Compute the number of expression elements required to hold the string
 325      (including a null byte terminator), along with one expression element
 326      at each end to record the actual string length (not including the
 327      null byte terminator). */
 328
 329   lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
 330
 331   /* Ensure that we have enough available expression elements to store
 332      everything. */
 333
 334   if ((expout_ptr + lenelt) >= expout_size)
 335     {
 336       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 337       expout = (struct expression *)
 338         xrealloc ((char *) expout, (sizeof (struct expression)
 339                                     + EXP_ELEM_TO_BYTES (expout_size)));
 340     }
 341
 342   /* Write the leading length expression element (which advances the current
 343      expression element index), then write the string constant followed by a
 344      terminating null byte, and then write the trailing length expression
 345      element. */
 346
 347   write_exp_elt_longcst ((LONGEST) len);
 348   strdata = (char *) &expout->elts[expout_ptr];
 349   memcpy (strdata, str.ptr, len);
 350   *(strdata + len) = '\0';
 351   expout_ptr += lenelt - 2;
 352   write_exp_elt_longcst ((LONGEST) len);
 353 }
 354
 355 /* Add a vector of string constants to the end of the expression.
 356
 357    This adds an OP_STRING operation, but encodes the contents
 358    differently from write_exp_string.  The language is expected to
 359    handle evaluation of this expression itself.
 360
 361    After the usual OP_STRING header, TYPE is written into the
 362    expression as a long constant.  The interpretation of this field is
 363    up to the language evaluator.
 364
 365    Next, each string in VEC is written.  The length is written as a
 366    long constant, followed by the contents of the string.  */
 367
 368 void
 369 write_exp_string_vector (int type, struct stoken_vector *vec)
 370 {
 371   int i, n_slots, len;
 372
 373   /* Compute the size.  We compute the size in number of slots to
 374      avoid issues with string padding.  */
 375   n_slots = 0;
 376   for (i = 0; i < vec->len; ++i)
 377     {
 378       /* One slot for the length of this element, plus the number of
 379          slots needed for this string.  */
 380       n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length);
 381     }
 382
 383   /* One more slot for the type of the string.  */
 384   ++n_slots;
 385
 386   /* Now compute a phony string length.  */
 387   len = EXP_ELEM_TO_BYTES (n_slots) - 1;
 388
 389   n_slots += 4;
 390   if ((expout_ptr + n_slots) >= expout_size)
 391     {
 392       expout_size = max (expout_size * 2, expout_ptr + n_slots + 10);
 393       expout = (struct expression *)
 394         xrealloc ((char *) expout, (sizeof (struct expression)
 395                                     + EXP_ELEM_TO_BYTES (expout_size)));
 396     }
 397
 398   write_exp_elt_opcode (OP_STRING);
 399   write_exp_elt_longcst (len);
 400   write_exp_elt_longcst (type);
 401
 402   for (i = 0; i < vec->len; ++i)
 403     {
 404       write_exp_elt_longcst (vec->tokens[i].length);
 405       memcpy (&expout->elts[expout_ptr], vec->tokens[i].ptr,
 406               vec->tokens[i].length);
 407       expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length);
 408     }
 409
 410   write_exp_elt_longcst (len);
 411   write_exp_elt_opcode (OP_STRING);
 412 }
 413
 414 /* Add a bitstring constant to the end of the expression.
 415
 416    Bitstring constants are stored by first writing an expression element
 417    that contains the length of the bitstring (in bits), then stuffing the
 418    bitstring constant itself into however many expression elements are
 419    needed to hold it, and then writing another expression element that
 420    contains the length of the bitstring.  I.E. an expression element at
 421    each end of the bitstring records the bitstring length, so you can skip
 422    over the expression elements containing the actual bitstring bytes from
 423    either end of the bitstring. */
 424
 425 void
 426 write_exp_bitstring (struct stoken str)
 427 {
 428   int bits = str.length;        /* length in bits */
 429   int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 430   int lenelt;
 431   char *strdata;
 432
 433   /* Compute the number of expression elements required to hold the bitstring,
 434      along with one expression element at each end to record the actual
 435      bitstring length in bits. */
 436
 437   lenelt = 2 + BYTES_TO_EXP_ELEM (len);
 438
 439   /* Ensure that we have enough available expression elements to store
 440      everything. */
 441
 442   if ((expout_ptr + lenelt) >= expout_size)
 443     {
 444       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 445       expout = (struct expression *)
 446         xrealloc ((char *) expout, (sizeof (struct expression)
 447                                     + EXP_ELEM_TO_BYTES (expout_size)));
 448     }
 449
 450   /* Write the leading length expression element (which advances the current
 451      expression element index), then write the bitstring constant, and then
 452      write the trailing length expression element. */
 453
 454   write_exp_elt_longcst ((LONGEST) bits);
 455   strdata = (char *) &expout->elts[expout_ptr];
 456   memcpy (strdata, str.ptr, len);
 457   expout_ptr += lenelt - 2;
 458   write_exp_elt_longcst ((LONGEST) bits);
 459 }
 460
 461 /* Add the appropriate elements for a minimal symbol to the end of
 462    the expression.  */
 463
 464 void
 465 write_exp_msymbol (struct minimal_symbol *msymbol)
 466 {
 467   struct objfile *objfile = msymbol_objfile (msymbol);
 468   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 469
 470   CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
 471   struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol);
 472   enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
 473   CORE_ADDR pc;
 474
 475   /* The minimal symbol might point to a function descriptor;
 476      resolve it to the actual code address instead.  */
 477   pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
 478   if (pc != addr)
 479     {
 480       /* In this case, assume we have a code symbol instead of
 481          a data symbol.  */
 482       type = mst_text;
 483       section = NULL;
 484       addr = pc;
 485     }
 486
 487   if (overlay_debugging)
 488     addr = symbol_overlayed_address (addr, section);
 489
 490   write_exp_elt_opcode (OP_LONG);
 491   /* Let's make the type big enough to hold a 64-bit address.  */
 492   write_exp_elt_type (objfile_type (objfile)->builtin_core_addr);
 493   write_exp_elt_longcst ((LONGEST) addr);
 494   write_exp_elt_opcode (OP_LONG);
 495
 496   if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
 497     {
 498       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 499       write_exp_elt_objfile (objfile);
 500       write_exp_elt_type (objfile_type (objfile)->nodebug_tls_symbol);
 501       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 502       return;
 503     }
 504
 505   write_exp_elt_opcode (UNOP_MEMVAL);
 506   switch (type)
 507     {
 508     case mst_text:
 509     case mst_file_text:
 510     case mst_solib_trampoline:
 511       write_exp_elt_type (objfile_type (objfile)->nodebug_text_symbol);
 512       break;
 513
 514     case mst_data:
 515     case mst_file_data:
 516     case mst_bss:
 517     case mst_file_bss:
 518       write_exp_elt_type (objfile_type (objfile)->nodebug_data_symbol);
 519       break;
 520
 521     default:
 522       write_exp_elt_type (objfile_type (objfile)->nodebug_unknown_symbol);
 523       break;
 524     }
 525   write_exp_elt_opcode (UNOP_MEMVAL);
 526 }
 527
 528 /* Mark the current index as the starting location of a structure
 529    expression.  This is used when completing on field names.  */
 530
 531 void
 532 mark_struct_expression (void)
 533 {
 534   expout_last_struct = expout_ptr;
 535 }
 536
 537 \f
 538 /* Recognize tokens that start with '$'.  These include:
 539
 540    $regname     A native register name or a "standard
 541    register name".
 542
 543    $variable    A convenience variable with a name chosen
 544    by the user.
 545
 546    $digits              Value history with index <digits>, starting
 547    from the first value which has index 1.
 548
 549    $$digits     Value history with index <digits> relative
 550    to the last value.  I.E. $$0 is the last
 551    value, $$1 is the one previous to that, $$2
 552    is the one previous to $$1, etc.
 553
 554    $ | $0 | $$0 The last value in the value history.
 555
 556    $$           An abbreviation for the second to the last
 557    value in the value history, I.E. $$1
 558
 559  */
 560
 561 void
 562 write_dollar_variable (struct stoken str)
 563 {
 564   struct symbol *sym = NULL;
 565   struct minimal_symbol *msym = NULL;
 566   struct internalvar *isym = NULL;
 567
 568   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
 569      and $$digits (equivalent to $<-digits> if you could type that). */
 570
 571   int negate = 0;
 572   int i = 1;
 573   /* Double dollar means negate the number and add -1 as well.
 574      Thus $$ alone means -1.  */
 575   if (str.length >= 2 && str.ptr[1] == '$')
 576     {
 577       negate = 1;
 578       i = 2;
 579     }
 580   if (i == str.length)
 581     {
 582       /* Just dollars (one or two) */
 583       i = -negate;
 584       goto handle_last;
 585     }
 586   /* Is the rest of the token digits?  */
 587   for (; i < str.length; i++)
 588     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
 589       break;
 590   if (i == str.length)
 591     {
 592       i = atoi (str.ptr + 1 + negate);
 593       if (negate)
 594         i = -i;
 595       goto handle_last;
 596     }
 597
 598   /* Handle tokens that refer to machine registers:
 599      $ followed by a register name.  */
 600   i = user_reg_map_name_to_regnum (parse_gdbarch,
 601                                    str.ptr + 1, str.length - 1);
 602   if (i >= 0)
 603     goto handle_register;
 604
 605   /* Any names starting with $ are probably debugger internal variables.  */
 606
 607   isym = lookup_only_internalvar (copy_name (str) + 1);
 608   if (isym)
 609     {
 610       write_exp_elt_opcode (OP_INTERNALVAR);
 611       write_exp_elt_intern (isym);
 612       write_exp_elt_opcode (OP_INTERNALVAR);
 613       return;
 614     }
 615
 616   /* On some systems, such as HP-UX and hppa-linux, certain system routines
 617      have names beginning with $ or $$.  Check for those, first. */
 618
 619   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
 620                        VAR_DOMAIN, (int *) NULL);
 621   if (sym)
 622     {
 623       write_exp_elt_opcode (OP_VAR_VALUE);
 624       write_exp_elt_block (block_found);        /* set by lookup_symbol */
 625       write_exp_elt_sym (sym);
 626       write_exp_elt_opcode (OP_VAR_VALUE);
 627       return;
 628     }
 629   msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
 630   if (msym)
 631     {
 632       write_exp_msymbol (msym);
 633       return;
 634     }
 635
 636   /* Any other names are assumed to be debugger internal variables.  */
 637
 638   write_exp_elt_opcode (OP_INTERNALVAR);
 639   write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
 640   write_exp_elt_opcode (OP_INTERNALVAR);
 641   return;
 642 handle_last:
 643   write_exp_elt_opcode (OP_LAST);
 644   write_exp_elt_longcst ((LONGEST) i);
 645   write_exp_elt_opcode (OP_LAST);
 646   return;
 647 handle_register:
 648   write_exp_elt_opcode (OP_REGISTER);
 649   str.length--;
 650   str.ptr++;
 651   write_exp_string (str);
 652   write_exp_elt_opcode (OP_REGISTER);
 653   return;
 654 }
 655
 656
 657 char *
 658 find_template_name_end (char *p)
 659 {
 660   int depth = 1;
 661   int just_seen_right = 0;
 662   int just_seen_colon = 0;
 663   int just_seen_space = 0;
 664
 665   if (!p || (*p != '<'))
 666     return 0;
 667
 668   while (*++p)
 669     {
 670       switch (*p)
 671         {
 672         case '\'':
 673         case '\"':
 674         case '{':
 675         case '}':
 676           /* In future, may want to allow these?? */
 677           return 0;
 678         case '<':
 679           depth++;              /* start nested template */
 680           if (just_seen_colon || just_seen_right || just_seen_space)
 681             return 0;           /* but not after : or :: or > or space */
 682           break;
 683         case '>':
 684           if (just_seen_colon || just_seen_right)
 685             return 0;           /* end a (nested?) template */
 686           just_seen_right = 1;  /* but not after : or :: */
 687           if (--depth == 0)     /* also disallow >>, insist on > > */
 688             return ++p;         /* if outermost ended, return */
 689           break;
 690         case ':':
 691           if (just_seen_space || (just_seen_colon > 1))
 692             return 0;           /* nested class spec coming up */
 693           just_seen_colon++;    /* we allow :: but not :::: */
 694           break;
 695         case ' ':
 696           break;
 697         default:
 698           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
 699                 (*p >= 'A' && *p <= 'Z') ||
 700                 (*p >= '0' && *p <= '9') ||
 701                 (*p == '_') || (*p == ',') ||   /* commas for template args */
 702                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
 703                 (*p == '(') || (*p == ')') ||   /* function types */
 704                 (*p == '[') || (*p == ']')))    /* array types */
 705             return 0;
 706         }
 707       if (*p != ' ')
 708         just_seen_space = 0;
 709       if (*p != ':')
 710         just_seen_colon = 0;
 711       if (*p != '>')
 712         just_seen_right = 0;
 713     }
 714   return 0;
 715 }
 716 \f
 717
 718
 719 /* Return a null-terminated temporary copy of the name
 720    of a string token.  */
 721
 722 char *
 723 copy_name (struct stoken token)
 724 {
 725   /* Make sure there's enough space for the token.  */
 726   if (namecopy_size < token.length + 1)
 727     {
 728       namecopy_size = token.length + 1;
 729       namecopy = xrealloc (namecopy, token.length + 1);
 730     }
 731
 732   memcpy (namecopy, token.ptr, token.length);
 733   namecopy[token.length] = 0;
 734
 735   return namecopy;
 736 }
 737 \f
 738 /* Reverse an expression from suffix form (in which it is constructed)
 739    to prefix form (in which we can conveniently print or execute it).
 740    Ordinarily this always returns -1.  However, if EXPOUT_LAST_STRUCT
 741    is not -1 (i.e., we are trying to complete a field name), it will
 742    return the index of the subexpression which is the left-hand-side
 743    of the struct operation at EXPOUT_LAST_STRUCT.  */
 744
 745 static int
 746 prefixify_expression (struct expression *expr)
 747 {
 748   int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
 749   struct expression *temp;
 750   int inpos = expr->nelts, outpos = 0;
 751
 752   temp = (struct expression *) alloca (len);
 753
 754   /* Copy the original expression into temp.  */
 755   memcpy (temp, expr, len);
 756
 757   return prefixify_subexp (temp, expr, inpos, outpos);
 758 }
 759
 760 /* Return the number of exp_elements in the postfix subexpression
 761    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
 762
 763 int
 764 length_of_subexp (struct expression *expr, int endpos)
 765 {
 766   int oplen, args, i;
 767
 768   operator_length (expr, endpos, &oplen, &args);
 769
 770   while (args > 0)
 771     {
 772       oplen += length_of_subexp (expr, endpos - oplen);
 773       args--;
 774     }
 775
 776   return oplen;
 777 }
 778
 779 /* Sets *OPLENP to the length of the operator whose (last) index is
 780    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
 781    operator takes.  */
 782
 783 void
 784 operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp)
 785 {
 786   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
 787                                                      oplenp, argsp);
 788 }
 789
 790 /* Default value for operator_length in exp_descriptor vectors.  */
 791
 792 void
 793 operator_length_standard (struct expression *expr, int endpos,
 794                           int *oplenp, int *argsp)
 795 {
 796   int oplen = 1;
 797   int args = 0;
 798   enum f90_range_type range_type;
 799   int i;
 800
 801   if (endpos < 1)
 802     error (_("?error in operator_length_standard"));
 803
 804   i = (int) expr->elts[endpos - 1].opcode;
 805
 806   switch (i)
 807     {
 808       /* C++  */
 809     case OP_SCOPE:
 810       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 811       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 812       break;
 813
 814     case OP_LONG:
 815     case OP_DOUBLE:
 816     case OP_DECFLOAT:
 817     case OP_VAR_VALUE:
 818       oplen = 4;
 819       break;
 820
 821     case OP_TYPE:
 822     case OP_BOOL:
 823     case OP_LAST:
 824     case OP_INTERNALVAR:
 825       oplen = 3;
 826       break;
 827
 828     case OP_COMPLEX:
 829       oplen = 3;
 830       args = 2;
 831       break;
 832
 833     case OP_FUNCALL:
 834     case OP_F77_UNDETERMINED_ARGLIST:
 835       oplen = 3;
 836       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 837       break;
 838
 839     case TYPE_INSTANCE:
 840       oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst);
 841       args = 1;
 842       break;
 843
 844     case OP_OBJC_MSGCALL:       /* Objective C message (method) call */
 845       oplen = 4;
 846       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 847       break;
 848
 849     case UNOP_MAX:
 850     case UNOP_MIN:
 851       oplen = 3;
 852       break;
 853
 854     case BINOP_VAL:
 855     case UNOP_CAST:
 856     case UNOP_DYNAMIC_CAST:
 857     case UNOP_REINTERPRET_CAST:
 858     case UNOP_MEMVAL:
 859       oplen = 3;
 860       args = 1;
 861       break;
 862
 863     case UNOP_MEMVAL_TLS:
 864       oplen = 4;
 865       args = 1;
 866       break;
 867
 868     case UNOP_ABS:
 869     case UNOP_CAP:
 870     case UNOP_CHR:
 871     case UNOP_FLOAT:
 872     case UNOP_HIGH:
 873     case UNOP_ODD:
 874     case UNOP_ORD:
 875     case UNOP_TRUNC:
 876       oplen = 1;
 877       args = 1;
 878       break;
 879
 880     case OP_LABELED:
 881     case STRUCTOP_STRUCT:
 882     case STRUCTOP_PTR:
 883       args = 1;
 884       /* fall through */
 885     case OP_REGISTER:
 886     case OP_M2_STRING:
 887     case OP_STRING:
 888     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class NSString constant */
 889     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op */
 890     case OP_NAME:
 891       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 892       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 893       break;
 894
 895     case OP_BITSTRING:
 896       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 897       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 898       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 899       break;
 900
 901     case OP_ARRAY:
 902       oplen = 4;
 903       args = longest_to_int (expr->elts[endpos - 2].longconst);
 904       args -= longest_to_int (expr->elts[endpos - 3].longconst);
 905       args += 1;
 906       break;
 907
 908     case TERNOP_COND:
 909     case TERNOP_SLICE:
 910     case TERNOP_SLICE_COUNT:
 911       args = 3;
 912       break;
 913
 914       /* Modula-2 */
 915     case MULTI_SUBSCRIPT:
 916       oplen = 3;
 917       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 918       break;
 919
 920     case BINOP_ASSIGN_MODIFY:
 921       oplen = 3;
 922       args = 2;
 923       break;
 924
 925       /* C++ */
 926     case OP_THIS:
 927     case OP_OBJC_SELF:
 928       oplen = 2;
 929       break;
 930
 931     case OP_F90_RANGE:
 932       oplen = 3;
 933
 934       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
 935       switch (range_type)
 936         {
 937         case LOW_BOUND_DEFAULT:
 938         case HIGH_BOUND_DEFAULT:
 939           args = 1;
 940           break;
 941         case BOTH_BOUND_DEFAULT:
 942           args = 0;
 943           break;
 944         case NONE_BOUND_DEFAULT:
 945           args = 2;
 946           break;
 947         }
 948
 949       break;
 950
 951     default:
 952       args = 1 + (i < (int) BINOP_END);
 953     }
 954
 955   *oplenp = oplen;
 956   *argsp = args;
 957 }
 958
 959 /* Copy the subexpression ending just before index INEND in INEXPR
 960    into OUTEXPR, starting at index OUTBEG.
 961    In the process, convert it from suffix to prefix form.
 962    If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
 963    Otherwise, it returns the index of the subexpression which is the
 964    left-hand-side of the expression at EXPOUT_LAST_STRUCT.  */
 965
 966 static int
 967 prefixify_subexp (struct expression *inexpr,
 968                   struct expression *outexpr, int inend, int outbeg)
 969 {
 970   int oplen;
 971   int args;
 972   int i;
 973   int *arglens;
 974   enum exp_opcode opcode;
 975   int result = -1;
 976
 977   operator_length (inexpr, inend, &oplen, &args);
 978
 979   /* Copy the final operator itself, from the end of the input
 980      to the beginning of the output.  */
 981   inend -= oplen;
 982   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
 983           EXP_ELEM_TO_BYTES (oplen));
 984   outbeg += oplen;
 985
 986   if (expout_last_struct == inend)
 987     result = outbeg - oplen;
 988
 989   /* Find the lengths of the arg subexpressions.  */
 990   arglens = (int *) alloca (args * sizeof (int));
 991   for (i = args - 1; i >= 0; i--)
 992     {
 993       oplen = length_of_subexp (inexpr, inend);
 994       arglens[i] = oplen;
 995       inend -= oplen;
 996     }
 997
 998   /* Now copy each subexpression, preserving the order of
 999      the subexpressions, but prefixifying each one.
1000      In this loop, inend starts at the beginning of
1001      the expression this level is working on
1002      and marches forward over the arguments.
1003      outbeg does similarly in the output.  */
1004   for (i = 0; i < args; i++)
1005     {
1006       int r;
1007       oplen = arglens[i];
1008       inend += oplen;
1009       r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
1010       if (r != -1)
1011         {
1012           /* Return immediately.  We probably have only parsed a
1013              partial expression, so we don't want to try to reverse
1014              the other operands.  */
1015           return r;
1016         }
1017       outbeg += oplen;
1018     }
1019
1020   return result;
1021 }
1022 \f
1023 /* This page contains the two entry points to this file.  */
1024
1025 /* Read an expression from the string *STRINGPTR points to,
1026    parse it, and return a pointer to a  struct expression  that we malloc.
1027    Use block BLOCK as the lexical context for variable names;
1028    if BLOCK is zero, use the block of the selected stack frame.
1029    Meanwhile, advance *STRINGPTR to point after the expression,
1030    at the first nonwhite character that is not part of the expression
1031    (possibly a null character).
1032
1033    If COMMA is nonzero, stop if a comma is reached.  */
1034
1035 struct expression *
1036 parse_exp_1 (char **stringptr, struct block *block, int comma)
1037 {
1038   return parse_exp_in_context (stringptr, block, comma, 0, NULL);
1039 }
1040
1041 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1042    no value is expected from the expression.
1043    OUT_SUBEXP is set when attempting to complete a field name; in this
1044    case it is set to the index of the subexpression on the
1045    left-hand-side of the struct op.  If not doing such completion, it
1046    is left untouched.  */
1047
1048 static struct expression *
1049 parse_exp_in_context (char **stringptr, struct block *block, int comma,
1050                       int void_context_p, int *out_subexp)
1051 {
1052   volatile struct gdb_exception except;
1053   struct cleanup *old_chain;
1054   int subexp;
1055
1056   lexptr = *stringptr;
1057   prev_lexptr = NULL;
1058
1059   paren_depth = 0;
1060   type_stack_depth = 0;
1061   expout_last_struct = -1;
1062
1063   comma_terminates = comma;
1064
1065   if (lexptr == 0 || *lexptr == 0)
1066     error_no_arg (_("expression to compute"));
1067
1068   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1069   funcall_chain = 0;
1070
1071   expression_context_block = block;
1072
1073   /* If no context specified, try using the current frame, if any.  */
1074   if (!expression_context_block)
1075     expression_context_block = get_selected_block (&expression_context_pc);
1076   else
1077     expression_context_pc = BLOCK_START (expression_context_block);
1078
1079   /* Fall back to using the current source static context, if any.  */
1080
1081   if (!expression_context_block)
1082     {
1083       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1084       if (cursal.symtab)
1085         expression_context_block
1086           = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1087       if (expression_context_block)
1088         expression_context_pc = BLOCK_START (expression_context_block);
1089     }
1090
1091   expout_size = 10;
1092   expout_ptr = 0;
1093   expout = (struct expression *)
1094     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1095   expout->language_defn = current_language;
1096   expout->gdbarch = get_current_arch ();
1097
1098   TRY_CATCH (except, RETURN_MASK_ALL)
1099     {
1100       if (current_language->la_parser ())
1101         current_language->la_error (NULL);
1102     }
1103   if (except.reason < 0)
1104     {
1105       if (! in_parse_field)
1106         {
1107           xfree (expout);
1108           throw_exception (except);
1109         }
1110     }
1111
1112   discard_cleanups (old_chain);
1113
1114   /* Record the actual number of expression elements, and then
1115      reallocate the expression memory so that we free up any
1116      excess elements. */
1117
1118   expout->nelts = expout_ptr;
1119   expout = (struct expression *)
1120     xrealloc ((char *) expout,
1121               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1122
1123   /* Convert expression from postfix form as generated by yacc
1124      parser, to a prefix form. */
1125
1126   if (expressiondebug)
1127     dump_raw_expression (expout, gdb_stdlog,
1128                          "before conversion to prefix form");
1129
1130   subexp = prefixify_expression (expout);
1131   if (out_subexp)
1132     *out_subexp = subexp;
1133
1134   current_language->la_post_parser (&expout, void_context_p);
1135
1136   if (expressiondebug)
1137     dump_prefix_expression (expout, gdb_stdlog);
1138
1139   *stringptr = lexptr;
1140   return expout;
1141 }
1142
1143 /* Parse STRING as an expression, and complain if this fails
1144    to use up all of the contents of STRING.  */
1145
1146 struct expression *
1147 parse_expression (char *string)
1148 {
1149   struct expression *exp;
1150   exp = parse_exp_1 (&string, 0, 0);
1151   if (*string)
1152     error (_("Junk after end of expression."));
1153   return exp;
1154 }
1155
1156 /* Parse STRING as an expression.  If parsing ends in the middle of a
1157    field reference, return the type of the left-hand-side of the
1158    reference; furthermore, if the parsing ends in the field name,
1159    return the field name in *NAME.  In all other cases, return NULL.
1160    Returned non-NULL *NAME must be freed by the caller.  */
1161
1162 struct type *
1163 parse_field_expression (char *string, char **name)
1164 {
1165   struct expression *exp = NULL;
1166   struct value *val;
1167   int subexp;
1168   volatile struct gdb_exception except;
1169
1170   TRY_CATCH (except, RETURN_MASK_ALL)
1171     {
1172       in_parse_field = 1;
1173       exp = parse_exp_in_context (&string, 0, 0, 0, &subexp);
1174     }
1175   in_parse_field = 0;
1176   if (except.reason < 0 || ! exp)
1177     return NULL;
1178   if (expout_last_struct == -1)
1179     {
1180       xfree (exp);
1181       return NULL;
1182     }
1183
1184   *name = extract_field_op (exp, &subexp);
1185   if (!*name)
1186     {
1187       xfree (exp);
1188       return NULL;
1189     }
1190   /* (*NAME) is a part of the EXP memory block freed below.  */
1191   *name = xstrdup (*name);
1192
1193   val = evaluate_subexpression_type (exp, subexp);
1194   xfree (exp);
1195
1196   return value_type (val);
1197 }
1198
1199 /* A post-parser that does nothing */
1200
1201 void
1202 null_post_parser (struct expression **exp, int void_context_p)
1203 {
1204 }
1205 \f
1206 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1207    probably useful for any language which declares its types "backwards".  */
1208
1209 static void
1210 check_type_stack_depth (void)
1211 {
1212   if (type_stack_depth == type_stack_size)
1213     {
1214       type_stack_size *= 2;
1215       type_stack = (union type_stack_elt *)
1216         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1217     }
1218 }
1219
1220 void
1221 push_type (enum type_pieces tp)
1222 {
1223   check_type_stack_depth ();
1224   type_stack[type_stack_depth++].piece = tp;
1225 }
1226
1227 void
1228 push_type_int (int n)
1229 {
1230   check_type_stack_depth ();
1231   type_stack[type_stack_depth++].int_val = n;
1232 }
1233
1234 void
1235 push_type_address_space (char *string)
1236 {
1237   push_type_int (address_space_name_to_int (parse_gdbarch, string));
1238 }
1239
1240 enum type_pieces
1241 pop_type (void)
1242 {
1243   if (type_stack_depth)
1244     return type_stack[--type_stack_depth].piece;
1245   return tp_end;
1246 }
1247
1248 int
1249 pop_type_int (void)
1250 {
1251   if (type_stack_depth)
1252     return type_stack[--type_stack_depth].int_val;
1253   /* "Can't happen".  */
1254   return 0;
1255 }
1256
1257 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1258    as modified by all the stuff on the stack.  */
1259 struct type *
1260 follow_types (struct type *follow_type)
1261 {
1262   int done = 0;
1263   int make_const = 0;
1264   int make_volatile = 0;
1265   int make_addr_space = 0;
1266   int array_size;
1267
1268   while (!done)
1269     switch (pop_type ())
1270       {
1271       case tp_end:
1272         done = 1;
1273         if (make_const)
1274           follow_type = make_cv_type (make_const,
1275                                       TYPE_VOLATILE (follow_type),
1276                                       follow_type, 0);
1277         if (make_volatile)
1278           follow_type = make_cv_type (TYPE_CONST (follow_type),
1279                                       make_volatile,
1280                                       follow_type, 0);
1281         if (make_addr_space)
1282           follow_type = make_type_with_address_space (follow_type,
1283                                                       make_addr_space);
1284         make_const = make_volatile = 0;
1285         make_addr_space = 0;
1286         break;
1287       case tp_const:
1288         make_const = 1;
1289         break;
1290       case tp_volatile:
1291         make_volatile = 1;
1292         break;
1293       case tp_space_identifier:
1294         make_addr_space = pop_type_int ();
1295         break;
1296       case tp_pointer:
1297         follow_type = lookup_pointer_type (follow_type);
1298         if (make_const)
1299           follow_type = make_cv_type (make_const,
1300                                       TYPE_VOLATILE (follow_type),
1301                                       follow_type, 0);
1302         if (make_volatile)
1303           follow_type = make_cv_type (TYPE_CONST (follow_type),
1304                                       make_volatile,
1305                                       follow_type, 0);
1306         if (make_addr_space)
1307           follow_type = make_type_with_address_space (follow_type,
1308                                                       make_addr_space);
1309         make_const = make_volatile = 0;
1310         make_addr_space = 0;
1311         break;
1312       case tp_reference:
1313         follow_type = lookup_reference_type (follow_type);
1314         if (make_const)
1315           follow_type = make_cv_type (make_const,
1316                                       TYPE_VOLATILE (follow_type),
1317                                       follow_type, 0);
1318         if (make_volatile)
1319           follow_type = make_cv_type (TYPE_CONST (follow_type),
1320                                       make_volatile,
1321                                       follow_type, 0);
1322         if (make_addr_space)
1323           follow_type = make_type_with_address_space (follow_type,
1324                                                       make_addr_space);
1325         make_const = make_volatile = 0;
1326         make_addr_space = 0;
1327         break;
1328       case tp_array:
1329         array_size = pop_type_int ();
1330         /* FIXME-type-allocation: need a way to free this type when we are
1331            done with it.  */
1332         follow_type =
1333           lookup_array_range_type (follow_type,
1334                                    0, array_size >= 0 ? array_size - 1 : 0);
1335         if (array_size < 0)
1336           TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type) = 1;
1337         break;
1338       case tp_function:
1339         /* FIXME-type-allocation: need a way to free this type when we are
1340            done with it.  */
1341         follow_type = lookup_function_type (follow_type);
1342         break;
1343       }
1344   return follow_type;
1345 }
1346 \f
1347 /* This function avoids direct calls to fprintf
1348    in the parser generated debug code.  */
1349 void
1350 parser_fprintf (FILE *x, const char *y, ...)
1351 {
1352   va_list args;
1353   va_start (args, y);
1354   if (x == stderr)
1355     vfprintf_unfiltered (gdb_stderr, y, args);
1356   else
1357     {
1358       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1359       vfprintf_unfiltered (gdb_stderr, y, args);
1360     }
1361   va_end (args);
1362 }
1363
1364 void
1365 _initialize_parse (void)
1366 {
1367   type_stack_size = 80;
1368   type_stack_depth = 0;
1369   type_stack = (union type_stack_elt *)
1370     xmalloc (type_stack_size * sizeof (*type_stack));
1371
1372   add_setshow_zinteger_cmd ("expression", class_maintenance,
1373                             &expressiondebug, _("\
1374 Set expression debugging."), _("\
1375 Show expression debugging."), _("\
1376 When non-zero, the internal representation of expressions will be printed."),
1377                             NULL,
1378                             show_expressiondebug,
1379                             &setdebuglist, &showdebuglist);
1380 }