contrib/gdb/gdb/parse.c

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