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