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