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