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