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