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