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
   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 "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.  Gdb
 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 bitstring constant to the end of the expression.
 356
 357    Bitstring constants are stored by first writing an expression element
 358    that contains the length of the bitstring (in bits), then stuffing the
 359    bitstring constant itself into however many expression elements are
 360    needed to hold it, and then writing another expression element that
 361    contains the length of the bitstring.  I.E. an expression element at
 362    each end of the bitstring records the bitstring length, so you can skip
 363    over the expression elements containing the actual bitstring bytes from
 364    either end of the bitstring. */
 365
 366 void
 367 write_exp_bitstring (struct stoken str)
 368 {
 369   int bits = str.length;        /* length in bits */
 370   int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 371   int lenelt;
 372   char *strdata;
 373
 374   /* Compute the number of expression elements required to hold the bitstring,
 375      along with one expression element at each end to record the actual
 376      bitstring length in bits. */
 377
 378   lenelt = 2 + BYTES_TO_EXP_ELEM (len);
 379
 380   /* Ensure that we have enough available expression elements to store
 381      everything. */
 382
 383   if ((expout_ptr + lenelt) >= expout_size)
 384     {
 385       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 386       expout = (struct expression *)
 387         xrealloc ((char *) expout, (sizeof (struct expression)
 388                                     + EXP_ELEM_TO_BYTES (expout_size)));
 389     }
 390
 391   /* Write the leading length expression element (which advances the current
 392      expression element index), then write the bitstring constant, and then
 393      write the trailing length expression element. */
 394
 395   write_exp_elt_longcst ((LONGEST) bits);
 396   strdata = (char *) &expout->elts[expout_ptr];
 397   memcpy (strdata, str.ptr, len);
 398   expout_ptr += lenelt - 2;
 399   write_exp_elt_longcst ((LONGEST) bits);
 400 }
 401
 402 /* Add the appropriate elements for a minimal symbol to the end of
 403    the expression.  */
 404
 405 void
 406 write_exp_msymbol (struct minimal_symbol *msymbol)
 407 {
 408   struct objfile *objfile = msymbol_objfile (msymbol);
 409   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 410
 411   CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
 412   struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol);
 413   enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
 414   CORE_ADDR pc;
 415
 416   /* The minimal symbol might point to a function descriptor;
 417      resolve it to the actual code address instead.  */
 418   pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
 419   if (pc != addr)
 420     {
 421       /* In this case, assume we have a code symbol instead of
 422          a data symbol.  */
 423       type = mst_text;
 424       section = NULL;
 425       addr = pc;
 426     }
 427
 428   if (overlay_debugging)
 429     addr = symbol_overlayed_address (addr, section);
 430
 431   write_exp_elt_opcode (OP_LONG);
 432   /* Let's make the type big enough to hold a 64-bit address.  */
 433   write_exp_elt_type (builtin_type (gdbarch)->builtin_core_addr);
 434   write_exp_elt_longcst ((LONGEST) addr);
 435   write_exp_elt_opcode (OP_LONG);
 436
 437   if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
 438     {
 439       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 440       write_exp_elt_objfile (objfile);
 441       write_exp_elt_type (builtin_type (gdbarch)->nodebug_tls_symbol);
 442       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
 443       return;
 444     }
 445
 446   write_exp_elt_opcode (UNOP_MEMVAL);
 447   switch (type)
 448     {
 449     case mst_text:
 450     case mst_file_text:
 451     case mst_solib_trampoline:
 452       write_exp_elt_type (builtin_type (gdbarch)->nodebug_text_symbol);
 453       break;
 454
 455     case mst_data:
 456     case mst_file_data:
 457     case mst_bss:
 458     case mst_file_bss:
 459       write_exp_elt_type (builtin_type (gdbarch)->nodebug_data_symbol);
 460       break;
 461
 462     default:
 463       write_exp_elt_type (builtin_type (gdbarch)->nodebug_unknown_symbol);
 464       break;
 465     }
 466   write_exp_elt_opcode (UNOP_MEMVAL);
 467 }
 468
 469 /* Mark the current index as the starting location of a structure
 470    expression.  This is used when completing on field names.  */
 471
 472 void
 473 mark_struct_expression (void)
 474 {
 475   expout_last_struct = expout_ptr;
 476 }
 477
 478 \f
 479 /* Recognize tokens that start with '$'.  These include:
 480
 481    $regname     A native register name or a "standard
 482    register name".
 483
 484    $variable    A convenience variable with a name chosen
 485    by the user.
 486
 487    $digits              Value history with index <digits>, starting
 488    from the first value which has index 1.
 489
 490    $$digits     Value history with index <digits> relative
 491    to the last value.  I.E. $$0 is the last
 492    value, $$1 is the one previous to that, $$2
 493    is the one previous to $$1, etc.
 494
 495    $ | $0 | $$0 The last value in the value history.
 496
 497    $$           An abbreviation for the second to the last
 498    value in the value history, I.E. $$1
 499
 500  */
 501
 502 void
 503 write_dollar_variable (struct stoken str)
 504 {
 505   struct symbol *sym = NULL;
 506   struct minimal_symbol *msym = NULL;
 507   struct internalvar *isym = NULL;
 508
 509   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
 510      and $$digits (equivalent to $<-digits> if you could type that). */
 511
 512   int negate = 0;
 513   int i = 1;
 514   /* Double dollar means negate the number and add -1 as well.
 515      Thus $$ alone means -1.  */
 516   if (str.length >= 2 && str.ptr[1] == '$')
 517     {
 518       negate = 1;
 519       i = 2;
 520     }
 521   if (i == str.length)
 522     {
 523       /* Just dollars (one or two) */
 524       i = -negate;
 525       goto handle_last;
 526     }
 527   /* Is the rest of the token digits?  */
 528   for (; i < str.length; i++)
 529     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
 530       break;
 531   if (i == str.length)
 532     {
 533       i = atoi (str.ptr + 1 + negate);
 534       if (negate)
 535         i = -i;
 536       goto handle_last;
 537     }
 538
 539   /* Handle tokens that refer to machine registers:
 540      $ followed by a register name.  */
 541   i = user_reg_map_name_to_regnum (current_gdbarch,
 542                                    str.ptr + 1, str.length - 1);
 543   if (i >= 0)
 544     goto handle_register;
 545
 546   /* Any names starting with $ are probably debugger internal variables.  */
 547
 548   isym = lookup_only_internalvar (copy_name (str) + 1);
 549   if (isym)
 550     {
 551       write_exp_elt_opcode (OP_INTERNALVAR);
 552       write_exp_elt_intern (isym);
 553       write_exp_elt_opcode (OP_INTERNALVAR);
 554       return;
 555     }
 556
 557   /* On some systems, such as HP-UX and hppa-linux, certain system routines
 558      have names beginning with $ or $$.  Check for those, first. */
 559
 560   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
 561                        VAR_DOMAIN, (int *) NULL);
 562   if (sym)
 563     {
 564       write_exp_elt_opcode (OP_VAR_VALUE);
 565       write_exp_elt_block (block_found);        /* set by lookup_symbol */
 566       write_exp_elt_sym (sym);
 567       write_exp_elt_opcode (OP_VAR_VALUE);
 568       return;
 569     }
 570   msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
 571   if (msym)
 572     {
 573       write_exp_msymbol (msym);
 574       return;
 575     }
 576
 577   /* Any other names are assumed to be debugger internal variables.  */
 578
 579   write_exp_elt_opcode (OP_INTERNALVAR);
 580   write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
 581   write_exp_elt_opcode (OP_INTERNALVAR);
 582   return;
 583 handle_last:
 584   write_exp_elt_opcode (OP_LAST);
 585   write_exp_elt_longcst ((LONGEST) i);
 586   write_exp_elt_opcode (OP_LAST);
 587   return;
 588 handle_register:
 589   write_exp_elt_opcode (OP_REGISTER);
 590   str.length--;
 591   str.ptr++;
 592   write_exp_string (str);
 593   write_exp_elt_opcode (OP_REGISTER);
 594   return;
 595 }
 596
 597
 598 char *
 599 find_template_name_end (char *p)
 600 {
 601   int depth = 1;
 602   int just_seen_right = 0;
 603   int just_seen_colon = 0;
 604   int just_seen_space = 0;
 605
 606   if (!p || (*p != '<'))
 607     return 0;
 608
 609   while (*++p)
 610     {
 611       switch (*p)
 612         {
 613         case '\'':
 614         case '\"':
 615         case '{':
 616         case '}':
 617           /* In future, may want to allow these?? */
 618           return 0;
 619         case '<':
 620           depth++;              /* start nested template */
 621           if (just_seen_colon || just_seen_right || just_seen_space)
 622             return 0;           /* but not after : or :: or > or space */
 623           break;
 624         case '>':
 625           if (just_seen_colon || just_seen_right)
 626             return 0;           /* end a (nested?) template */
 627           just_seen_right = 1;  /* but not after : or :: */
 628           if (--depth == 0)     /* also disallow >>, insist on > > */
 629             return ++p;         /* if outermost ended, return */
 630           break;
 631         case ':':
 632           if (just_seen_space || (just_seen_colon > 1))
 633             return 0;           /* nested class spec coming up */
 634           just_seen_colon++;    /* we allow :: but not :::: */
 635           break;
 636         case ' ':
 637           break;
 638         default:
 639           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
 640                 (*p >= 'A' && *p <= 'Z') ||
 641                 (*p >= '0' && *p <= '9') ||
 642                 (*p == '_') || (*p == ',') ||   /* commas for template args */
 643                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
 644                 (*p == '(') || (*p == ')') ||   /* function types */
 645                 (*p == '[') || (*p == ']')))    /* array types */
 646             return 0;
 647         }
 648       if (*p != ' ')
 649         just_seen_space = 0;
 650       if (*p != ':')
 651         just_seen_colon = 0;
 652       if (*p != '>')
 653         just_seen_right = 0;
 654     }
 655   return 0;
 656 }
 657 \f
 658
 659
 660 /* Return a null-terminated temporary copy of the name
 661    of a string token.  */
 662
 663 char *
 664 copy_name (struct stoken token)
 665 {
 666   /* Make sure there's enough space for the token.  */
 667   if (namecopy_size < token.length + 1)
 668     {
 669       namecopy_size = token.length + 1;
 670       namecopy = xrealloc (namecopy, token.length + 1);
 671     }
 672
 673   memcpy (namecopy, token.ptr, token.length);
 674   namecopy[token.length] = 0;
 675
 676   return namecopy;
 677 }
 678 \f
 679 /* Reverse an expression from suffix form (in which it is constructed)
 680    to prefix form (in which we can conveniently print or execute it).
 681    Ordinarily this always returns -1.  However, if EXPOUT_LAST_STRUCT
 682    is not -1 (i.e., we are trying to complete a field name), it will
 683    return the index of the subexpression which is the left-hand-side
 684    of the struct operation at EXPOUT_LAST_STRUCT.  */
 685
 686 static int
 687 prefixify_expression (struct expression *expr)
 688 {
 689   int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
 690   struct expression *temp;
 691   int inpos = expr->nelts, outpos = 0;
 692
 693   temp = (struct expression *) alloca (len);
 694
 695   /* Copy the original expression into temp.  */
 696   memcpy (temp, expr, len);
 697
 698   return prefixify_subexp (temp, expr, inpos, outpos);
 699 }
 700
 701 /* Return the number of exp_elements in the postfix subexpression
 702    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
 703
 704 int
 705 length_of_subexp (struct expression *expr, int endpos)
 706 {
 707   int oplen, args, i;
 708
 709   operator_length (expr, endpos, &oplen, &args);
 710
 711   while (args > 0)
 712     {
 713       oplen += length_of_subexp (expr, endpos - oplen);
 714       args--;
 715     }
 716
 717   return oplen;
 718 }
 719
 720 /* Sets *OPLENP to the length of the operator whose (last) index is
 721    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
 722    operator takes.  */
 723
 724 void
 725 operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp)
 726 {
 727   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
 728                                                      oplenp, argsp);
 729 }
 730
 731 /* Default value for operator_length in exp_descriptor vectors.  */
 732
 733 void
 734 operator_length_standard (struct expression *expr, int endpos,
 735                           int *oplenp, int *argsp)
 736 {
 737   int oplen = 1;
 738   int args = 0;
 739   enum f90_range_type range_type;
 740   int i;
 741
 742   if (endpos < 1)
 743     error (_("?error in operator_length_standard"));
 744
 745   i = (int) expr->elts[endpos - 1].opcode;
 746
 747   switch (i)
 748     {
 749       /* C++  */
 750     case OP_SCOPE:
 751       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 752       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 753       break;
 754
 755     case OP_LONG:
 756     case OP_DOUBLE:
 757     case OP_DECFLOAT:
 758     case OP_VAR_VALUE:
 759       oplen = 4;
 760       break;
 761
 762     case OP_TYPE:
 763     case OP_BOOL:
 764     case OP_LAST:
 765     case OP_INTERNALVAR:
 766       oplen = 3;
 767       break;
 768
 769     case OP_COMPLEX:
 770       oplen = 3;
 771       args = 2;
 772       break;
 773
 774     case OP_FUNCALL:
 775     case OP_F77_UNDETERMINED_ARGLIST:
 776       oplen = 3;
 777       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 778       break;
 779
 780     case OP_OBJC_MSGCALL:       /* Objective C message (method) call */
 781       oplen = 4;
 782       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 783       break;
 784
 785     case UNOP_MAX:
 786     case UNOP_MIN:
 787       oplen = 3;
 788       break;
 789
 790     case BINOP_VAL:
 791     case UNOP_CAST:
 792     case UNOP_MEMVAL:
 793       oplen = 3;
 794       args = 1;
 795       break;
 796
 797     case UNOP_MEMVAL_TLS:
 798       oplen = 4;
 799       args = 1;
 800       break;
 801
 802     case UNOP_ABS:
 803     case UNOP_CAP:
 804     case UNOP_CHR:
 805     case UNOP_FLOAT:
 806     case UNOP_HIGH:
 807     case UNOP_ODD:
 808     case UNOP_ORD:
 809     case UNOP_TRUNC:
 810       oplen = 1;
 811       args = 1;
 812       break;
 813
 814     case OP_LABELED:
 815     case STRUCTOP_STRUCT:
 816     case STRUCTOP_PTR:
 817       args = 1;
 818       /* fall through */
 819     case OP_REGISTER:
 820     case OP_M2_STRING:
 821     case OP_STRING:
 822     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class NSString constant */
 823     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op */
 824     case OP_NAME:
 825       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 826       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 827       break;
 828
 829     case OP_BITSTRING:
 830       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 831       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 832       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 833       break;
 834
 835     case OP_ARRAY:
 836       oplen = 4;
 837       args = longest_to_int (expr->elts[endpos - 2].longconst);
 838       args -= longest_to_int (expr->elts[endpos - 3].longconst);
 839       args += 1;
 840       break;
 841
 842     case TERNOP_COND:
 843     case TERNOP_SLICE:
 844     case TERNOP_SLICE_COUNT:
 845       args = 3;
 846       break;
 847
 848       /* Modula-2 */
 849     case MULTI_SUBSCRIPT:
 850       oplen = 3;
 851       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 852       break;
 853
 854     case BINOP_ASSIGN_MODIFY:
 855       oplen = 3;
 856       args = 2;
 857       break;
 858
 859       /* C++ */
 860     case OP_THIS:
 861     case OP_OBJC_SELF:
 862       oplen = 2;
 863       break;
 864
 865     case OP_F90_RANGE:
 866       oplen = 3;
 867
 868       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
 869       switch (range_type)
 870         {
 871         case LOW_BOUND_DEFAULT:
 872         case HIGH_BOUND_DEFAULT:
 873           args = 1;
 874           break;
 875         case BOTH_BOUND_DEFAULT:
 876           args = 0;
 877           break;
 878         case NONE_BOUND_DEFAULT:
 879           args = 2;
 880           break;
 881         }
 882
 883       break;
 884
 885     default:
 886       args = 1 + (i < (int) BINOP_END);
 887     }
 888
 889   *oplenp = oplen;
 890   *argsp = args;
 891 }
 892
 893 /* Copy the subexpression ending just before index INEND in INEXPR
 894    into OUTEXPR, starting at index OUTBEG.
 895    In the process, convert it from suffix to prefix form.
 896    If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
 897    Otherwise, it returns the index of the subexpression which is the
 898    left-hand-side of the expression at EXPOUT_LAST_STRUCT.  */
 899
 900 static int
 901 prefixify_subexp (struct expression *inexpr,
 902                   struct expression *outexpr, int inend, int outbeg)
 903 {
 904   int oplen;
 905   int args;
 906   int i;
 907   int *arglens;
 908   enum exp_opcode opcode;
 909   int result = -1;
 910
 911   operator_length (inexpr, inend, &oplen, &args);
 912
 913   /* Copy the final operator itself, from the end of the input
 914      to the beginning of the output.  */
 915   inend -= oplen;
 916   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
 917           EXP_ELEM_TO_BYTES (oplen));
 918   outbeg += oplen;
 919
 920   if (expout_last_struct == inend)
 921     result = outbeg - oplen;
 922
 923   /* Find the lengths of the arg subexpressions.  */
 924   arglens = (int *) alloca (args * sizeof (int));
 925   for (i = args - 1; i >= 0; i--)
 926     {
 927       oplen = length_of_subexp (inexpr, inend);
 928       arglens[i] = oplen;
 929       inend -= oplen;
 930     }
 931
 932   /* Now copy each subexpression, preserving the order of
 933      the subexpressions, but prefixifying each one.
 934      In this loop, inend starts at the beginning of
 935      the expression this level is working on
 936      and marches forward over the arguments.
 937      outbeg does similarly in the output.  */
 938   for (i = 0; i < args; i++)
 939     {
 940       int r;
 941       oplen = arglens[i];
 942       inend += oplen;
 943       r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
 944       if (r != -1)
 945         {
 946           /* Return immediately.  We probably have only parsed a
 947              partial expression, so we don't want to try to reverse
 948              the other operands.  */
 949           return r;
 950         }
 951       outbeg += oplen;
 952     }
 953
 954   return result;
 955 }
 956 \f
 957 /* This page contains the two entry points to this file.  */
 958
 959 /* Read an expression from the string *STRINGPTR points to,
 960    parse it, and return a pointer to a  struct expression  that we malloc.
 961    Use block BLOCK as the lexical context for variable names;
 962    if BLOCK is zero, use the block of the selected stack frame.
 963    Meanwhile, advance *STRINGPTR to point after the expression,
 964    at the first nonwhite character that is not part of the expression
 965    (possibly a null character).
 966
 967    If COMMA is nonzero, stop if a comma is reached.  */
 968
 969 struct expression *
 970 parse_exp_1 (char **stringptr, struct block *block, int comma)
 971 {
 972   return parse_exp_in_context (stringptr, block, comma, 0, NULL);
 973 }
 974
 975 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
 976    no value is expected from the expression.
 977    OUT_SUBEXP is set when attempting to complete a field name; in this
 978    case it is set to the index of the subexpression on the
 979    left-hand-side of the struct op.  If not doing such completion, it
 980    is left untouched.  */
 981
 982 static struct expression *
 983 parse_exp_in_context (char **stringptr, struct block *block, int comma,
 984                       int void_context_p, int *out_subexp)
 985 {
 986   volatile struct gdb_exception except;
 987   struct cleanup *old_chain;
 988   int subexp;
 989
 990   lexptr = *stringptr;
 991   prev_lexptr = NULL;
 992
 993   paren_depth = 0;
 994   type_stack_depth = 0;
 995   expout_last_struct = -1;
 996
 997   comma_terminates = comma;
 998
 999   if (lexptr == 0 || *lexptr == 0)
1000     error_no_arg (_("expression to compute"));
1001
1002   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1003   funcall_chain = 0;
1004
1005   expression_context_block = block;
1006
1007   /* If no context specified, try using the current frame, if any.  */
1008   if (!expression_context_block)
1009     expression_context_block = get_selected_block (&expression_context_pc);
1010   else
1011     expression_context_pc = BLOCK_START (expression_context_block);
1012
1013   /* Fall back to using the current source static context, if any.  */
1014
1015   if (!expression_context_block)
1016     {
1017       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1018       if (cursal.symtab)
1019         expression_context_block
1020           = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1021       if (expression_context_block)
1022         expression_context_pc = BLOCK_START (expression_context_block);
1023     }
1024
1025   expout_size = 10;
1026   expout_ptr = 0;
1027   expout = (struct expression *)
1028     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1029   expout->language_defn = current_language;
1030   expout->gdbarch = current_gdbarch;
1031
1032   TRY_CATCH (except, RETURN_MASK_ALL)
1033     {
1034       if (current_language->la_parser ())
1035         current_language->la_error (NULL);
1036     }
1037   if (except.reason < 0)
1038     {
1039       if (! in_parse_field)
1040         {
1041           xfree (expout);
1042           throw_exception (except);
1043         }
1044     }
1045
1046   discard_cleanups (old_chain);
1047
1048   /* Record the actual number of expression elements, and then
1049      reallocate the expression memory so that we free up any
1050      excess elements. */
1051
1052   expout->nelts = expout_ptr;
1053   expout = (struct expression *)
1054     xrealloc ((char *) expout,
1055               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1056
1057   /* Convert expression from postfix form as generated by yacc
1058      parser, to a prefix form. */
1059
1060   if (expressiondebug)
1061     dump_raw_expression (expout, gdb_stdlog,
1062                          "before conversion to prefix form");
1063
1064   subexp = prefixify_expression (expout);
1065   if (out_subexp)
1066     *out_subexp = subexp;
1067
1068   current_language->la_post_parser (&expout, void_context_p);
1069
1070   if (expressiondebug)
1071     dump_prefix_expression (expout, gdb_stdlog);
1072
1073   *stringptr = lexptr;
1074   return expout;
1075 }
1076
1077 /* Parse STRING as an expression, and complain if this fails
1078    to use up all of the contents of STRING.  */
1079
1080 struct expression *
1081 parse_expression (char *string)
1082 {
1083   struct expression *exp;
1084   exp = parse_exp_1 (&string, 0, 0);
1085   if (*string)
1086     error (_("Junk after end of expression."));
1087   return exp;
1088 }
1089
1090 /* Parse STRING as an expression.  If parsing ends in the middle of a
1091    field reference, return the type of the left-hand-side of the
1092    reference; furthermore, if the parsing ends in the field name,
1093    return the field name in *NAME.  In all other cases, return NULL.
1094    Returned non-NULL *NAME must be freed by the caller.  */
1095
1096 struct type *
1097 parse_field_expression (char *string, char **name)
1098 {
1099   struct expression *exp = NULL;
1100   struct value *val;
1101   int subexp;
1102   volatile struct gdb_exception except;
1103
1104   TRY_CATCH (except, RETURN_MASK_ALL)
1105     {
1106       in_parse_field = 1;
1107       exp = parse_exp_in_context (&string, 0, 0, 0, &subexp);
1108     }
1109   in_parse_field = 0;
1110   if (except.reason < 0 || ! exp)
1111     return NULL;
1112   if (expout_last_struct == -1)
1113     {
1114       xfree (exp);
1115       return NULL;
1116     }
1117
1118   *name = extract_field_op (exp, &subexp);
1119   if (!*name)
1120     {
1121       xfree (exp);
1122       return NULL;
1123     }
1124   /* (*NAME) is a part of the EXP memory block freed below.  */
1125   *name = xstrdup (*name);
1126
1127   val = evaluate_subexpression_type (exp, subexp);
1128   xfree (exp);
1129
1130   return value_type (val);
1131 }
1132
1133 /* A post-parser that does nothing */
1134
1135 void
1136 null_post_parser (struct expression **exp, int void_context_p)
1137 {
1138 }
1139 \f
1140 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1141    probably useful for any language which declares its types "backwards".  */
1142
1143 static void
1144 check_type_stack_depth (void)
1145 {
1146   if (type_stack_depth == type_stack_size)
1147     {
1148       type_stack_size *= 2;
1149       type_stack = (union type_stack_elt *)
1150         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1151     }
1152 }
1153
1154 void
1155 push_type (enum type_pieces tp)
1156 {
1157   check_type_stack_depth ();
1158   type_stack[type_stack_depth++].piece = tp;
1159 }
1160
1161 void
1162 push_type_int (int n)
1163 {
1164   check_type_stack_depth ();
1165   type_stack[type_stack_depth++].int_val = n;
1166 }
1167
1168 void
1169 push_type_address_space (char *string)
1170 {
1171   push_type_int (address_space_name_to_int (string));
1172 }
1173
1174 enum type_pieces
1175 pop_type (void)
1176 {
1177   if (type_stack_depth)
1178     return type_stack[--type_stack_depth].piece;
1179   return tp_end;
1180 }
1181
1182 int
1183 pop_type_int (void)
1184 {
1185   if (type_stack_depth)
1186     return type_stack[--type_stack_depth].int_val;
1187   /* "Can't happen".  */
1188   return 0;
1189 }
1190
1191 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1192    as modified by all the stuff on the stack.  */
1193 struct type *
1194 follow_types (struct type *follow_type)
1195 {
1196   int done = 0;
1197   int make_const = 0;
1198   int make_volatile = 0;
1199   int make_addr_space = 0;
1200   int array_size;
1201   struct type *range_type;
1202
1203   while (!done)
1204     switch (pop_type ())
1205       {
1206       case tp_end:
1207         done = 1;
1208         if (make_const)
1209           follow_type = make_cv_type (make_const,
1210                                       TYPE_VOLATILE (follow_type),
1211                                       follow_type, 0);
1212         if (make_volatile)
1213           follow_type = make_cv_type (TYPE_CONST (follow_type),
1214                                       make_volatile,
1215                                       follow_type, 0);
1216         if (make_addr_space)
1217           follow_type = make_type_with_address_space (follow_type,
1218                                                       make_addr_space);
1219         make_const = make_volatile = 0;
1220         make_addr_space = 0;
1221         break;
1222       case tp_const:
1223         make_const = 1;
1224         break;
1225       case tp_volatile:
1226         make_volatile = 1;
1227         break;
1228       case tp_space_identifier:
1229         make_addr_space = pop_type_int ();
1230         break;
1231       case tp_pointer:
1232         follow_type = lookup_pointer_type (follow_type);
1233         if (make_const)
1234           follow_type = make_cv_type (make_const,
1235                                       TYPE_VOLATILE (follow_type),
1236                                       follow_type, 0);
1237         if (make_volatile)
1238           follow_type = make_cv_type (TYPE_CONST (follow_type),
1239                                       make_volatile,
1240                                       follow_type, 0);
1241         if (make_addr_space)
1242           follow_type = make_type_with_address_space (follow_type,
1243                                                       make_addr_space);
1244         make_const = make_volatile = 0;
1245         make_addr_space = 0;
1246         break;
1247       case tp_reference:
1248         follow_type = lookup_reference_type (follow_type);
1249         if (make_const)
1250           follow_type = make_cv_type (make_const,
1251                                       TYPE_VOLATILE (follow_type),
1252                                       follow_type, 0);
1253         if (make_volatile)
1254           follow_type = make_cv_type (TYPE_CONST (follow_type),
1255                                       make_volatile,
1256                                       follow_type, 0);
1257         if (make_addr_space)
1258           follow_type = make_type_with_address_space (follow_type,
1259                                                       make_addr_space);
1260         make_const = make_volatile = 0;
1261         make_addr_space = 0;
1262         break;
1263       case tp_array:
1264         array_size = pop_type_int ();
1265         /* FIXME-type-allocation: need a way to free this type when we are
1266            done with it.  */
1267         range_type =
1268           create_range_type ((struct type *) NULL,
1269                              builtin_type_int32, 0,
1270                              array_size >= 0 ? array_size - 1 : 0);
1271         follow_type =
1272           create_array_type ((struct type *) NULL,
1273                              follow_type, range_type);
1274         if (array_size < 0)
1275           TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type) = 1;
1276         break;
1277       case tp_function:
1278         /* FIXME-type-allocation: need a way to free this type when we are
1279            done with it.  */
1280         follow_type = lookup_function_type (follow_type);
1281         break;
1282       }
1283   return follow_type;
1284 }
1285 \f
1286 /* This function avoids direct calls to fprintf
1287    in the parser generated debug code.  */
1288 void
1289 parser_fprintf (FILE *x, const char *y, ...)
1290 {
1291   va_list args;
1292   va_start (args, y);
1293   if (x == stderr)
1294     vfprintf_unfiltered (gdb_stderr, y, args);
1295   else
1296     {
1297       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1298       vfprintf_unfiltered (gdb_stderr, y, args);
1299     }
1300   va_end (args);
1301 }
1302
1303 void
1304 _initialize_parse (void)
1305 {
1306   type_stack_size = 80;
1307   type_stack_depth = 0;
1308   type_stack = (union type_stack_elt *)
1309     xmalloc (type_stack_size * sizeof (*type_stack));
1310
1311   add_setshow_zinteger_cmd ("expression", class_maintenance,
1312                             &expressiondebug, _("\
1313 Set expression debugging."), _("\
1314 Show expression debugging."), _("\
1315 When non-zero, the internal representation of expressions will be printed."),
1316                             NULL,
1317                             show_expressiondebug,
1318                             &setdebuglist, &showdebuglist);
1319 }