gdb/parse.c

   1 /* Parse expressions for GDB.
   2
   3    Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1997, 1998, 1999, 2000, 2001, 2004, 2005 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"           /* for NUM_PSEUDO_REGS.  NOTE: replace
  51                                    with "gdbarch.h" when appropriate.  */
  52 #include "doublest.h"
  53 #include "gdb_assert.h"
  54 #include "block.h"
  55 #include "source.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
 195   tmp.opcode = expelt;
 196
 197   write_exp_elt (tmp);
 198 }
 199
 200 void
 201 write_exp_elt_sym (struct symbol *expelt)
 202 {
 203   union exp_element tmp;
 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   tmp.block = b;
 215   write_exp_elt (tmp);
 216 }
 217
 218 void
 219 write_exp_elt_longcst (LONGEST expelt)
 220 {
 221   union exp_element tmp;
 222
 223   tmp.longconst = expelt;
 224
 225   write_exp_elt (tmp);
 226 }
 227
 228 void
 229 write_exp_elt_dblcst (DOUBLEST expelt)
 230 {
 231   union exp_element tmp;
 232
 233   tmp.doubleconst = expelt;
 234
 235   write_exp_elt (tmp);
 236 }
 237
 238 void
 239 write_exp_elt_type (struct type *expelt)
 240 {
 241   union exp_element tmp;
 242
 243   tmp.type = expelt;
 244
 245   write_exp_elt (tmp);
 246 }
 247
 248 void
 249 write_exp_elt_intern (struct internalvar *expelt)
 250 {
 251   union exp_element tmp;
 252
 253   tmp.internalvar = expelt;
 254
 255   write_exp_elt (tmp);
 256 }
 257
 258 /* Add a string constant to the end of the expression.
 259
 260    String constants are stored by first writing an expression element
 261    that contains the length of the string, then stuffing the string
 262    constant itself into however many expression elements are needed
 263    to hold it, and then writing another expression element that contains
 264    the length of the string.  I.E. an expression element at each end of
 265    the string records the string length, so you can skip over the
 266    expression elements containing the actual string bytes from either
 267    end of the string.  Note that this also allows gdb to handle
 268    strings with embedded null bytes, as is required for some languages.
 269
 270    Don't be fooled by the fact that the string is null byte terminated,
 271    this is strictly for the convenience of debugging gdb itself.  Gdb
 272    Gdb does not depend up the string being null terminated, since the
 273    actual length is recorded in expression elements at each end of the
 274    string.  The null byte is taken into consideration when computing how
 275    many expression elements are required to hold the string constant, of
 276    course. */
 277
 278
 279 void
 280 write_exp_string (struct stoken str)
 281 {
 282   int len = str.length;
 283   int lenelt;
 284   char *strdata;
 285
 286   /* Compute the number of expression elements required to hold the string
 287      (including a null byte terminator), along with one expression element
 288      at each end to record the actual string length (not including the
 289      null byte terminator). */
 290
 291   lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
 292
 293   /* Ensure that we have enough available expression elements to store
 294      everything. */
 295
 296   if ((expout_ptr + lenelt) >= expout_size)
 297     {
 298       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 299       expout = (struct expression *)
 300         xrealloc ((char *) expout, (sizeof (struct expression)
 301                                     + EXP_ELEM_TO_BYTES (expout_size)));
 302     }
 303
 304   /* Write the leading length expression element (which advances the current
 305      expression element index), then write the string constant followed by a
 306      terminating null byte, and then write the trailing length expression
 307      element. */
 308
 309   write_exp_elt_longcst ((LONGEST) len);
 310   strdata = (char *) &expout->elts[expout_ptr];
 311   memcpy (strdata, str.ptr, len);
 312   *(strdata + len) = '\0';
 313   expout_ptr += lenelt - 2;
 314   write_exp_elt_longcst ((LONGEST) len);
 315 }
 316
 317 /* Add a bitstring constant to the end of the expression.
 318
 319    Bitstring constants are stored by first writing an expression element
 320    that contains the length of the bitstring (in bits), then stuffing the
 321    bitstring constant itself into however many expression elements are
 322    needed to hold it, and then writing another expression element that
 323    contains the length of the bitstring.  I.E. an expression element at
 324    each end of the bitstring records the bitstring length, so you can skip
 325    over the expression elements containing the actual bitstring bytes from
 326    either end of the bitstring. */
 327
 328 void
 329 write_exp_bitstring (struct stoken str)
 330 {
 331   int bits = str.length;        /* length in bits */
 332   int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 333   int lenelt;
 334   char *strdata;
 335
 336   /* Compute the number of expression elements required to hold the bitstring,
 337      along with one expression element at each end to record the actual
 338      bitstring length in bits. */
 339
 340   lenelt = 2 + BYTES_TO_EXP_ELEM (len);
 341
 342   /* Ensure that we have enough available expression elements to store
 343      everything. */
 344
 345   if ((expout_ptr + lenelt) >= expout_size)
 346     {
 347       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
 348       expout = (struct expression *)
 349         xrealloc ((char *) expout, (sizeof (struct expression)
 350                                     + EXP_ELEM_TO_BYTES (expout_size)));
 351     }
 352
 353   /* Write the leading length expression element (which advances the current
 354      expression element index), then write the bitstring constant, and then
 355      write the trailing length expression element. */
 356
 357   write_exp_elt_longcst ((LONGEST) bits);
 358   strdata = (char *) &expout->elts[expout_ptr];
 359   memcpy (strdata, str.ptr, len);
 360   expout_ptr += lenelt - 2;
 361   write_exp_elt_longcst ((LONGEST) bits);
 362 }
 363
 364 /* Add the appropriate elements for a minimal symbol to the end of
 365    the expression.  The rationale behind passing in text_symbol_type and
 366    data_symbol_type was so that Modula-2 could pass in WORD for
 367    data_symbol_type.  Perhaps it still is useful to have those types vary
 368    based on the language, but they no longer have names like "int", so
 369    the initial rationale is gone.  */
 370
 371 static struct type *msym_text_symbol_type;
 372 static struct type *msym_data_symbol_type;
 373 static struct type *msym_unknown_symbol_type;
 374
 375 void
 376 write_exp_msymbol (struct minimal_symbol *msymbol,
 377                    struct type *text_symbol_type,
 378                    struct type *data_symbol_type)
 379 {
 380   CORE_ADDR addr;
 381
 382   write_exp_elt_opcode (OP_LONG);
 383   /* Let's make the type big enough to hold a 64-bit address.  */
 384   write_exp_elt_type (builtin_type_CORE_ADDR);
 385
 386   addr = SYMBOL_VALUE_ADDRESS (msymbol);
 387   if (overlay_debugging)
 388     addr = symbol_overlayed_address (addr, SYMBOL_BFD_SECTION (msymbol));
 389   write_exp_elt_longcst ((LONGEST) addr);
 390
 391   write_exp_elt_opcode (OP_LONG);
 392
 393   write_exp_elt_opcode (UNOP_MEMVAL);
 394   switch (msymbol->type)
 395     {
 396     case mst_text:
 397     case mst_file_text:
 398     case mst_solib_trampoline:
 399       write_exp_elt_type (msym_text_symbol_type);
 400       break;
 401
 402     case mst_data:
 403     case mst_file_data:
 404     case mst_bss:
 405     case mst_file_bss:
 406       write_exp_elt_type (msym_data_symbol_type);
 407       break;
 408
 409     default:
 410       write_exp_elt_type (msym_unknown_symbol_type);
 411       break;
 412     }
 413   write_exp_elt_opcode (UNOP_MEMVAL);
 414 }
 415 \f
 416 /* Recognize tokens that start with '$'.  These include:
 417
 418    $regname     A native register name or a "standard
 419    register name".
 420
 421    $variable    A convenience variable with a name chosen
 422    by the user.
 423
 424    $digits              Value history with index <digits>, starting
 425    from the first value which has index 1.
 426
 427    $$digits     Value history with index <digits> relative
 428    to the last value.  I.E. $$0 is the last
 429    value, $$1 is the one previous to that, $$2
 430    is the one previous to $$1, etc.
 431
 432    $ | $0 | $$0 The last value in the value history.
 433
 434    $$           An abbreviation for the second to the last
 435    value in the value history, I.E. $$1
 436
 437  */
 438
 439 void
 440 write_dollar_variable (struct stoken str)
 441 {
 442   struct symbol *sym = NULL;
 443   struct minimal_symbol *msym = NULL;
 444
 445   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
 446      and $$digits (equivalent to $<-digits> if you could type that). */
 447
 448   int negate = 0;
 449   int i = 1;
 450   /* Double dollar means negate the number and add -1 as well.
 451      Thus $$ alone means -1.  */
 452   if (str.length >= 2 && str.ptr[1] == '$')
 453     {
 454       negate = 1;
 455       i = 2;
 456     }
 457   if (i == str.length)
 458     {
 459       /* Just dollars (one or two) */
 460       i = -negate;
 461       goto handle_last;
 462     }
 463   /* Is the rest of the token digits?  */
 464   for (; i < str.length; i++)
 465     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
 466       break;
 467   if (i == str.length)
 468     {
 469       i = atoi (str.ptr + 1 + negate);
 470       if (negate)
 471         i = -i;
 472       goto handle_last;
 473     }
 474
 475   /* Handle tokens that refer to machine registers:
 476      $ followed by a register name.  */
 477   i = frame_map_name_to_regnum (deprecated_selected_frame,
 478                                 str.ptr + 1, str.length - 1);
 479   if (i >= 0)
 480     goto handle_register;
 481
 482   /* On some systems, such as HP-UX and hppa-linux, certain system routines
 483      have names beginning with $ or $$.  Check for those, first. */
 484
 485   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
 486                        VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL);
 487   if (sym)
 488     {
 489       write_exp_elt_opcode (OP_VAR_VALUE);
 490       write_exp_elt_block (block_found);        /* set by lookup_symbol */
 491       write_exp_elt_sym (sym);
 492       write_exp_elt_opcode (OP_VAR_VALUE);
 493       return;
 494     }
 495   msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
 496   if (msym)
 497     {
 498       write_exp_msymbol (msym,
 499                          lookup_function_type (builtin_type_int),
 500                          builtin_type_int);
 501       return;
 502     }
 503
 504   /* Any other names starting in $ are debugger internal variables.  */
 505
 506   write_exp_elt_opcode (OP_INTERNALVAR);
 507   write_exp_elt_intern (lookup_internalvar (copy_name (str) + 1));
 508   write_exp_elt_opcode (OP_INTERNALVAR);
 509   return;
 510 handle_last:
 511   write_exp_elt_opcode (OP_LAST);
 512   write_exp_elt_longcst ((LONGEST) i);
 513   write_exp_elt_opcode (OP_LAST);
 514   return;
 515 handle_register:
 516   write_exp_elt_opcode (OP_REGISTER);
 517   write_exp_elt_longcst (i);
 518   write_exp_elt_opcode (OP_REGISTER);
 519   return;
 520 }
 521
 522
 523 /* Parse a string that is possibly a namespace / nested class
 524    specification, i.e., something of the form A::B::C::x.  Input
 525    (NAME) is the entire string; LEN is the current valid length; the
 526    output is a string, TOKEN, which points to the largest recognized
 527    prefix which is a series of namespaces or classes.  CLASS_PREFIX is
 528    another output, which records whether a nested class spec was
 529    recognized (= 1) or a fully qualified variable name was found (=
 530    0).  ARGPTR is side-effected (if non-NULL) to point to beyond the
 531    string recognized and consumed by this routine.
 532
 533    The return value is a pointer to the symbol for the base class or
 534    variable if found, or NULL if not found.  Callers must check this
 535    first -- if NULL, the outputs may not be correct.
 536
 537    This function is used c-exp.y.  This is used specifically to get
 538    around HP aCC (and possibly other compilers), which insists on
 539    generating names with embedded colons for namespace or nested class
 540    members.
 541
 542    (Argument LEN is currently unused. 1997-08-27)
 543
 544    Callers must free memory allocated for the output string TOKEN.  */
 545
 546 static const char coloncolon[2] =
 547 {':', ':'};
 548
 549 struct symbol *
 550 parse_nested_classes_for_hpacc (char *name, int len, char **token,
 551                                 int *class_prefix, char **argptr)
 552 {
 553   /* Comment below comes from decode_line_1 which has very similar
 554      code, which is called for "break" command parsing. */
 555
 556   /* We have what looks like a class or namespace
 557      scope specification (A::B), possibly with many
 558      levels of namespaces or classes (A::B::C::D).
 559
 560      Some versions of the HP ANSI C++ compiler (as also possibly
 561      other compilers) generate class/function/member names with
 562      embedded double-colons if they are inside namespaces. To
 563      handle this, we loop a few times, considering larger and
 564      larger prefixes of the string as though they were single
 565      symbols.  So, if the initially supplied string is
 566      A::B::C::D::foo, we have to look up "A", then "A::B",
 567      then "A::B::C", then "A::B::C::D", and finally
 568      "A::B::C::D::foo" as single, monolithic symbols, because
 569      A, B, C or D may be namespaces.
 570
 571      Note that namespaces can nest only inside other
 572      namespaces, and not inside classes.  So we need only
 573      consider *prefixes* of the string; there is no need to look up
 574      "B::C" separately as a symbol in the previous example. */
 575
 576   char *p;
 577   char *start, *end;
 578   char *prefix = NULL;
 579   char *tmp;
 580   struct symbol *sym_class = NULL;
 581   struct symbol *sym_var = NULL;
 582   struct type *t;
 583   int prefix_len = 0;
 584   int done = 0;
 585   char *q;
 586
 587   /* Check for HP-compiled executable -- in other cases
 588      return NULL, and caller must default to standard GDB
 589      behaviour. */
 590
 591   if (!deprecated_hp_som_som_object_present)
 592     return (struct symbol *) NULL;
 593
 594   p = name;
 595
 596   /* Skip over whitespace and possible global "::" */
 597   while (*p && (*p == ' ' || *p == '\t'))
 598     p++;
 599   if (p[0] == ':' && p[1] == ':')
 600     p += 2;
 601   while (*p && (*p == ' ' || *p == '\t'))
 602     p++;
 603
 604   while (1)
 605     {
 606       /* Get to the end of the next namespace or class spec. */
 607       /* If we're looking at some non-token, fail immediately */
 608       start = p;
 609       if (!(isalpha (*p) || *p == '$' || *p == '_'))
 610         return (struct symbol *) NULL;
 611       p++;
 612       while (*p && (isalnum (*p) || *p == '$' || *p == '_'))
 613         p++;
 614
 615       if (*p == '<')
 616         {
 617           /* If we have the start of a template specification,
 618              scan right ahead to its end */
 619           q = find_template_name_end (p);
 620           if (q)
 621             p = q;
 622         }
 623
 624       end = p;
 625
 626       /* Skip over "::" and whitespace for next time around */
 627       while (*p && (*p == ' ' || *p == '\t'))
 628         p++;
 629       if (p[0] == ':' && p[1] == ':')
 630         p += 2;
 631       while (*p && (*p == ' ' || *p == '\t'))
 632         p++;
 633
 634       /* Done with tokens? */
 635       if (!*p || !(isalpha (*p) || *p == '$' || *p == '_'))
 636         done = 1;
 637
 638       tmp = (char *) alloca (prefix_len + end - start + 3);
 639       if (prefix)
 640         {
 641           memcpy (tmp, prefix, prefix_len);
 642           memcpy (tmp + prefix_len, coloncolon, 2);
 643           memcpy (tmp + prefix_len + 2, start, end - start);
 644           tmp[prefix_len + 2 + end - start] = '\000';
 645         }
 646       else
 647         {
 648           memcpy (tmp, start, end - start);
 649           tmp[end - start] = '\000';
 650         }
 651
 652       prefix = tmp;
 653       prefix_len = strlen (prefix);
 654
 655       /* See if the prefix we have now is something we know about */
 656
 657       if (!done)
 658         {
 659           /* More tokens to process, so this must be a class/namespace */
 660           sym_class = lookup_symbol (prefix, 0, STRUCT_DOMAIN,
 661                                      0, (struct symtab **) NULL);
 662         }
 663       else
 664         {
 665           /* No more tokens, so try as a variable first */
 666           sym_var = lookup_symbol (prefix, 0, VAR_DOMAIN,
 667                                    0, (struct symtab **) NULL);
 668           /* If failed, try as class/namespace */
 669           if (!sym_var)
 670             sym_class = lookup_symbol (prefix, 0, STRUCT_DOMAIN,
 671                                        0, (struct symtab **) NULL);
 672         }
 673
 674       if (sym_var ||
 675           (sym_class &&
 676            (t = check_typedef (SYMBOL_TYPE (sym_class)),
 677             (TYPE_CODE (t) == TYPE_CODE_STRUCT
 678              || TYPE_CODE (t) == TYPE_CODE_UNION))))
 679         {
 680           /* We found a valid token */
 681           *token = (char *) xmalloc (prefix_len + 1);
 682           memcpy (*token, prefix, prefix_len);
 683           (*token)[prefix_len] = '\000';
 684           break;
 685         }
 686
 687       /* No variable or class/namespace found, no more tokens */
 688       if (done)
 689         return (struct symbol *) NULL;
 690     }
 691
 692   /* Out of loop, so we must have found a valid token */
 693   if (sym_var)
 694     *class_prefix = 0;
 695   else
 696     *class_prefix = 1;
 697
 698   if (argptr)
 699     *argptr = done ? p : end;
 700
 701   return sym_var ? sym_var : sym_class;         /* found */
 702 }
 703
 704 char *
 705 find_template_name_end (char *p)
 706 {
 707   int depth = 1;
 708   int just_seen_right = 0;
 709   int just_seen_colon = 0;
 710   int just_seen_space = 0;
 711
 712   if (!p || (*p != '<'))
 713     return 0;
 714
 715   while (*++p)
 716     {
 717       switch (*p)
 718         {
 719         case '\'':
 720         case '\"':
 721         case '{':
 722         case '}':
 723           /* In future, may want to allow these?? */
 724           return 0;
 725         case '<':
 726           depth++;              /* start nested template */
 727           if (just_seen_colon || just_seen_right || just_seen_space)
 728             return 0;           /* but not after : or :: or > or space */
 729           break;
 730         case '>':
 731           if (just_seen_colon || just_seen_right)
 732             return 0;           /* end a (nested?) template */
 733           just_seen_right = 1;  /* but not after : or :: */
 734           if (--depth == 0)     /* also disallow >>, insist on > > */
 735             return ++p;         /* if outermost ended, return */
 736           break;
 737         case ':':
 738           if (just_seen_space || (just_seen_colon > 1))
 739             return 0;           /* nested class spec coming up */
 740           just_seen_colon++;    /* we allow :: but not :::: */
 741           break;
 742         case ' ':
 743           break;
 744         default:
 745           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
 746                 (*p >= 'A' && *p <= 'Z') ||
 747                 (*p >= '0' && *p <= '9') ||
 748                 (*p == '_') || (*p == ',') ||   /* commas for template args */
 749                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
 750                 (*p == '(') || (*p == ')') ||   /* function types */
 751                 (*p == '[') || (*p == ']')))    /* array types */
 752             return 0;
 753         }
 754       if (*p != ' ')
 755         just_seen_space = 0;
 756       if (*p != ':')
 757         just_seen_colon = 0;
 758       if (*p != '>')
 759         just_seen_right = 0;
 760     }
 761   return 0;
 762 }
 763 \f
 764
 765
 766 /* Return a null-terminated temporary copy of the name
 767    of a string token.  */
 768
 769 char *
 770 copy_name (struct stoken token)
 771 {
 772   /* Make sure there's enough space for the token.  */
 773   if (namecopy_size < token.length + 1)
 774     {
 775       namecopy_size = token.length + 1;
 776       namecopy = xrealloc (namecopy, token.length + 1);
 777     }
 778
 779   memcpy (namecopy, token.ptr, token.length);
 780   namecopy[token.length] = 0;
 781
 782   return namecopy;
 783 }
 784 \f
 785 /* Reverse an expression from suffix form (in which it is constructed)
 786    to prefix form (in which we can conveniently print or execute it).  */
 787
 788 static void
 789 prefixify_expression (struct expression *expr)
 790 {
 791   int len =
 792   sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
 793   struct expression *temp;
 794   int inpos = expr->nelts, outpos = 0;
 795
 796   temp = (struct expression *) alloca (len);
 797
 798   /* Copy the original expression into temp.  */
 799   memcpy (temp, expr, len);
 800
 801   prefixify_subexp (temp, expr, inpos, outpos);
 802 }
 803
 804 /* Return the number of exp_elements in the postfix subexpression
 805    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
 806
 807 int
 808 length_of_subexp (struct expression *expr, int endpos)
 809 {
 810   int oplen, args, i;
 811
 812   operator_length (expr, endpos, &oplen, &args);
 813
 814   while (args > 0)
 815     {
 816       oplen += length_of_subexp (expr, endpos - oplen);
 817       args--;
 818     }
 819
 820   return oplen;
 821 }
 822
 823 /* Sets *OPLENP to the length of the operator whose (last) index is
 824    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
 825    operator takes.  */
 826
 827 void
 828 operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp)
 829 {
 830   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
 831                                                      oplenp, argsp);
 832 }
 833
 834 /* Default value for operator_length in exp_descriptor vectors.  */
 835
 836 void
 837 operator_length_standard (struct expression *expr, int endpos,
 838                           int *oplenp, int *argsp)
 839 {
 840   int oplen = 1;
 841   int args = 0;
 842   enum f90_range_type range_type;
 843   int i;
 844
 845   if (endpos < 1)
 846     error (_("?error in operator_length_standard"));
 847
 848   i = (int) expr->elts[endpos - 1].opcode;
 849
 850   switch (i)
 851     {
 852       /* C++  */
 853     case OP_SCOPE:
 854       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 855       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
 856       break;
 857
 858     case OP_LONG:
 859     case OP_DOUBLE:
 860     case OP_VAR_VALUE:
 861       oplen = 4;
 862       break;
 863
 864     case OP_TYPE:
 865     case OP_BOOL:
 866     case OP_LAST:
 867     case OP_REGISTER:
 868     case OP_INTERNALVAR:
 869       oplen = 3;
 870       break;
 871
 872     case OP_COMPLEX:
 873       oplen = 1;
 874       args = 2;
 875       break;
 876
 877     case OP_FUNCALL:
 878     case OP_F77_UNDETERMINED_ARGLIST:
 879       oplen = 3;
 880       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 881       break;
 882
 883     case OP_OBJC_MSGCALL:       /* Objective C message (method) call */
 884       oplen = 4;
 885       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 886       break;
 887
 888     case UNOP_MAX:
 889     case UNOP_MIN:
 890       oplen = 3;
 891       break;
 892
 893     case BINOP_VAL:
 894     case UNOP_CAST:
 895     case UNOP_MEMVAL:
 896       oplen = 3;
 897       args = 1;
 898       break;
 899
 900     case UNOP_ABS:
 901     case UNOP_CAP:
 902     case UNOP_CHR:
 903     case UNOP_FLOAT:
 904     case UNOP_HIGH:
 905     case UNOP_ODD:
 906     case UNOP_ORD:
 907     case UNOP_TRUNC:
 908       oplen = 1;
 909       args = 1;
 910       break;
 911
 912     case OP_LABELED:
 913     case STRUCTOP_STRUCT:
 914     case STRUCTOP_PTR:
 915       args = 1;
 916       /* fall through */
 917     case OP_M2_STRING:
 918     case OP_STRING:
 919     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class NSString constant */
 920     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op */
 921     case OP_NAME:
 922     case OP_EXPRSTRING:
 923       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 924       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
 925       break;
 926
 927     case OP_BITSTRING:
 928       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
 929       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 930       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
 931       break;
 932
 933     case OP_ARRAY:
 934       oplen = 4;
 935       args = longest_to_int (expr->elts[endpos - 2].longconst);
 936       args -= longest_to_int (expr->elts[endpos - 3].longconst);
 937       args += 1;
 938       break;
 939
 940     case TERNOP_COND:
 941     case TERNOP_SLICE:
 942     case TERNOP_SLICE_COUNT:
 943       args = 3;
 944       break;
 945
 946       /* Modula-2 */
 947     case MULTI_SUBSCRIPT:
 948       oplen = 3;
 949       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
 950       break;
 951
 952     case BINOP_ASSIGN_MODIFY:
 953       oplen = 3;
 954       args = 2;
 955       break;
 956
 957       /* C++ */
 958     case OP_THIS:
 959     case OP_OBJC_SELF:
 960       oplen = 2;
 961       break;
 962
 963     case OP_F90_RANGE:
 964       oplen = 3;
 965
 966       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
 967       switch (range_type)
 968         {
 969         case LOW_BOUND_DEFAULT:
 970         case HIGH_BOUND_DEFAULT:
 971           args = 1;
 972           break;
 973         case BOTH_BOUND_DEFAULT:
 974           args = 0;
 975           break;
 976         case NONE_BOUND_DEFAULT:
 977           args = 2;
 978           break;
 979         }
 980
 981       break;
 982
 983     default:
 984       args = 1 + (i < (int) BINOP_END);
 985     }
 986
 987   *oplenp = oplen;
 988   *argsp = args;
 989 }
 990
 991 /* Copy the subexpression ending just before index INEND in INEXPR
 992    into OUTEXPR, starting at index OUTBEG.
 993    In the process, convert it from suffix to prefix form.  */
 994
 995 static void
 996 prefixify_subexp (struct expression *inexpr,
 997                   struct expression *outexpr, int inend, int outbeg)
 998 {
 999   int oplen;
1000   int args;
1001   int i;
1002   int *arglens;
1003   enum exp_opcode opcode;
1004
1005   operator_length (inexpr, inend, &oplen, &args);
1006
1007   /* Copy the final operator itself, from the end of the input
1008      to the beginning of the output.  */
1009   inend -= oplen;
1010   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1011           EXP_ELEM_TO_BYTES (oplen));
1012   outbeg += oplen;
1013
1014   /* Find the lengths of the arg subexpressions.  */
1015   arglens = (int *) alloca (args * sizeof (int));
1016   for (i = args - 1; i >= 0; i--)
1017     {
1018       oplen = length_of_subexp (inexpr, inend);
1019       arglens[i] = oplen;
1020       inend -= oplen;
1021     }
1022
1023   /* Now copy each subexpression, preserving the order of
1024      the subexpressions, but prefixifying each one.
1025      In this loop, inend starts at the beginning of
1026      the expression this level is working on
1027      and marches forward over the arguments.
1028      outbeg does similarly in the output.  */
1029   for (i = 0; i < args; i++)
1030     {
1031       oplen = arglens[i];
1032       inend += oplen;
1033       prefixify_subexp (inexpr, outexpr, inend, outbeg);
1034       outbeg += oplen;
1035     }
1036 }
1037 \f
1038 /* This page contains the two entry points to this file.  */
1039
1040 /* Read an expression from the string *STRINGPTR points to,
1041    parse it, and return a pointer to a  struct expression  that we malloc.
1042    Use block BLOCK as the lexical context for variable names;
1043    if BLOCK is zero, use the block of the selected stack frame.
1044    Meanwhile, advance *STRINGPTR to point after the expression,
1045    at the first nonwhite character that is not part of the expression
1046    (possibly a null character).
1047
1048    If COMMA is nonzero, stop if a comma is reached.  */
1049
1050 struct expression *
1051 parse_exp_1 (char **stringptr, struct block *block, int comma)
1052 {
1053   return parse_exp_in_context (stringptr, block, comma, 0);
1054 }
1055
1056 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1057    no value is expected from the expression.  */
1058
1059 static struct expression *
1060 parse_exp_in_context (char **stringptr, struct block *block, int comma,
1061                       int void_context_p)
1062 {
1063   struct cleanup *old_chain;
1064
1065   lexptr = *stringptr;
1066   prev_lexptr = NULL;
1067
1068   paren_depth = 0;
1069   type_stack_depth = 0;
1070
1071   comma_terminates = comma;
1072
1073   if (lexptr == 0 || *lexptr == 0)
1074     error_no_arg (_("expression to compute"));
1075
1076   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1077   funcall_chain = 0;
1078
1079   /* If no context specified, try using the current frame, if any. */
1080
1081   if (!block)
1082     block = get_selected_block (&expression_context_pc);
1083
1084   /* Fall back to using the current source static context, if any. */
1085
1086   if (!block)
1087     {
1088       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1089       if (cursal.symtab)
1090         block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1091     }
1092
1093   /* Save the context, if specified by caller, or found above. */
1094
1095   if (block)
1096     {
1097       expression_context_block = block;
1098       expression_context_pc = BLOCK_START (block);
1099     }
1100
1101   expout_size = 10;
1102   expout_ptr = 0;
1103   expout = (struct expression *)
1104     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1105   expout->language_defn = current_language;
1106   make_cleanup (free_current_contents, &expout);
1107
1108   if (current_language->la_parser ())
1109     current_language->la_error (NULL);
1110
1111   discard_cleanups (old_chain);
1112
1113   /* Record the actual number of expression elements, and then
1114      reallocate the expression memory so that we free up any
1115      excess elements. */
1116
1117   expout->nelts = expout_ptr;
1118   expout = (struct expression *)
1119     xrealloc ((char *) expout,
1120               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1121
1122   /* Convert expression from postfix form as generated by yacc
1123      parser, to a prefix form. */
1124
1125   if (expressiondebug)
1126     dump_raw_expression (expout, gdb_stdlog,
1127                          "before conversion to prefix form");
1128
1129   prefixify_expression (expout);
1130
1131   current_language->la_post_parser (&expout, void_context_p);
1132
1133   if (expressiondebug)
1134     dump_prefix_expression (expout, gdb_stdlog);
1135
1136   *stringptr = lexptr;
1137   return expout;
1138 }
1139
1140 /* Parse STRING as an expression, and complain if this fails
1141    to use up all of the contents of STRING.  */
1142
1143 struct expression *
1144 parse_expression (char *string)
1145 {
1146   struct expression *exp;
1147   exp = parse_exp_1 (&string, 0, 0);
1148   if (*string)
1149     error (_("Junk after end of expression."));
1150   return exp;
1151 }
1152
1153
1154 /* As for parse_expression, except that if VOID_CONTEXT_P, then
1155    no value is expected from the expression.  */
1156
1157 struct expression *
1158 parse_expression_in_context (char *string, int void_context_p)
1159 {
1160   struct expression *exp;
1161   exp = parse_exp_in_context (&string, 0, 0, void_context_p);
1162   if (*string != '\000')
1163     error (_("Junk after end of expression."));
1164   return exp;
1165 }
1166
1167 /* A post-parser that does nothing */
1168
1169 void
1170 null_post_parser (struct expression **exp, int void_context_p)
1171 {
1172 }
1173 \f
1174 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1175    probably useful for any language which declares its types "backwards".  */
1176
1177 static void
1178 check_type_stack_depth (void)
1179 {
1180   if (type_stack_depth == type_stack_size)
1181     {
1182       type_stack_size *= 2;
1183       type_stack = (union type_stack_elt *)
1184         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1185     }
1186 }
1187
1188 void
1189 push_type (enum type_pieces tp)
1190 {
1191   check_type_stack_depth ();
1192   type_stack[type_stack_depth++].piece = tp;
1193 }
1194
1195 void
1196 push_type_int (int n)
1197 {
1198   check_type_stack_depth ();
1199   type_stack[type_stack_depth++].int_val = n;
1200 }
1201
1202 void
1203 push_type_address_space (char *string)
1204 {
1205   push_type_int (address_space_name_to_int (string));
1206 }
1207
1208 enum type_pieces
1209 pop_type (void)
1210 {
1211   if (type_stack_depth)
1212     return type_stack[--type_stack_depth].piece;
1213   return tp_end;
1214 }
1215
1216 int
1217 pop_type_int (void)
1218 {
1219   if (type_stack_depth)
1220     return type_stack[--type_stack_depth].int_val;
1221   /* "Can't happen".  */
1222   return 0;
1223 }
1224
1225 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1226    as modified by all the stuff on the stack.  */
1227 struct type *
1228 follow_types (struct type *follow_type)
1229 {
1230   int done = 0;
1231   int make_const = 0;
1232   int make_volatile = 0;
1233   int make_addr_space = 0;
1234   int array_size;
1235   struct type *range_type;
1236
1237   while (!done)
1238     switch (pop_type ())
1239       {
1240       case tp_end:
1241         done = 1;
1242         if (make_const)
1243           follow_type = make_cv_type (make_const,
1244                                       TYPE_VOLATILE (follow_type),
1245                                       follow_type, 0);
1246         if (make_volatile)
1247           follow_type = make_cv_type (TYPE_CONST (follow_type),
1248                                       make_volatile,
1249                                       follow_type, 0);
1250         if (make_addr_space)
1251           follow_type = make_type_with_address_space (follow_type,
1252                                                       make_addr_space);
1253         make_const = make_volatile = 0;
1254         make_addr_space = 0;
1255         break;
1256       case tp_const:
1257         make_const = 1;
1258         break;
1259       case tp_volatile:
1260         make_volatile = 1;
1261         break;
1262       case tp_space_identifier:
1263         make_addr_space = pop_type_int ();
1264         break;
1265       case tp_pointer:
1266         follow_type = lookup_pointer_type (follow_type);
1267         if (make_const)
1268           follow_type = make_cv_type (make_const,
1269                                       TYPE_VOLATILE (follow_type),
1270                                       follow_type, 0);
1271         if (make_volatile)
1272           follow_type = make_cv_type (TYPE_CONST (follow_type),
1273                                       make_volatile,
1274                                       follow_type, 0);
1275         if (make_addr_space)
1276           follow_type = make_type_with_address_space (follow_type,
1277                                                       make_addr_space);
1278         make_const = make_volatile = 0;
1279         make_addr_space = 0;
1280         break;
1281       case tp_reference:
1282         follow_type = lookup_reference_type (follow_type);
1283         if (make_const)
1284           follow_type = make_cv_type (make_const,
1285                                       TYPE_VOLATILE (follow_type),
1286                                       follow_type, 0);
1287         if (make_volatile)
1288           follow_type = make_cv_type (TYPE_CONST (follow_type),
1289                                       make_volatile,
1290                                       follow_type, 0);
1291         if (make_addr_space)
1292           follow_type = make_type_with_address_space (follow_type,
1293                                                       make_addr_space);
1294         make_const = make_volatile = 0;
1295         make_addr_space = 0;
1296         break;
1297       case tp_array:
1298         array_size = pop_type_int ();
1299         /* FIXME-type-allocation: need a way to free this type when we are
1300            done with it.  */
1301         range_type =
1302           create_range_type ((struct type *) NULL,
1303                              builtin_type_int, 0,
1304                              array_size >= 0 ? array_size - 1 : 0);
1305         follow_type =
1306           create_array_type ((struct type *) NULL,
1307                              follow_type, range_type);
1308         if (array_size < 0)
1309           TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1310             = BOUND_CANNOT_BE_DETERMINED;
1311         break;
1312       case tp_function:
1313         /* FIXME-type-allocation: need a way to free this type when we are
1314            done with it.  */
1315         follow_type = lookup_function_type (follow_type);
1316         break;
1317       }
1318   return follow_type;
1319 }
1320 \f
1321 static void build_parse (void);
1322 static void
1323 build_parse (void)
1324 {
1325   int i;
1326
1327   msym_text_symbol_type =
1328     init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
1329   TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
1330   msym_data_symbol_type =
1331     init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1332                "<data variable, no debug info>", NULL);
1333   msym_unknown_symbol_type =
1334     init_type (TYPE_CODE_INT, 1, 0,
1335                "<variable (not text or data), no debug info>",
1336                NULL);
1337 }
1338
1339 /* This function avoids direct calls to fprintf
1340    in the parser generated debug code.  */
1341 void
1342 parser_fprintf (FILE *x, const char *y, ...)
1343 {
1344   va_list args;
1345   va_start (args, y);
1346   if (x == stderr)
1347     vfprintf_unfiltered (gdb_stderr, y, args);
1348   else
1349     {
1350       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1351       vfprintf_unfiltered (gdb_stderr, y, args);
1352     }
1353   va_end (args);
1354 }
1355
1356 void
1357 _initialize_parse (void)
1358 {
1359   type_stack_size = 80;
1360   type_stack_depth = 0;
1361   type_stack = (union type_stack_elt *)
1362     xmalloc (type_stack_size * sizeof (*type_stack));
1363
1364   build_parse ();
1365
1366   /* FIXME - For the moment, handle types by swapping them in and out.
1367      Should be using the per-architecture data-pointer and a large
1368      struct. */
1369   DEPRECATED_REGISTER_GDBARCH_SWAP (msym_text_symbol_type);
1370   DEPRECATED_REGISTER_GDBARCH_SWAP (msym_data_symbol_type);
1371   DEPRECATED_REGISTER_GDBARCH_SWAP (msym_unknown_symbol_type);
1372   deprecated_register_gdbarch_swap (NULL, 0, build_parse);
1373
1374   add_setshow_zinteger_cmd ("expression", class_maintenance,
1375                             &expressiondebug, _("\
1376 Set expression debugging."), _("\
1377 Show expression debugging."), _("\
1378 When non-zero, the internal representation of expressions will be printed."),
1379                             NULL,
1380                             show_expressiondebug,
1381                             &setdebuglist, &showdebuglist);
1382 }