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