gdb/parse.c

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