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