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