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