gdb/parse.c

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