gdb/parse.c

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