URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [VER_5_3/] [gdb-5.3/] [gdb/] [ch-exp.c] - Blame information for rev 1782

Go to most recent revision | Details | Compare with Previous | View Log


// OBSOLETE /* Parser for GNU CHILL (CCITT High-Level Language)  -*- C -*-
// OBSOLETE    Copyright 1992, 1993, 1995, 1996, 1997, 1999, 2000, 2001
// OBSOLETE    Free Software Foundation, Inc.
// OBSOLETE 
// OBSOLETE    This file is part of GDB.
// OBSOLETE 
// OBSOLETE    This program is free software; you can redistribute it and/or modify
// OBSOLETE    it under the terms of the GNU General Public License as published by
// OBSOLETE    the Free Software Foundation; either version 2 of the License, or
// OBSOLETE    (at your option) any later version.
// OBSOLETE 
// OBSOLETE    This program is distributed in the hope that it will be useful,
// OBSOLETE    but WITHOUT ANY WARRANTY; without even the implied warranty of
// OBSOLETE    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// OBSOLETE    GNU General Public License for more details.
// OBSOLETE 
// OBSOLETE    You should have received a copy of the GNU General Public License
// OBSOLETE    along with this program; if not, write to the Free Software
// OBSOLETE    Foundation, Inc., 59 Temple Place - Suite 330,
// OBSOLETE    Boston, MA 02111-1307, USA.  */
// OBSOLETE 
// OBSOLETE /* Parse a Chill expression from text in a string,
// OBSOLETE    and return the result as a  struct expression  pointer.
// OBSOLETE    That structure contains arithmetic operations in reverse polish,
// OBSOLETE    with constants represented by operations that are followed by special data.
// OBSOLETE    See expression.h for the details of the format.
// OBSOLETE    What is important here is that it can be built up sequentially
// OBSOLETE    during the process of parsing; the lower levels of the tree always
// OBSOLETE    come first in the result.
// OBSOLETE 
// OBSOLETE    Note that the language accepted by this parser is more liberal
// OBSOLETE    than the one accepted by an actual Chill compiler.  For example, the
// OBSOLETE    language rule that a simple name string can not be one of the reserved
// OBSOLETE    simple name strings is not enforced (e.g "case" is not treated as a
// OBSOLETE    reserved name).  Another example is that Chill is a strongly typed
// OBSOLETE    language, and certain expressions that violate the type constraints
// OBSOLETE    may still be evaluated if gdb can do so in a meaningful manner, while
// OBSOLETE    such expressions would be rejected by the compiler.  The reason for
// OBSOLETE    this more liberal behavior is the philosophy that the debugger
// OBSOLETE    is intended to be a tool that is used by the programmer when things
// OBSOLETE    go wrong, and as such, it should provide as few artificial barriers
// OBSOLETE    to it's use as possible.  If it can do something meaningful, even
// OBSOLETE    something that violates language contraints that are enforced by the
// OBSOLETE    compiler, it should do so without complaint.
// OBSOLETE 
// OBSOLETE  */
// OBSOLETE 
// OBSOLETE #include "defs.h"
// OBSOLETE #include "gdb_string.h"
// OBSOLETE #include <ctype.h>
// OBSOLETE #include "expression.h"
// OBSOLETE #include "language.h"
// OBSOLETE #include "value.h"
// OBSOLETE #include "parser-defs.h"
// OBSOLETE #include "ch-lang.h"
// OBSOLETE #include "bfd.h"            /* Required by objfiles.h.  */
// OBSOLETE #include "symfile.h"                /* Required by objfiles.h.  */
// OBSOLETE #include "objfiles.h"               /* For have_full_symbols and have_partial_symbols */
// OBSOLETE 
// OBSOLETE #ifdef __GNUC__
// OBSOLETE #define INLINE __inline__
// OBSOLETE #endif
// OBSOLETE 
// OBSOLETE typedef union
// OBSOLETE 
// OBSOLETE   {
// OBSOLETE     LONGEST lval;
// OBSOLETE     ULONGEST ulval;
// OBSOLETE     struct
// OBSOLETE       {
// OBSOLETE     LONGEST val;
// OBSOLETE     struct type *type;
// OBSOLETE       }
// OBSOLETE     typed_val;
// OBSOLETE     double dval;
// OBSOLETE     struct symbol *sym;
// OBSOLETE     struct type *tval;
// OBSOLETE     struct stoken sval;
// OBSOLETE     struct ttype tsym;
// OBSOLETE     struct symtoken ssym;
// OBSOLETE   }
// OBSOLETE YYSTYPE;
// OBSOLETE 
// OBSOLETE enum ch_terminal
// OBSOLETE   {
// OBSOLETE     END_TOKEN = 0,
// OBSOLETE     /* '\001' ... '\xff' come first. */
// OBSOLETE     OPEN_PAREN = '(',
// OBSOLETE     TOKEN_NOT_READ = 999,
// OBSOLETE     INTEGER_LITERAL,
// OBSOLETE     BOOLEAN_LITERAL,
// OBSOLETE     CHARACTER_LITERAL,
// OBSOLETE     FLOAT_LITERAL,
// OBSOLETE     GENERAL_PROCEDURE_NAME,
// OBSOLETE     LOCATION_NAME,
// OBSOLETE     EMPTINESS_LITERAL,
// OBSOLETE     CHARACTER_STRING_LITERAL,
// OBSOLETE     BIT_STRING_LITERAL,
// OBSOLETE     TYPENAME,
// OBSOLETE     DOT_FIELD_NAME,         /* '.' followed by <field name> */
// OBSOLETE     CASE,
// OBSOLETE     OF,
// OBSOLETE     ESAC,
// OBSOLETE     LOGIOR,
// OBSOLETE     ORIF,
// OBSOLETE     LOGXOR,
// OBSOLETE     LOGAND,
// OBSOLETE     ANDIF,
// OBSOLETE     NOTEQUAL,
// OBSOLETE     GEQ,
// OBSOLETE     LEQ,
// OBSOLETE     IN,
// OBSOLETE     SLASH_SLASH,
// OBSOLETE     MOD,
// OBSOLETE     REM,
// OBSOLETE     NOT,
// OBSOLETE     POINTER,
// OBSOLETE     RECEIVE,
// OBSOLETE     UP,
// OBSOLETE     IF,
// OBSOLETE     THEN,
// OBSOLETE     ELSE,
// OBSOLETE     FI,
// OBSOLETE     ELSIF,
// OBSOLETE     ILLEGAL_TOKEN,
// OBSOLETE     NUM,
// OBSOLETE     PRED,
// OBSOLETE     SUCC,
// OBSOLETE     ABS,
// OBSOLETE     CARD,
// OBSOLETE     MAX_TOKEN,
// OBSOLETE     MIN_TOKEN,
// OBSOLETE     ADDR_TOKEN,
// OBSOLETE     SIZE,
// OBSOLETE     UPPER,
// OBSOLETE     LOWER,
// OBSOLETE     LENGTH,
// OBSOLETE     ARRAY,
// OBSOLETE     GDB_VARIABLE,
// OBSOLETE     GDB_ASSIGNMENT
// OBSOLETE   };
// OBSOLETE 
// OBSOLETE /* Forward declarations. */
// OBSOLETE 
// OBSOLETE static void write_lower_upper_value (enum exp_opcode, struct type *);
// OBSOLETE static enum ch_terminal match_bitstring_literal (void);
// OBSOLETE static enum ch_terminal match_integer_literal (void);
// OBSOLETE static enum ch_terminal match_character_literal (void);
// OBSOLETE static enum ch_terminal match_string_literal (void);
// OBSOLETE static enum ch_terminal match_float_literal (void);
// OBSOLETE static int decode_integer_literal (LONGEST *, char **);
// OBSOLETE static int decode_integer_value (int, char **, LONGEST *);
// OBSOLETE static char *match_simple_name_string (void);
// OBSOLETE static void growbuf_by_size (int);
// OBSOLETE static void parse_case_label (void);
// OBSOLETE static void parse_untyped_expr (void);
// OBSOLETE static void parse_if_expression (void);
// OBSOLETE static void parse_if_expression_body (void);
// OBSOLETE static void parse_else_alternative (void);
// OBSOLETE static void parse_then_alternative (void);
// OBSOLETE static void parse_expr (void);
// OBSOLETE static void parse_operand0 (void);
// OBSOLETE static void parse_operand1 (void);
// OBSOLETE static void parse_operand2 (void);
// OBSOLETE static void parse_operand3 (void);
// OBSOLETE static void parse_operand4 (void);
// OBSOLETE static void parse_operand5 (void);
// OBSOLETE static void parse_operand6 (void);
// OBSOLETE static void parse_primval (void);
// OBSOLETE static void parse_tuple (struct type *);
// OBSOLETE static void parse_opt_element_list (struct type *);
// OBSOLETE static void parse_tuple_element (struct type *);
// OBSOLETE static void parse_named_record_element (void);
// OBSOLETE static void parse_call (void);
// OBSOLETE static struct type *parse_mode_or_normal_call (void);
// OBSOLETE #if 0
// OBSOLETE static struct type *parse_mode_call (void);
// OBSOLETE #endif
// OBSOLETE static void parse_unary_call (void);
// OBSOLETE static int parse_opt_untyped_expr (void);
// OBSOLETE static int expect (enum ch_terminal, char *);
// OBSOLETE static enum ch_terminal ch_lex (void);
// OBSOLETE INLINE static enum ch_terminal PEEK_TOKEN (void);
// OBSOLETE static enum ch_terminal peek_token_ (int);
// OBSOLETE static void forward_token_ (void);
// OBSOLETE static void require (enum ch_terminal);
// OBSOLETE static int check_token (enum ch_terminal);
// OBSOLETE 
// OBSOLETE #define MAX_LOOK_AHEAD 2
// OBSOLETE static enum ch_terminal terminal_buffer[MAX_LOOK_AHEAD + 1] =
// OBSOLETE {
// OBSOLETE   TOKEN_NOT_READ, TOKEN_NOT_READ, TOKEN_NOT_READ};
// OBSOLETE static YYSTYPE yylval;
// OBSOLETE static YYSTYPE val_buffer[MAX_LOOK_AHEAD + 1];
// OBSOLETE 
// OBSOLETE /*int current_token, lookahead_token; */
// OBSOLETE 
// OBSOLETE INLINE static enum ch_terminal
// OBSOLETE PEEK_TOKEN (void)
// OBSOLETE {
// OBSOLETE   if (terminal_buffer[0] == TOKEN_NOT_READ)
// OBSOLETE     {
// OBSOLETE       terminal_buffer[0] = ch_lex ();
// OBSOLETE       val_buffer[0] = yylval;
// OBSOLETE     }
// OBSOLETE   return terminal_buffer[0];
// OBSOLETE }
// OBSOLETE #define PEEK_LVAL() val_buffer[0]
// OBSOLETE #define PEEK_TOKEN1() peek_token_(1)
// OBSOLETE #define PEEK_TOKEN2() peek_token_(2)
// OBSOLETE static enum ch_terminal
// OBSOLETE peek_token_ (int i)
// OBSOLETE {
// OBSOLETE   if (i > MAX_LOOK_AHEAD)
// OBSOLETE     internal_error (__FILE__, __LINE__,
// OBSOLETE                 "too much lookahead");
// OBSOLETE   if (terminal_buffer[i] == TOKEN_NOT_READ)
// OBSOLETE     {
// OBSOLETE       terminal_buffer[i] = ch_lex ();
// OBSOLETE       val_buffer[i] = yylval;
// OBSOLETE     }
// OBSOLETE   return terminal_buffer[i];
// OBSOLETE }
// OBSOLETE 
// OBSOLETE #if 0
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE pushback_token (enum ch_terminal code, YYSTYPE node)
// OBSOLETE {
// OBSOLETE   int i;
// OBSOLETE   if (terminal_buffer[MAX_LOOK_AHEAD] != TOKEN_NOT_READ)
// OBSOLETE     internal_error (__FILE__, __LINE__,
// OBSOLETE                 "cannot pushback token");
// OBSOLETE   for (i = MAX_LOOK_AHEAD; i > 0; i--)
// OBSOLETE     {
// OBSOLETE       terminal_buffer[i] = terminal_buffer[i - 1];
// OBSOLETE       val_buffer[i] = val_buffer[i - 1];
// OBSOLETE     }
// OBSOLETE   terminal_buffer[0] = code;
// OBSOLETE   val_buffer[0] = node;
// OBSOLETE }
// OBSOLETE 
// OBSOLETE #endif
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE forward_token_ (void)
// OBSOLETE {
// OBSOLETE   int i;
// OBSOLETE   for (i = 0; i < MAX_LOOK_AHEAD; i++)
// OBSOLETE     {
// OBSOLETE       terminal_buffer[i] = terminal_buffer[i + 1];
// OBSOLETE       val_buffer[i] = val_buffer[i + 1];
// OBSOLETE     }
// OBSOLETE   terminal_buffer[MAX_LOOK_AHEAD] = TOKEN_NOT_READ;
// OBSOLETE }
// OBSOLETE #define FORWARD_TOKEN() forward_token_()
// OBSOLETE 
// OBSOLETE /* Skip the next token.
// OBSOLETE    if it isn't TOKEN, the parser is broken. */
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE require (enum ch_terminal token)
// OBSOLETE {
// OBSOLETE   if (PEEK_TOKEN () != token)
// OBSOLETE     {
// OBSOLETE       internal_error (__FILE__, __LINE__,
// OBSOLETE                   "expected token %d", (int) token);
// OBSOLETE     }
// OBSOLETE   FORWARD_TOKEN ();
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static int
// OBSOLETE check_token (enum ch_terminal token)
// OBSOLETE {
// OBSOLETE   if (PEEK_TOKEN () != token)
// OBSOLETE     return 0;
// OBSOLETE   FORWARD_TOKEN ();
// OBSOLETE   return 1;
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* return 0 if expected token was not found,
// OBSOLETE    else return 1.
// OBSOLETE  */
// OBSOLETE static int
// OBSOLETE expect (enum ch_terminal token, char *message)
// OBSOLETE {
// OBSOLETE   if (PEEK_TOKEN () != token)
// OBSOLETE     {
// OBSOLETE       if (message)
// OBSOLETE     error (message);
// OBSOLETE       else if (token < 256)
// OBSOLETE     error ("syntax error - expected a '%c' here \"%s\"", token, lexptr);
// OBSOLETE       else
// OBSOLETE     error ("syntax error");
// OBSOLETE       return 0;
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     FORWARD_TOKEN ();
// OBSOLETE   return 1;
// OBSOLETE }
// OBSOLETE 
// OBSOLETE #if 0
// OBSOLETE /* Parse a name string.  If ALLOW_ALL is 1, ALL is allowed as a postfix. */
// OBSOLETE 
// OBSOLETE static tree
// OBSOLETE parse_opt_name_string (int allow_all)
// OBSOLETE {
// OBSOLETE   int token = PEEK_TOKEN ();
// OBSOLETE   tree name;
// OBSOLETE   if (token != NAME)
// OBSOLETE     {
// OBSOLETE       if (token == ALL && allow_all)
// OBSOLETE     {
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       return ALL_POSTFIX;
// OBSOLETE     }
// OBSOLETE       return NULL_TREE;
// OBSOLETE     }
// OBSOLETE   name = PEEK_LVAL ();
// OBSOLETE   for (;;)
// OBSOLETE     {
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       token = PEEK_TOKEN ();
// OBSOLETE       if (token != '!')
// OBSOLETE     return name;
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       token = PEEK_TOKEN ();
// OBSOLETE       if (token == ALL && allow_all)
// OBSOLETE     return get_identifier3 (IDENTIFIER_POINTER (name), "!", "*");
// OBSOLETE       if (token != NAME)
// OBSOLETE     {
// OBSOLETE       if (pass == 1)
// OBSOLETE         error ("'%s!' is not followed by an identifier",
// OBSOLETE                IDENTIFIER_POINTER (name));
// OBSOLETE       return name;
// OBSOLETE     }
// OBSOLETE       name = get_identifier3 (IDENTIFIER_POINTER (name),
// OBSOLETE                           "!", IDENTIFIER_POINTER (PEEK_LVAL ()));
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static tree
// OBSOLETE parse_simple_name_string (void)
// OBSOLETE {
// OBSOLETE   int token = PEEK_TOKEN ();
// OBSOLETE   tree name;
// OBSOLETE   if (token != NAME)
// OBSOLETE     {
// OBSOLETE       error ("expected a name here");
// OBSOLETE       return error_mark_node;
// OBSOLETE     }
// OBSOLETE   name = PEEK_LVAL ();
// OBSOLETE   FORWARD_TOKEN ();
// OBSOLETE   return name;
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static tree
// OBSOLETE parse_name_string (void)
// OBSOLETE {
// OBSOLETE   tree name = parse_opt_name_string (0);
// OBSOLETE   if (name)
// OBSOLETE     return name;
// OBSOLETE   if (pass == 1)
// OBSOLETE     error ("expected a name string here");
// OBSOLETE   return error_mark_node;
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Matches: <name_string>
// OBSOLETE    Returns if pass 1: the identifier.
// OBSOLETE    Returns if pass 2: a decl or value for identifier. */
// OBSOLETE 
// OBSOLETE static tree
// OBSOLETE parse_name (void)
// OBSOLETE {
// OBSOLETE   tree name = parse_name_string ();
// OBSOLETE   if (pass == 1 || ignoring)
// OBSOLETE     return name;
// OBSOLETE   else
// OBSOLETE     {
// OBSOLETE       tree decl = lookup_name (name);
// OBSOLETE       if (decl == NULL_TREE)
// OBSOLETE     {
// OBSOLETE       error ("`%s' undeclared", IDENTIFIER_POINTER (name));
// OBSOLETE       return error_mark_node;
// OBSOLETE     }
// OBSOLETE       else if (TREE_CODE (TREE_TYPE (decl)) == ERROR_MARK)
// OBSOLETE     return error_mark_node;
// OBSOLETE       else if (TREE_CODE (decl) == CONST_DECL)
// OBSOLETE     return DECL_INITIAL (decl);
// OBSOLETE       else if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
// OBSOLETE     return convert_from_reference (decl);
// OBSOLETE       else
// OBSOLETE     return decl;
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE #endif
// OBSOLETE 
// OBSOLETE #if 0
// OBSOLETE static void
// OBSOLETE pushback_paren_expr (tree expr)
// OBSOLETE {
// OBSOLETE   if (pass == 1 && !ignoring)
// OBSOLETE     expr = build1 (PAREN_EXPR, NULL_TREE, expr);
// OBSOLETE   pushback_token (EXPR, expr);
// OBSOLETE }
// OBSOLETE #endif
// OBSOLETE 
// OBSOLETE /* Matches: <case label> */
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_case_label (void)
// OBSOLETE {
// OBSOLETE   if (check_token (ELSE))
// OBSOLETE     error ("ELSE in tuples labels not implemented");
// OBSOLETE   /* Does not handle the case of a mode name.  FIXME */
// OBSOLETE   parse_expr ();
// OBSOLETE   if (check_token (':'))
// OBSOLETE     {
// OBSOLETE       parse_expr ();
// OBSOLETE       write_exp_elt_opcode (BINOP_RANGE);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static int
// OBSOLETE parse_opt_untyped_expr (void)
// OBSOLETE {
// OBSOLETE   switch (PEEK_TOKEN ())
// OBSOLETE     {
// OBSOLETE     case ',':
// OBSOLETE     case ':':
// OBSOLETE     case ')':
// OBSOLETE       return 0;
// OBSOLETE     default:
// OBSOLETE       parse_untyped_expr ();
// OBSOLETE       return 1;
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_unary_call (void)
// OBSOLETE {
// OBSOLETE   FORWARD_TOKEN ();
// OBSOLETE   expect ('(', NULL);
// OBSOLETE   parse_expr ();
// OBSOLETE   expect (')', NULL);
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Parse NAME '(' MODENAME ')'. */
// OBSOLETE 
// OBSOLETE #if 0
// OBSOLETE 
// OBSOLETE static struct type *
// OBSOLETE parse_mode_call (void)
// OBSOLETE {
// OBSOLETE   struct type *type;
// OBSOLETE   FORWARD_TOKEN ();
// OBSOLETE   expect ('(', NULL);
// OBSOLETE   if (PEEK_TOKEN () != TYPENAME)
// OBSOLETE     error ("expect MODENAME here `%s'", lexptr);
// OBSOLETE   type = PEEK_LVAL ().tsym.type;
// OBSOLETE   FORWARD_TOKEN ();
// OBSOLETE   expect (')', NULL);
// OBSOLETE   return type;
// OBSOLETE }
// OBSOLETE 
// OBSOLETE #endif
// OBSOLETE 
// OBSOLETE static struct type *
// OBSOLETE parse_mode_or_normal_call (void)
// OBSOLETE {
// OBSOLETE   struct type *type;
// OBSOLETE   FORWARD_TOKEN ();
// OBSOLETE   expect ('(', NULL);
// OBSOLETE   if (PEEK_TOKEN () == TYPENAME)
// OBSOLETE     {
// OBSOLETE       type = PEEK_LVAL ().tsym.type;
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     {
// OBSOLETE       parse_expr ();
// OBSOLETE       type = NULL;
// OBSOLETE     }
// OBSOLETE   expect (')', NULL);
// OBSOLETE   return type;
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Parse something that looks like a function call.
// OBSOLETE    Assume we have parsed the function, and are at the '('. */
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_call (void)
// OBSOLETE {
// OBSOLETE   int arg_count;
// OBSOLETE   require ('(');
// OBSOLETE   /* This is to save the value of arglist_len
// OBSOLETE      being accumulated for each dimension. */
// OBSOLETE   start_arglist ();
// OBSOLETE   if (parse_opt_untyped_expr ())
// OBSOLETE     {
// OBSOLETE       int tok = PEEK_TOKEN ();
// OBSOLETE       arglist_len = 1;
// OBSOLETE       if (tok == UP || tok == ':')
// OBSOLETE     {
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       parse_expr ();
// OBSOLETE       expect (')', "expected ')' to terminate slice");
// OBSOLETE       end_arglist ();
// OBSOLETE       write_exp_elt_opcode (tok == UP ? TERNOP_SLICE_COUNT
// OBSOLETE                             : TERNOP_SLICE);
// OBSOLETE       return;
// OBSOLETE     }
// OBSOLETE       while (check_token (','))
// OBSOLETE     {
// OBSOLETE       parse_untyped_expr ();
// OBSOLETE       arglist_len++;
// OBSOLETE     }
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     arglist_len = 0;
// OBSOLETE   expect (')', NULL);
// OBSOLETE   arg_count = end_arglist ();
// OBSOLETE   write_exp_elt_opcode (MULTI_SUBSCRIPT);
// OBSOLETE   write_exp_elt_longcst (arg_count);
// OBSOLETE   write_exp_elt_opcode (MULTI_SUBSCRIPT);
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_named_record_element (void)
// OBSOLETE {
// OBSOLETE   struct stoken label;
// OBSOLETE   char buf[256];
// OBSOLETE 
// OBSOLETE   label = PEEK_LVAL ().sval;
// OBSOLETE   sprintf (buf, "expected a field name here `%s'", lexptr);
// OBSOLETE   expect (DOT_FIELD_NAME, buf);
// OBSOLETE   if (check_token (','))
// OBSOLETE     parse_named_record_element ();
// OBSOLETE   else if (check_token (':'))
// OBSOLETE     parse_expr ();
// OBSOLETE   else
// OBSOLETE     error ("syntax error near `%s' in named record tuple element", lexptr);
// OBSOLETE   write_exp_elt_opcode (OP_LABELED);
// OBSOLETE   write_exp_string (label);
// OBSOLETE   write_exp_elt_opcode (OP_LABELED);
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Returns one or more TREE_LIST nodes, in reverse order. */
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_tuple_element (struct type *type)
// OBSOLETE {
// OBSOLETE   if (PEEK_TOKEN () == DOT_FIELD_NAME)
// OBSOLETE     {
// OBSOLETE       /* Parse a labelled structure tuple. */
// OBSOLETE       parse_named_record_element ();
// OBSOLETE       return;
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   if (check_token ('('))
// OBSOLETE     {
// OBSOLETE       if (check_token ('*'))
// OBSOLETE     {
// OBSOLETE       expect (')', "missing ')' after '*' case label list");
// OBSOLETE       if (type)
// OBSOLETE         {
// OBSOLETE           if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
// OBSOLETE             {
// OBSOLETE               /* do this as a range from low to high */
// OBSOLETE               struct type *range_type = TYPE_FIELD_TYPE (type, 0);
// OBSOLETE               LONGEST low_bound, high_bound;
// OBSOLETE               if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
// OBSOLETE                 error ("cannot determine bounds for (*)");
// OBSOLETE               /* lower bound */
// OBSOLETE               write_exp_elt_opcode (OP_LONG);
// OBSOLETE               write_exp_elt_type (range_type);
// OBSOLETE               write_exp_elt_longcst (low_bound);
// OBSOLETE               write_exp_elt_opcode (OP_LONG);
// OBSOLETE               /* upper bound */
// OBSOLETE               write_exp_elt_opcode (OP_LONG);
// OBSOLETE               write_exp_elt_type (range_type);
// OBSOLETE               write_exp_elt_longcst (high_bound);
// OBSOLETE               write_exp_elt_opcode (OP_LONG);
// OBSOLETE               write_exp_elt_opcode (BINOP_RANGE);
// OBSOLETE             }
// OBSOLETE           else
// OBSOLETE             error ("(*) in invalid context");
// OBSOLETE         }
// OBSOLETE       else
// OBSOLETE         error ("(*) only possible with modename in front of tuple (mode[..])");
// OBSOLETE     }
// OBSOLETE       else
// OBSOLETE     {
// OBSOLETE       parse_case_label ();
// OBSOLETE       while (check_token (','))
// OBSOLETE         {
// OBSOLETE           parse_case_label ();
// OBSOLETE           write_exp_elt_opcode (BINOP_COMMA);
// OBSOLETE         }
// OBSOLETE       expect (')', NULL);
// OBSOLETE     }
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     parse_untyped_expr ();
// OBSOLETE   if (check_token (':'))
// OBSOLETE     {
// OBSOLETE       /* A powerset range or a labeled Array. */
// OBSOLETE       parse_untyped_expr ();
// OBSOLETE       write_exp_elt_opcode (BINOP_RANGE);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Matches:  a COMMA-separated list of tuple elements.
// OBSOLETE    Returns a list (of TREE_LIST nodes). */
// OBSOLETE static void
// OBSOLETE parse_opt_element_list (struct type *type)
// OBSOLETE {
// OBSOLETE   arglist_len = 0;
// OBSOLETE   if (PEEK_TOKEN () == ']')
// OBSOLETE     return;
// OBSOLETE   for (;;)
// OBSOLETE     {
// OBSOLETE       parse_tuple_element (type);
// OBSOLETE       arglist_len++;
// OBSOLETE       if (PEEK_TOKEN () == ']')
// OBSOLETE     break;
// OBSOLETE       if (!check_token (','))
// OBSOLETE     error ("bad syntax in tuple");
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Parses: '[' elements ']'
// OBSOLETE    If modename is non-NULL it prefixed the tuple.  */
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_tuple (struct type *mode)
// OBSOLETE {
// OBSOLETE   struct type *type;
// OBSOLETE   if (mode)
// OBSOLETE     type = check_typedef (mode);
// OBSOLETE   else
// OBSOLETE     type = 0;
// OBSOLETE   require ('[');
// OBSOLETE   start_arglist ();
// OBSOLETE   parse_opt_element_list (type);
// OBSOLETE   expect (']', "missing ']' after tuple");
// OBSOLETE   write_exp_elt_opcode (OP_ARRAY);
// OBSOLETE   write_exp_elt_longcst ((LONGEST) 0);
// OBSOLETE   write_exp_elt_longcst ((LONGEST) end_arglist () - 1);
// OBSOLETE   write_exp_elt_opcode (OP_ARRAY);
// OBSOLETE   if (type)
// OBSOLETE     {
// OBSOLETE       if (TYPE_CODE (type) != TYPE_CODE_ARRAY
// OBSOLETE       && TYPE_CODE (type) != TYPE_CODE_STRUCT
// OBSOLETE       && TYPE_CODE (type) != TYPE_CODE_SET)
// OBSOLETE     error ("invalid tuple mode");
// OBSOLETE       write_exp_elt_opcode (UNOP_CAST);
// OBSOLETE       write_exp_elt_type (mode);
// OBSOLETE       write_exp_elt_opcode (UNOP_CAST);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_primval (void)
// OBSOLETE {
// OBSOLETE   struct type *type;
// OBSOLETE   enum exp_opcode op;
// OBSOLETE   char *op_name;
// OBSOLETE   switch (PEEK_TOKEN ())
// OBSOLETE     {
// OBSOLETE     case INTEGER_LITERAL:
// OBSOLETE     case CHARACTER_LITERAL:
// OBSOLETE       write_exp_elt_opcode (OP_LONG);
// OBSOLETE       write_exp_elt_type (PEEK_LVAL ().typed_val.type);
// OBSOLETE       write_exp_elt_longcst (PEEK_LVAL ().typed_val.val);
// OBSOLETE       write_exp_elt_opcode (OP_LONG);
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       break;
// OBSOLETE     case BOOLEAN_LITERAL:
// OBSOLETE       write_exp_elt_opcode (OP_BOOL);
// OBSOLETE       write_exp_elt_longcst ((LONGEST) PEEK_LVAL ().ulval);
// OBSOLETE       write_exp_elt_opcode (OP_BOOL);
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       break;
// OBSOLETE     case FLOAT_LITERAL:
// OBSOLETE       write_exp_elt_opcode (OP_DOUBLE);
// OBSOLETE       write_exp_elt_type (builtin_type_double);
// OBSOLETE       write_exp_elt_dblcst (PEEK_LVAL ().dval);
// OBSOLETE       write_exp_elt_opcode (OP_DOUBLE);
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       break;
// OBSOLETE     case EMPTINESS_LITERAL:
// OBSOLETE       write_exp_elt_opcode (OP_LONG);
// OBSOLETE       write_exp_elt_type (lookup_pointer_type (builtin_type_void));
// OBSOLETE       write_exp_elt_longcst (0);
// OBSOLETE       write_exp_elt_opcode (OP_LONG);
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       break;
// OBSOLETE     case CHARACTER_STRING_LITERAL:
// OBSOLETE       write_exp_elt_opcode (OP_STRING);
// OBSOLETE       write_exp_string (PEEK_LVAL ().sval);
// OBSOLETE       write_exp_elt_opcode (OP_STRING);
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       break;
// OBSOLETE     case BIT_STRING_LITERAL:
// OBSOLETE       write_exp_elt_opcode (OP_BITSTRING);
// OBSOLETE       write_exp_bitstring (PEEK_LVAL ().sval);
// OBSOLETE       write_exp_elt_opcode (OP_BITSTRING);
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       break;
// OBSOLETE     case ARRAY:
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       /* This is pseudo-Chill, similar to C's '(TYPE[])EXPR'
// OBSOLETE          which casts to an artificial array. */
// OBSOLETE       expect ('(', NULL);
// OBSOLETE       expect (')', NULL);
// OBSOLETE       if (PEEK_TOKEN () != TYPENAME)
// OBSOLETE     error ("missing MODENAME after ARRAY()");
// OBSOLETE       type = PEEK_LVAL ().tsym.type;
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       expect ('(', NULL);
// OBSOLETE       parse_expr ();
// OBSOLETE       expect (')', "missing right parenthesis");
// OBSOLETE       type = create_array_type ((struct type *) NULL, type,
// OBSOLETE                             create_range_type ((struct type *) NULL,
// OBSOLETE                                                builtin_type_int, 0, 0));
// OBSOLETE       TYPE_ARRAY_UPPER_BOUND_TYPE (type) = BOUND_CANNOT_BE_DETERMINED;
// OBSOLETE       write_exp_elt_opcode (UNOP_CAST);
// OBSOLETE       write_exp_elt_type (type);
// OBSOLETE       write_exp_elt_opcode (UNOP_CAST);
// OBSOLETE       break;
// OBSOLETE #if 0
// OBSOLETE     case CONST:
// OBSOLETE     case EXPR:
// OBSOLETE       val = PEEK_LVAL ();
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       break;
// OBSOLETE #endif
// OBSOLETE     case '(':
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       parse_expr ();
// OBSOLETE       expect (')', "missing right parenthesis");
// OBSOLETE       break;
// OBSOLETE     case '[':
// OBSOLETE       parse_tuple (NULL);
// OBSOLETE       break;
// OBSOLETE     case GENERAL_PROCEDURE_NAME:
// OBSOLETE     case LOCATION_NAME:
// OBSOLETE       write_exp_elt_opcode (OP_VAR_VALUE);
// OBSOLETE       write_exp_elt_block (NULL);
// OBSOLETE       write_exp_elt_sym (PEEK_LVAL ().ssym.sym);
// OBSOLETE       write_exp_elt_opcode (OP_VAR_VALUE);
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       break;
// OBSOLETE     case GDB_VARIABLE:              /* gdb specific */
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       break;
// OBSOLETE     case NUM:
// OBSOLETE       parse_unary_call ();
// OBSOLETE       write_exp_elt_opcode (UNOP_CAST);
// OBSOLETE       write_exp_elt_type (builtin_type_int);
// OBSOLETE       write_exp_elt_opcode (UNOP_CAST);
// OBSOLETE       break;
// OBSOLETE     case CARD:
// OBSOLETE       parse_unary_call ();
// OBSOLETE       write_exp_elt_opcode (UNOP_CARD);
// OBSOLETE       break;
// OBSOLETE     case MAX_TOKEN:
// OBSOLETE       parse_unary_call ();
// OBSOLETE       write_exp_elt_opcode (UNOP_CHMAX);
// OBSOLETE       break;
// OBSOLETE     case MIN_TOKEN:
// OBSOLETE       parse_unary_call ();
// OBSOLETE       write_exp_elt_opcode (UNOP_CHMIN);
// OBSOLETE       break;
// OBSOLETE     case PRED:
// OBSOLETE       op_name = "PRED";
// OBSOLETE       goto unimplemented_unary_builtin;
// OBSOLETE     case SUCC:
// OBSOLETE       op_name = "SUCC";
// OBSOLETE       goto unimplemented_unary_builtin;
// OBSOLETE     case ABS:
// OBSOLETE       op_name = "ABS";
// OBSOLETE       goto unimplemented_unary_builtin;
// OBSOLETE     unimplemented_unary_builtin:
// OBSOLETE       parse_unary_call ();
// OBSOLETE       error ("not implemented:  %s builtin function", op_name);
// OBSOLETE       break;
// OBSOLETE     case ADDR_TOKEN:
// OBSOLETE       parse_unary_call ();
// OBSOLETE       write_exp_elt_opcode (UNOP_ADDR);
// OBSOLETE       break;
// OBSOLETE     case SIZE:
// OBSOLETE       type = parse_mode_or_normal_call ();
// OBSOLETE       if (type)
// OBSOLETE     {
// OBSOLETE       write_exp_elt_opcode (OP_LONG);
// OBSOLETE       write_exp_elt_type (builtin_type_int);
// OBSOLETE       CHECK_TYPEDEF (type);
// OBSOLETE       write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (type));
// OBSOLETE       write_exp_elt_opcode (OP_LONG);
// OBSOLETE     }
// OBSOLETE       else
// OBSOLETE     write_exp_elt_opcode (UNOP_SIZEOF);
// OBSOLETE       break;
// OBSOLETE     case LOWER:
// OBSOLETE       op = UNOP_LOWER;
// OBSOLETE       goto lower_upper;
// OBSOLETE     case UPPER:
// OBSOLETE       op = UNOP_UPPER;
// OBSOLETE       goto lower_upper;
// OBSOLETE     lower_upper:
// OBSOLETE       type = parse_mode_or_normal_call ();
// OBSOLETE       write_lower_upper_value (op, type);
// OBSOLETE       break;
// OBSOLETE     case LENGTH:
// OBSOLETE       parse_unary_call ();
// OBSOLETE       write_exp_elt_opcode (UNOP_LENGTH);
// OBSOLETE       break;
// OBSOLETE     case TYPENAME:
// OBSOLETE       type = PEEK_LVAL ().tsym.type;
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       switch (PEEK_TOKEN ())
// OBSOLETE     {
// OBSOLETE     case '[':
// OBSOLETE       parse_tuple (type);
// OBSOLETE       break;
// OBSOLETE     case '(':
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       parse_expr ();
// OBSOLETE       expect (')', "missing right parenthesis");
// OBSOLETE       write_exp_elt_opcode (UNOP_CAST);
// OBSOLETE       write_exp_elt_type (type);
// OBSOLETE       write_exp_elt_opcode (UNOP_CAST);
// OBSOLETE       break;
// OBSOLETE     default:
// OBSOLETE       error ("typename in invalid context");
// OBSOLETE     }
// OBSOLETE       break;
// OBSOLETE 
// OBSOLETE     default:
// OBSOLETE       error ("invalid expression syntax at `%s'", lexptr);
// OBSOLETE     }
// OBSOLETE   for (;;)
// OBSOLETE     {
// OBSOLETE       switch (PEEK_TOKEN ())
// OBSOLETE     {
// OBSOLETE     case DOT_FIELD_NAME:
// OBSOLETE       write_exp_elt_opcode (STRUCTOP_STRUCT);
// OBSOLETE       write_exp_string (PEEK_LVAL ().sval);
// OBSOLETE       write_exp_elt_opcode (STRUCTOP_STRUCT);
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       continue;
// OBSOLETE     case POINTER:
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       if (PEEK_TOKEN () == TYPENAME)
// OBSOLETE         {
// OBSOLETE           type = PEEK_LVAL ().tsym.type;
// OBSOLETE           write_exp_elt_opcode (UNOP_CAST);
// OBSOLETE           write_exp_elt_type (lookup_pointer_type (type));
// OBSOLETE           write_exp_elt_opcode (UNOP_CAST);
// OBSOLETE           FORWARD_TOKEN ();
// OBSOLETE         }
// OBSOLETE       write_exp_elt_opcode (UNOP_IND);
// OBSOLETE       continue;
// OBSOLETE     case OPEN_PAREN:
// OBSOLETE       parse_call ();
// OBSOLETE       continue;
// OBSOLETE     case CHARACTER_STRING_LITERAL:
// OBSOLETE     case CHARACTER_LITERAL:
// OBSOLETE     case BIT_STRING_LITERAL:
// OBSOLETE       /* Handle string repetition. (See comment in parse_operand5.) */
// OBSOLETE       parse_primval ();
// OBSOLETE       write_exp_elt_opcode (MULTI_SUBSCRIPT);
// OBSOLETE       write_exp_elt_longcst (1);
// OBSOLETE       write_exp_elt_opcode (MULTI_SUBSCRIPT);
// OBSOLETE       continue;
// OBSOLETE     case END_TOKEN:
// OBSOLETE     case TOKEN_NOT_READ:
// OBSOLETE     case INTEGER_LITERAL:
// OBSOLETE     case BOOLEAN_LITERAL:
// OBSOLETE     case FLOAT_LITERAL:
// OBSOLETE     case GENERAL_PROCEDURE_NAME:
// OBSOLETE     case LOCATION_NAME:
// OBSOLETE     case EMPTINESS_LITERAL:
// OBSOLETE     case TYPENAME:
// OBSOLETE     case CASE:
// OBSOLETE     case OF:
// OBSOLETE     case ESAC:
// OBSOLETE     case LOGIOR:
// OBSOLETE     case ORIF:
// OBSOLETE     case LOGXOR:
// OBSOLETE     case LOGAND:
// OBSOLETE     case ANDIF:
// OBSOLETE     case NOTEQUAL:
// OBSOLETE     case GEQ:
// OBSOLETE     case LEQ:
// OBSOLETE     case IN:
// OBSOLETE     case SLASH_SLASH:
// OBSOLETE     case MOD:
// OBSOLETE     case REM:
// OBSOLETE     case NOT:
// OBSOLETE     case RECEIVE:
// OBSOLETE     case UP:
// OBSOLETE     case IF:
// OBSOLETE     case THEN:
// OBSOLETE     case ELSE:
// OBSOLETE     case FI:
// OBSOLETE     case ELSIF:
// OBSOLETE     case ILLEGAL_TOKEN:
// OBSOLETE     case NUM:
// OBSOLETE     case PRED:
// OBSOLETE     case SUCC:
// OBSOLETE     case ABS:
// OBSOLETE     case CARD:
// OBSOLETE     case MAX_TOKEN:
// OBSOLETE     case MIN_TOKEN:
// OBSOLETE     case ADDR_TOKEN:
// OBSOLETE     case SIZE:
// OBSOLETE     case UPPER:
// OBSOLETE     case LOWER:
// OBSOLETE     case LENGTH:
// OBSOLETE     case ARRAY:
// OBSOLETE     case GDB_VARIABLE:
// OBSOLETE     case GDB_ASSIGNMENT:
// OBSOLETE       break;
// OBSOLETE     }
// OBSOLETE       break;
// OBSOLETE     }
// OBSOLETE   return;
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_operand6 (void)
// OBSOLETE {
// OBSOLETE   if (check_token (RECEIVE))
// OBSOLETE     {
// OBSOLETE       parse_primval ();
// OBSOLETE       error ("not implemented:  RECEIVE expression");
// OBSOLETE     }
// OBSOLETE   else if (check_token (POINTER))
// OBSOLETE     {
// OBSOLETE       parse_primval ();
// OBSOLETE       write_exp_elt_opcode (UNOP_ADDR);
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     parse_primval ();
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_operand5 (void)
// OBSOLETE {
// OBSOLETE   enum exp_opcode op;
// OBSOLETE   /* We are supposed to be looking for a <string repetition operator>,
// OBSOLETE      but in general we can't distinguish that from a parenthesized
// OBSOLETE      expression.  This is especially difficult if we allow the
// OBSOLETE      string operand to be a constant expression (as requested by
// OBSOLETE      some users), and not just a string literal.
// OBSOLETE      Consider:  LPRN expr RPRN LPRN expr RPRN
// OBSOLETE      Is that a function call or string repetition?
// OBSOLETE      Instead, we handle string repetition in parse_primval,
// OBSOLETE      and build_generalized_call. */
// OBSOLETE   switch (PEEK_TOKEN ())
// OBSOLETE     {
// OBSOLETE     case NOT:
// OBSOLETE       op = UNOP_LOGICAL_NOT;
// OBSOLETE       break;
// OBSOLETE     case '-':
// OBSOLETE       op = UNOP_NEG;
// OBSOLETE       break;
// OBSOLETE     default:
// OBSOLETE       op = OP_NULL;
// OBSOLETE     }
// OBSOLETE   if (op != OP_NULL)
// OBSOLETE     FORWARD_TOKEN ();
// OBSOLETE   parse_operand6 ();
// OBSOLETE   if (op != OP_NULL)
// OBSOLETE     write_exp_elt_opcode (op);
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_operand4 (void)
// OBSOLETE {
// OBSOLETE   enum exp_opcode op;
// OBSOLETE   parse_operand5 ();
// OBSOLETE   for (;;)
// OBSOLETE     {
// OBSOLETE       switch (PEEK_TOKEN ())
// OBSOLETE     {
// OBSOLETE     case '*':
// OBSOLETE       op = BINOP_MUL;
// OBSOLETE       break;
// OBSOLETE     case '/':
// OBSOLETE       op = BINOP_DIV;
// OBSOLETE       break;
// OBSOLETE     case MOD:
// OBSOLETE       op = BINOP_MOD;
// OBSOLETE       break;
// OBSOLETE     case REM:
// OBSOLETE       op = BINOP_REM;
// OBSOLETE       break;
// OBSOLETE     default:
// OBSOLETE       return;
// OBSOLETE     }
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       parse_operand5 ();
// OBSOLETE       write_exp_elt_opcode (op);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_operand3 (void)
// OBSOLETE {
// OBSOLETE   enum exp_opcode op;
// OBSOLETE   parse_operand4 ();
// OBSOLETE   for (;;)
// OBSOLETE     {
// OBSOLETE       switch (PEEK_TOKEN ())
// OBSOLETE     {
// OBSOLETE     case '+':
// OBSOLETE       op = BINOP_ADD;
// OBSOLETE       break;
// OBSOLETE     case '-':
// OBSOLETE       op = BINOP_SUB;
// OBSOLETE       break;
// OBSOLETE     case SLASH_SLASH:
// OBSOLETE       op = BINOP_CONCAT;
// OBSOLETE       break;
// OBSOLETE     default:
// OBSOLETE       return;
// OBSOLETE     }
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       parse_operand4 ();
// OBSOLETE       write_exp_elt_opcode (op);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_operand2 (void)
// OBSOLETE {
// OBSOLETE   enum exp_opcode op;
// OBSOLETE   parse_operand3 ();
// OBSOLETE   for (;;)
// OBSOLETE     {
// OBSOLETE       if (check_token (IN))
// OBSOLETE     {
// OBSOLETE       parse_operand3 ();
// OBSOLETE       write_exp_elt_opcode (BINOP_IN);
// OBSOLETE     }
// OBSOLETE       else
// OBSOLETE     {
// OBSOLETE       switch (PEEK_TOKEN ())
// OBSOLETE         {
// OBSOLETE         case '>':
// OBSOLETE           op = BINOP_GTR;
// OBSOLETE           break;
// OBSOLETE         case GEQ:
// OBSOLETE           op = BINOP_GEQ;
// OBSOLETE           break;
// OBSOLETE         case '<':
// OBSOLETE           op = BINOP_LESS;
// OBSOLETE           break;
// OBSOLETE         case LEQ:
// OBSOLETE           op = BINOP_LEQ;
// OBSOLETE           break;
// OBSOLETE         case '=':
// OBSOLETE           op = BINOP_EQUAL;
// OBSOLETE           break;
// OBSOLETE         case NOTEQUAL:
// OBSOLETE           op = BINOP_NOTEQUAL;
// OBSOLETE           break;
// OBSOLETE         default:
// OBSOLETE           return;
// OBSOLETE         }
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       parse_operand3 ();
// OBSOLETE       write_exp_elt_opcode (op);
// OBSOLETE     }
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_operand1 (void)
// OBSOLETE {
// OBSOLETE   enum exp_opcode op;
// OBSOLETE   parse_operand2 ();
// OBSOLETE   for (;;)
// OBSOLETE     {
// OBSOLETE       switch (PEEK_TOKEN ())
// OBSOLETE     {
// OBSOLETE     case LOGAND:
// OBSOLETE       op = BINOP_BITWISE_AND;
// OBSOLETE       break;
// OBSOLETE     case ANDIF:
// OBSOLETE       op = BINOP_LOGICAL_AND;
// OBSOLETE       break;
// OBSOLETE     default:
// OBSOLETE       return;
// OBSOLETE     }
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       parse_operand2 ();
// OBSOLETE       write_exp_elt_opcode (op);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_operand0 (void)
// OBSOLETE {
// OBSOLETE   enum exp_opcode op;
// OBSOLETE   parse_operand1 ();
// OBSOLETE   for (;;)
// OBSOLETE     {
// OBSOLETE       switch (PEEK_TOKEN ())
// OBSOLETE     {
// OBSOLETE     case LOGIOR:
// OBSOLETE       op = BINOP_BITWISE_IOR;
// OBSOLETE       break;
// OBSOLETE     case LOGXOR:
// OBSOLETE       op = BINOP_BITWISE_XOR;
// OBSOLETE       break;
// OBSOLETE     case ORIF:
// OBSOLETE       op = BINOP_LOGICAL_OR;
// OBSOLETE       break;
// OBSOLETE     default:
// OBSOLETE       return;
// OBSOLETE     }
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       parse_operand1 ();
// OBSOLETE       write_exp_elt_opcode (op);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_expr (void)
// OBSOLETE {
// OBSOLETE   parse_operand0 ();
// OBSOLETE   if (check_token (GDB_ASSIGNMENT))
// OBSOLETE     {
// OBSOLETE       parse_expr ();
// OBSOLETE       write_exp_elt_opcode (BINOP_ASSIGN);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_then_alternative (void)
// OBSOLETE {
// OBSOLETE   expect (THEN, "missing 'THEN' in 'IF' expression");
// OBSOLETE   parse_expr ();
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_else_alternative (void)
// OBSOLETE {
// OBSOLETE   if (check_token (ELSIF))
// OBSOLETE     parse_if_expression_body ();
// OBSOLETE   else if (check_token (ELSE))
// OBSOLETE     parse_expr ();
// OBSOLETE   else
// OBSOLETE     error ("missing ELSE/ELSIF in IF expression");
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Matches: <boolean expression> <then alternative> <else alternative> */
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_if_expression_body (void)
// OBSOLETE {
// OBSOLETE   parse_expr ();
// OBSOLETE   parse_then_alternative ();
// OBSOLETE   parse_else_alternative ();
// OBSOLETE   write_exp_elt_opcode (TERNOP_COND);
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_if_expression (void)
// OBSOLETE {
// OBSOLETE   require (IF);
// OBSOLETE   parse_if_expression_body ();
// OBSOLETE   expect (FI, "missing 'FI' at end of conditional expression");
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* An <untyped_expr> is a superset of <expr>.  It also includes
// OBSOLETE    <conditional expressions> and untyped <tuples>, whose types
// OBSOLETE    are not given by their constituents.  Hence, these are only
// OBSOLETE    allowed in certain contexts that expect a certain type.
// OBSOLETE    You should call convert() to fix up the <untyped_expr>. */
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE parse_untyped_expr (void)
// OBSOLETE {
// OBSOLETE   switch (PEEK_TOKEN ())
// OBSOLETE     {
// OBSOLETE     case IF:
// OBSOLETE       parse_if_expression ();
// OBSOLETE       return;
// OBSOLETE     case CASE:
// OBSOLETE       error ("not implemented:  CASE expression");
// OBSOLETE     case '(':
// OBSOLETE       switch (PEEK_TOKEN1 ())
// OBSOLETE     {
// OBSOLETE     case IF:
// OBSOLETE     case CASE:
// OBSOLETE       goto skip_lprn;
// OBSOLETE     case '[':
// OBSOLETE     skip_lprn:
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE       parse_untyped_expr ();
// OBSOLETE       expect (')', "missing ')'");
// OBSOLETE       return;
// OBSOLETE     default:;
// OBSOLETE       /* fall through */
// OBSOLETE     }
// OBSOLETE     default:
// OBSOLETE       parse_operand0 ();
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE int
// OBSOLETE chill_parse (void)
// OBSOLETE {
// OBSOLETE   terminal_buffer[0] = TOKEN_NOT_READ;
// OBSOLETE   if (PEEK_TOKEN () == TYPENAME && PEEK_TOKEN1 () == END_TOKEN)
// OBSOLETE     {
// OBSOLETE       write_exp_elt_opcode (OP_TYPE);
// OBSOLETE       write_exp_elt_type (PEEK_LVAL ().tsym.type);
// OBSOLETE       write_exp_elt_opcode (OP_TYPE);
// OBSOLETE       FORWARD_TOKEN ();
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     parse_expr ();
// OBSOLETE   if (terminal_buffer[0] != END_TOKEN)
// OBSOLETE     {
// OBSOLETE       if (comma_terminates && terminal_buffer[0] == ',')
// OBSOLETE     lexptr--;               /* Put the comma back.  */
// OBSOLETE       else
// OBSOLETE     error ("Junk after end of expression.");
// OBSOLETE     }
// OBSOLETE   return 0;
// OBSOLETE }
// OBSOLETE 
// OBSOLETE 
// OBSOLETE /* Implementation of a dynamically expandable buffer for processing input
// OBSOLETE    characters acquired through lexptr and building a value to return in
// OBSOLETE    yylval. */
// OBSOLETE 
// OBSOLETE static char *tempbuf;               /* Current buffer contents */
// OBSOLETE static int tempbufsize;             /* Size of allocated buffer */
// OBSOLETE static int tempbufindex;    /* Current index into buffer */
// OBSOLETE 
// OBSOLETE #define GROWBY_MIN_SIZE 64  /* Minimum amount to grow buffer by */
// OBSOLETE 
// OBSOLETE #define CHECKBUF(size) \
// OBSOLETE   do { \
// OBSOLETE     if (tempbufindex + (size) >= tempbufsize) \
// OBSOLETE       { \
// OBSOLETE     growbuf_by_size (size); \
// OBSOLETE       } \
// OBSOLETE   } while (0);
// OBSOLETE 
// OBSOLETE /* Grow the static temp buffer if necessary, including allocating the first one
// OBSOLETE    on demand. */
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE growbuf_by_size (int count)
// OBSOLETE {
// OBSOLETE   int growby;
// OBSOLETE 
// OBSOLETE   growby = max (count, GROWBY_MIN_SIZE);
// OBSOLETE   tempbufsize += growby;
// OBSOLETE   if (tempbuf == NULL)
// OBSOLETE     {
// OBSOLETE       tempbuf = (char *) xmalloc (tempbufsize);
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     {
// OBSOLETE       tempbuf = (char *) xrealloc (tempbuf, tempbufsize);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Try to consume a simple name string token.  If successful, returns
// OBSOLETE    a pointer to a nullbyte terminated copy of the name that can be used
// OBSOLETE    in symbol table lookups.  If not successful, returns NULL. */
// OBSOLETE 
// OBSOLETE static char *
// OBSOLETE match_simple_name_string (void)
// OBSOLETE {
// OBSOLETE   char *tokptr = lexptr;
// OBSOLETE 
// OBSOLETE   if (isalpha (*tokptr) || *tokptr == '_')
// OBSOLETE     {
// OBSOLETE       char *result;
// OBSOLETE       do
// OBSOLETE     {
// OBSOLETE       tokptr++;
// OBSOLETE     }
// OBSOLETE       while (isalnum (*tokptr) || (*tokptr == '_'));
// OBSOLETE       yylval.sval.ptr = lexptr;
// OBSOLETE       yylval.sval.length = tokptr - lexptr;
// OBSOLETE       lexptr = tokptr;
// OBSOLETE       result = copy_name (yylval.sval);
// OBSOLETE       return result;
// OBSOLETE     }
// OBSOLETE   return (NULL);
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Start looking for a value composed of valid digits as set by the base
// OBSOLETE    in use.  Note that '_' characters are valid anywhere, in any quantity,
// OBSOLETE    and are simply ignored.  Since we must find at least one valid digit,
// OBSOLETE    or reject this token as an integer literal, we keep track of how many
// OBSOLETE    digits we have encountered. */
// OBSOLETE 
// OBSOLETE static int
// OBSOLETE decode_integer_value (int base, char **tokptrptr, LONGEST *ivalptr)
// OBSOLETE {
// OBSOLETE   char *tokptr = *tokptrptr;
// OBSOLETE   int temp;
// OBSOLETE   int digits = 0;
// OBSOLETE 
// OBSOLETE   while (*tokptr != '\0')
// OBSOLETE     {
// OBSOLETE       temp = *tokptr;
// OBSOLETE       if (isupper (temp))
// OBSOLETE     temp = tolower (temp);
// OBSOLETE       tokptr++;
// OBSOLETE       switch (temp)
// OBSOLETE     {
// OBSOLETE     case '_':
// OBSOLETE       continue;
// OBSOLETE     case '0':
// OBSOLETE     case '1':
// OBSOLETE     case '2':
// OBSOLETE     case '3':
// OBSOLETE     case '4':
// OBSOLETE     case '5':
// OBSOLETE     case '6':
// OBSOLETE     case '7':
// OBSOLETE     case '8':
// OBSOLETE     case '9':
// OBSOLETE       temp -= '0';
// OBSOLETE       break;
// OBSOLETE     case 'a':
// OBSOLETE     case 'b':
// OBSOLETE     case 'c':
// OBSOLETE     case 'd':
// OBSOLETE     case 'e':
// OBSOLETE     case 'f':
// OBSOLETE       temp -= 'a';
// OBSOLETE       temp += 10;
// OBSOLETE       break;
// OBSOLETE     default:
// OBSOLETE       temp = base;
// OBSOLETE       break;
// OBSOLETE     }
// OBSOLETE       if (temp < base)
// OBSOLETE     {
// OBSOLETE       digits++;
// OBSOLETE       *ivalptr *= base;
// OBSOLETE       *ivalptr += temp;
// OBSOLETE     }
// OBSOLETE       else
// OBSOLETE     {
// OBSOLETE       /* Found something not in domain for current base. */
// OBSOLETE       tokptr--;             /* Unconsume what gave us indigestion. */
// OBSOLETE       break;
// OBSOLETE     }
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* If we didn't find any digits, then we don't have a valid integer
// OBSOLETE      value, so reject the entire token.  Otherwise, update the lexical
// OBSOLETE      scan pointer, and return non-zero for success. */
// OBSOLETE 
// OBSOLETE   if (digits == 0)
// OBSOLETE     {
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     {
// OBSOLETE       *tokptrptr = tokptr;
// OBSOLETE       return (1);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static int
// OBSOLETE decode_integer_literal (LONGEST *valptr, char **tokptrptr)
// OBSOLETE {
// OBSOLETE   char *tokptr = *tokptrptr;
// OBSOLETE   int base = 0;
// OBSOLETE   LONGEST ival = 0;
// OBSOLETE   int explicit_base = 0;
// OBSOLETE 
// OBSOLETE   /* Look for an explicit base specifier, which is optional. */
// OBSOLETE 
// OBSOLETE   switch (*tokptr)
// OBSOLETE     {
// OBSOLETE     case 'd':
// OBSOLETE     case 'D':
// OBSOLETE       explicit_base++;
// OBSOLETE       base = 10;
// OBSOLETE       tokptr++;
// OBSOLETE       break;
// OBSOLETE     case 'b':
// OBSOLETE     case 'B':
// OBSOLETE       explicit_base++;
// OBSOLETE       base = 2;
// OBSOLETE       tokptr++;
// OBSOLETE       break;
// OBSOLETE     case 'h':
// OBSOLETE     case 'H':
// OBSOLETE       explicit_base++;
// OBSOLETE       base = 16;
// OBSOLETE       tokptr++;
// OBSOLETE       break;
// OBSOLETE     case 'o':
// OBSOLETE     case 'O':
// OBSOLETE       explicit_base++;
// OBSOLETE       base = 8;
// OBSOLETE       tokptr++;
// OBSOLETE       break;
// OBSOLETE     default:
// OBSOLETE       base = 10;
// OBSOLETE       break;
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* If we found an explicit base ensure that the character after the
// OBSOLETE      explicit base is a single quote. */
// OBSOLETE 
// OBSOLETE   if (explicit_base && (*tokptr++ != '\''))
// OBSOLETE     {
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* Attempt to decode whatever follows as an integer value in the
// OBSOLETE      indicated base, updating the token pointer in the process and
// OBSOLETE      computing the value into ival.  Also, if we have an explicit
// OBSOLETE      base, then the next character must not be a single quote, or we
// OBSOLETE      have a bitstring literal, so reject the entire token in this case.
// OBSOLETE      Otherwise, update the lexical scan pointer, and return non-zero
// OBSOLETE      for success. */
// OBSOLETE 
// OBSOLETE   if (!decode_integer_value (base, &tokptr, &ival))
// OBSOLETE     {
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE   else if (explicit_base && (*tokptr == '\''))
// OBSOLETE     {
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     {
// OBSOLETE       *valptr = ival;
// OBSOLETE       *tokptrptr = tokptr;
// OBSOLETE       return (1);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /*  If it wasn't for the fact that floating point values can contain '_'
// OBSOLETE    characters, we could just let strtod do all the hard work by letting it
// OBSOLETE    try to consume as much of the current token buffer as possible and
// OBSOLETE    find a legal conversion.  Unfortunately we need to filter out the '_'
// OBSOLETE    characters before calling strtod, which we do by copying the other
// OBSOLETE    legal chars to a local buffer to be converted.  However since we also
// OBSOLETE    need to keep track of where the last unconsumed character in the input
// OBSOLETE    buffer is, we have transfer only as many characters as may compose a
// OBSOLETE    legal floating point value. */
// OBSOLETE 
// OBSOLETE static enum ch_terminal
// OBSOLETE match_float_literal (void)
// OBSOLETE {
// OBSOLETE   char *tokptr = lexptr;
// OBSOLETE   char *buf;
// OBSOLETE   char *copy;
// OBSOLETE   double dval;
// OBSOLETE   extern double strtod ();
// OBSOLETE 
// OBSOLETE   /* Make local buffer in which to build the string to convert.  This is
// OBSOLETE      required because underscores are valid in chill floating point numbers
// OBSOLETE      but not in the string passed to strtod to convert.  The string will be
// OBSOLETE      no longer than our input string. */
// OBSOLETE 
// OBSOLETE   copy = buf = (char *) alloca (strlen (tokptr) + 1);
// OBSOLETE 
// OBSOLETE   /* Transfer all leading digits to the conversion buffer, discarding any
// OBSOLETE      underscores. */
// OBSOLETE 
// OBSOLETE   while (isdigit (*tokptr) || *tokptr == '_')
// OBSOLETE     {
// OBSOLETE       if (*tokptr != '_')
// OBSOLETE     {
// OBSOLETE       *copy++ = *tokptr;
// OBSOLETE     }
// OBSOLETE       tokptr++;
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* Now accept either a '.', or one of [eEdD].  Dot is legal regardless
// OBSOLETE      of whether we found any leading digits, and we simply accept it and
// OBSOLETE      continue on to look for the fractional part and/or exponent.  One of
// OBSOLETE      [eEdD] is legal only if we have seen digits, and means that there
// OBSOLETE      is no fractional part.  If we find neither of these, then this is
// OBSOLETE      not a floating point number, so return failure. */
// OBSOLETE 
// OBSOLETE   switch (*tokptr++)
// OBSOLETE     {
// OBSOLETE     case '.':
// OBSOLETE       /* Accept and then look for fractional part and/or exponent. */
// OBSOLETE       *copy++ = '.';
// OBSOLETE       break;
// OBSOLETE 
// OBSOLETE     case 'e':
// OBSOLETE     case 'E':
// OBSOLETE     case 'd':
// OBSOLETE     case 'D':
// OBSOLETE       if (copy == buf)
// OBSOLETE     {
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE       *copy++ = 'e';
// OBSOLETE       goto collect_exponent;
// OBSOLETE       break;
// OBSOLETE 
// OBSOLETE     default:
// OBSOLETE       return (0);
// OBSOLETE       break;
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* We found a '.', copy any fractional digits to the conversion buffer, up
// OBSOLETE      to the first nondigit, non-underscore character. */
// OBSOLETE 
// OBSOLETE   while (isdigit (*tokptr) || *tokptr == '_')
// OBSOLETE     {
// OBSOLETE       if (*tokptr != '_')
// OBSOLETE     {
// OBSOLETE       *copy++ = *tokptr;
// OBSOLETE     }
// OBSOLETE       tokptr++;
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* Look for an exponent, which must start with one of [eEdD].  If none
// OBSOLETE      is found, jump directly to trying to convert what we have collected
// OBSOLETE      so far. */
// OBSOLETE 
// OBSOLETE   switch (*tokptr)
// OBSOLETE     {
// OBSOLETE     case 'e':
// OBSOLETE     case 'E':
// OBSOLETE     case 'd':
// OBSOLETE     case 'D':
// OBSOLETE       *copy++ = 'e';
// OBSOLETE       tokptr++;
// OBSOLETE       break;
// OBSOLETE     default:
// OBSOLETE       goto convert_float;
// OBSOLETE       break;
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* Accept an optional '-' or '+' following one of [eEdD]. */
// OBSOLETE 
// OBSOLETE collect_exponent:
// OBSOLETE   if (*tokptr == '+' || *tokptr == '-')
// OBSOLETE     {
// OBSOLETE       *copy++ = *tokptr++;
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* Now copy an exponent into the conversion buffer.  Note that at the 
// OBSOLETE      moment underscores are *not* allowed in exponents. */
// OBSOLETE 
// OBSOLETE   while (isdigit (*tokptr))
// OBSOLETE     {
// OBSOLETE       *copy++ = *tokptr++;
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* If we transfered any chars to the conversion buffer, try to interpret its
// OBSOLETE      contents as a floating point value.  If any characters remain, then we
// OBSOLETE      must not have a valid floating point string. */
// OBSOLETE 
// OBSOLETE convert_float:
// OBSOLETE   *copy = '\0';
// OBSOLETE   if (copy != buf)
// OBSOLETE     {
// OBSOLETE       dval = strtod (buf, &copy);
// OBSOLETE       if (*copy == '\0')
// OBSOLETE     {
// OBSOLETE       yylval.dval = dval;
// OBSOLETE       lexptr = tokptr;
// OBSOLETE       return (FLOAT_LITERAL);
// OBSOLETE     }
// OBSOLETE     }
// OBSOLETE   return (0);
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Recognize a string literal.  A string literal is a sequence
// OBSOLETE    of characters enclosed in matching single or double quotes, except that
// OBSOLETE    a single character inside single quotes is a character literal, which
// OBSOLETE    we reject as a string literal.  To embed the terminator character inside
// OBSOLETE    a string, it is simply doubled (I.E. "this""is""one""string") */
// OBSOLETE 
// OBSOLETE static enum ch_terminal
// OBSOLETE match_string_literal (void)
// OBSOLETE {
// OBSOLETE   char *tokptr = lexptr;
// OBSOLETE   int in_ctrlseq = 0;
// OBSOLETE   LONGEST ival;
// OBSOLETE 
// OBSOLETE   for (tempbufindex = 0, tokptr++; *tokptr != '\0'; tokptr++)
// OBSOLETE     {
// OBSOLETE       CHECKBUF (1);
// OBSOLETE     tryagain:;
// OBSOLETE       if (in_ctrlseq)
// OBSOLETE     {
// OBSOLETE       /* skip possible whitespaces */
// OBSOLETE       while ((*tokptr == ' ' || *tokptr == '\t') && *tokptr)
// OBSOLETE         tokptr++;
// OBSOLETE       if (*tokptr == ')')
// OBSOLETE         {
// OBSOLETE           in_ctrlseq = 0;
// OBSOLETE           tokptr++;
// OBSOLETE           goto tryagain;
// OBSOLETE         }
// OBSOLETE       else if (*tokptr != ',')
// OBSOLETE         error ("Invalid control sequence");
// OBSOLETE       tokptr++;
// OBSOLETE       /* skip possible whitespaces */
// OBSOLETE       while ((*tokptr == ' ' || *tokptr == '\t') && *tokptr)
// OBSOLETE         tokptr++;
// OBSOLETE       if (!decode_integer_literal (&ival, &tokptr))
// OBSOLETE         error ("Invalid control sequence");
// OBSOLETE       tokptr--;
// OBSOLETE     }
// OBSOLETE       else if (*tokptr == *lexptr)
// OBSOLETE     {
// OBSOLETE       if (*(tokptr + 1) == *lexptr)
// OBSOLETE         {
// OBSOLETE           ival = *tokptr++;
// OBSOLETE         }
// OBSOLETE       else
// OBSOLETE         {
// OBSOLETE           break;
// OBSOLETE         }
// OBSOLETE     }
// OBSOLETE       else if (*tokptr == '^')
// OBSOLETE     {
// OBSOLETE       if (*(tokptr + 1) == '(')
// OBSOLETE         {
// OBSOLETE           in_ctrlseq = 1;
// OBSOLETE           tokptr += 2;
// OBSOLETE           if (!decode_integer_literal (&ival, &tokptr))
// OBSOLETE             error ("Invalid control sequence");
// OBSOLETE           tokptr--;
// OBSOLETE         }
// OBSOLETE       else if (*(tokptr + 1) == '^')
// OBSOLETE         ival = *tokptr++;
// OBSOLETE       else
// OBSOLETE         error ("Invalid control sequence");
// OBSOLETE     }
// OBSOLETE       else
// OBSOLETE     ival = *tokptr;
// OBSOLETE       tempbuf[tempbufindex++] = ival;
// OBSOLETE     }
// OBSOLETE   if (in_ctrlseq)
// OBSOLETE     error ("Invalid control sequence");
// OBSOLETE 
// OBSOLETE   if (*tokptr == '\0'               /* no terminator */
// OBSOLETE       || (tempbufindex == 1 && *tokptr == '\''))    /* char literal */
// OBSOLETE     {
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     {
// OBSOLETE       tempbuf[tempbufindex] = '\0';
// OBSOLETE       yylval.sval.ptr = tempbuf;
// OBSOLETE       yylval.sval.length = tempbufindex;
// OBSOLETE       lexptr = ++tokptr;
// OBSOLETE       return (CHARACTER_STRING_LITERAL);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Recognize a character literal.  A character literal is single character
// OBSOLETE    or a control sequence, enclosed in single quotes.  A control sequence
// OBSOLETE    is a comma separated list of one or more integer literals, enclosed
// OBSOLETE    in parenthesis and introduced with a circumflex character.
// OBSOLETE 
// OBSOLETE    EX:  'a'  '^(7)'  '^(7,8)'
// OBSOLETE 
// OBSOLETE    As a GNU chill extension, the syntax C'xx' is also recognized as a 
// OBSOLETE    character literal, where xx is a hex value for the character.
// OBSOLETE 
// OBSOLETE    Note that more than a single character, enclosed in single quotes, is
// OBSOLETE    a string literal.
// OBSOLETE 
// OBSOLETE    Returns CHARACTER_LITERAL if a match is found.
// OBSOLETE  */
// OBSOLETE 
// OBSOLETE static enum ch_terminal
// OBSOLETE match_character_literal (void)
// OBSOLETE {
// OBSOLETE   char *tokptr = lexptr;
// OBSOLETE   LONGEST ival = 0;
// OBSOLETE 
// OBSOLETE   if ((*tokptr == 'c' || *tokptr == 'C') && (*(tokptr + 1) == '\''))
// OBSOLETE     {
// OBSOLETE       /* We have a GNU chill extension form, so skip the leading "C'",
// OBSOLETE          decode the hex value, and then ensure that we have a trailing
// OBSOLETE          single quote character. */
// OBSOLETE       tokptr += 2;
// OBSOLETE       if (!decode_integer_value (16, &tokptr, &ival) || (*tokptr != '\''))
// OBSOLETE     {
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE       tokptr++;
// OBSOLETE     }
// OBSOLETE   else if (*tokptr == '\'')
// OBSOLETE     {
// OBSOLETE       tokptr++;
// OBSOLETE 
// OBSOLETE       /* Determine which form we have, either a control sequence or the
// OBSOLETE          single character form. */
// OBSOLETE 
// OBSOLETE       if (*tokptr == '^')
// OBSOLETE     {
// OBSOLETE       if (*(tokptr + 1) == '(')
// OBSOLETE         {
// OBSOLETE           /* Match and decode a control sequence.  Return zero if we don't
// OBSOLETE              find a valid integer literal, or if the next unconsumed character
// OBSOLETE              after the integer literal is not the trailing ')'. */
// OBSOLETE           tokptr += 2;
// OBSOLETE           if (!decode_integer_literal (&ival, &tokptr) || (*tokptr++ != ')'))
// OBSOLETE             {
// OBSOLETE               return (0);
// OBSOLETE             }
// OBSOLETE         }
// OBSOLETE       else if (*(tokptr + 1) == '^')
// OBSOLETE         {
// OBSOLETE           ival = *tokptr;
// OBSOLETE           tokptr += 2;
// OBSOLETE         }
// OBSOLETE       else
// OBSOLETE         /* fail */
// OBSOLETE         error ("Invalid control sequence");
// OBSOLETE     }
// OBSOLETE       else if (*tokptr == '\'')
// OBSOLETE     {
// OBSOLETE       /* this must be duplicated */
// OBSOLETE       ival = *tokptr;
// OBSOLETE       tokptr += 2;
// OBSOLETE     }
// OBSOLETE       else
// OBSOLETE     {
// OBSOLETE       ival = *tokptr++;
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE       /* The trailing quote has not yet been consumed.  If we don't find
// OBSOLETE          it, then we have no match. */
// OBSOLETE 
// OBSOLETE       if (*tokptr++ != '\'')
// OBSOLETE     {
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     {
// OBSOLETE       /* Not a character literal. */
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE   yylval.typed_val.val = ival;
// OBSOLETE   yylval.typed_val.type = builtin_type_chill_char;
// OBSOLETE   lexptr = tokptr;
// OBSOLETE   return (CHARACTER_LITERAL);
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Recognize an integer literal, as specified in Z.200 sec 5.2.4.2.
// OBSOLETE    Note that according to 5.2.4.2, a single "_" is also a valid integer
// OBSOLETE    literal, however GNU-chill requires there to be at least one "digit"
// OBSOLETE    in any integer literal. */
// OBSOLETE 
// OBSOLETE static enum ch_terminal
// OBSOLETE match_integer_literal (void)
// OBSOLETE {
// OBSOLETE   char *tokptr = lexptr;
// OBSOLETE   LONGEST ival;
// OBSOLETE 
// OBSOLETE   if (!decode_integer_literal (&ival, &tokptr))
// OBSOLETE     {
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     {
// OBSOLETE       yylval.typed_val.val = ival;
// OBSOLETE #if defined(CC_HAS_LONG_LONG)
// OBSOLETE       if (ival > (LONGEST) 2147483647U || ival < -(LONGEST) 2147483648U)
// OBSOLETE     yylval.typed_val.type = builtin_type_long_long;
// OBSOLETE       else
// OBSOLETE #endif
// OBSOLETE     yylval.typed_val.type = builtin_type_int;
// OBSOLETE       lexptr = tokptr;
// OBSOLETE       return (INTEGER_LITERAL);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE /* Recognize a bit-string literal, as specified in Z.200 sec 5.2.4.8
// OBSOLETE    Note that according to 5.2.4.8, a single "_" is also a valid bit-string
// OBSOLETE    literal, however GNU-chill requires there to be at least one "digit"
// OBSOLETE    in any bit-string literal. */
// OBSOLETE 
// OBSOLETE static enum ch_terminal
// OBSOLETE match_bitstring_literal (void)
// OBSOLETE {
// OBSOLETE   register char *tokptr = lexptr;
// OBSOLETE   int bitoffset = 0;
// OBSOLETE   int bitcount = 0;
// OBSOLETE   int bits_per_char;
// OBSOLETE   int digit;
// OBSOLETE 
// OBSOLETE   tempbufindex = 0;
// OBSOLETE   CHECKBUF (1);
// OBSOLETE   tempbuf[0] = 0;
// OBSOLETE 
// OBSOLETE   /* Look for the required explicit base specifier. */
// OBSOLETE 
// OBSOLETE   switch (*tokptr++)
// OBSOLETE     {
// OBSOLETE     case 'b':
// OBSOLETE     case 'B':
// OBSOLETE       bits_per_char = 1;
// OBSOLETE       break;
// OBSOLETE     case 'o':
// OBSOLETE     case 'O':
// OBSOLETE       bits_per_char = 3;
// OBSOLETE       break;
// OBSOLETE     case 'h':
// OBSOLETE     case 'H':
// OBSOLETE       bits_per_char = 4;
// OBSOLETE       break;
// OBSOLETE     default:
// OBSOLETE       return (0);
// OBSOLETE       break;
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* Ensure that the character after the explicit base is a single quote. */
// OBSOLETE 
// OBSOLETE   if (*tokptr++ != '\'')
// OBSOLETE     {
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   while (*tokptr != '\0' && *tokptr != '\'')
// OBSOLETE     {
// OBSOLETE       digit = *tokptr;
// OBSOLETE       if (isupper (digit))
// OBSOLETE     digit = tolower (digit);
// OBSOLETE       tokptr++;
// OBSOLETE       switch (digit)
// OBSOLETE     {
// OBSOLETE     case '_':
// OBSOLETE       continue;
// OBSOLETE     case '0':
// OBSOLETE     case '1':
// OBSOLETE     case '2':
// OBSOLETE     case '3':
// OBSOLETE     case '4':
// OBSOLETE     case '5':
// OBSOLETE     case '6':
// OBSOLETE     case '7':
// OBSOLETE     case '8':
// OBSOLETE     case '9':
// OBSOLETE       digit -= '0';
// OBSOLETE       break;
// OBSOLETE     case 'a':
// OBSOLETE     case 'b':
// OBSOLETE     case 'c':
// OBSOLETE     case 'd':
// OBSOLETE     case 'e':
// OBSOLETE     case 'f':
// OBSOLETE       digit -= 'a';
// OBSOLETE       digit += 10;
// OBSOLETE       break;
// OBSOLETE     default:
// OBSOLETE       /* this is not a bitstring literal, probably an integer */
// OBSOLETE       return 0;
// OBSOLETE     }
// OBSOLETE       if (digit >= 1 << bits_per_char)
// OBSOLETE     {
// OBSOLETE       /* Found something not in domain for current base. */
// OBSOLETE       error ("Too-large digit in bitstring or integer.");
// OBSOLETE     }
// OBSOLETE       else
// OBSOLETE     {
// OBSOLETE       /* Extract bits from digit, packing them into the bitstring byte. */
// OBSOLETE       int k = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? bits_per_char - 1 : 0;
// OBSOLETE       for (; TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? k >= 0 : k < bits_per_char;
// OBSOLETE            TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? k-- : k++)
// OBSOLETE         {
// OBSOLETE           bitcount++;
// OBSOLETE           if (digit & (1 << k))
// OBSOLETE             {
// OBSOLETE               tempbuf[tempbufindex] |=
// OBSOLETE                 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
// OBSOLETE                 ? (1 << (HOST_CHAR_BIT - 1 - bitoffset))
// OBSOLETE                 : (1 << bitoffset);
// OBSOLETE             }
// OBSOLETE           bitoffset++;
// OBSOLETE           if (bitoffset == HOST_CHAR_BIT)
// OBSOLETE             {
// OBSOLETE               bitoffset = 0;
// OBSOLETE               tempbufindex++;
// OBSOLETE               CHECKBUF (1);
// OBSOLETE               tempbuf[tempbufindex] = 0;
// OBSOLETE             }
// OBSOLETE         }
// OBSOLETE     }
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* Verify that we consumed everything up to the trailing single quote,
// OBSOLETE      and that we found some bits (IE not just underbars). */
// OBSOLETE 
// OBSOLETE   if (*tokptr++ != '\'')
// OBSOLETE     {
// OBSOLETE       return (0);
// OBSOLETE     }
// OBSOLETE   else
// OBSOLETE     {
// OBSOLETE       yylval.sval.ptr = tempbuf;
// OBSOLETE       yylval.sval.length = bitcount;
// OBSOLETE       lexptr = tokptr;
// OBSOLETE       return (BIT_STRING_LITERAL);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE struct token
// OBSOLETE {
// OBSOLETE   char *operator;
// OBSOLETE   int token;
// OBSOLETE };
// OBSOLETE 
// OBSOLETE static const struct token idtokentab[] =
// OBSOLETE {
// OBSOLETE   {"array", ARRAY},
// OBSOLETE   {"length", LENGTH},
// OBSOLETE   {"lower", LOWER},
// OBSOLETE   {"upper", UPPER},
// OBSOLETE   {"andif", ANDIF},
// OBSOLETE   {"pred", PRED},
// OBSOLETE   {"succ", SUCC},
// OBSOLETE   {"card", CARD},
// OBSOLETE   {"size", SIZE},
// OBSOLETE   {"orif", ORIF},
// OBSOLETE   {"num", NUM},
// OBSOLETE   {"abs", ABS},
// OBSOLETE   {"max", MAX_TOKEN},
// OBSOLETE   {"min", MIN_TOKEN},
// OBSOLETE   {"mod", MOD},
// OBSOLETE   {"rem", REM},
// OBSOLETE   {"not", NOT},
// OBSOLETE   {"xor", LOGXOR},
// OBSOLETE   {"and", LOGAND},
// OBSOLETE   {"in", IN},
// OBSOLETE   {"or", LOGIOR},
// OBSOLETE   {"up", UP},
// OBSOLETE   {"addr", ADDR_TOKEN},
// OBSOLETE   {"null", EMPTINESS_LITERAL}
// OBSOLETE };
// OBSOLETE 
// OBSOLETE static const struct token tokentab2[] =
// OBSOLETE {
// OBSOLETE   {":=", GDB_ASSIGNMENT},
// OBSOLETE   {"//", SLASH_SLASH},
// OBSOLETE   {"->", POINTER},
// OBSOLETE   {"/=", NOTEQUAL},
// OBSOLETE   {"<=", LEQ},
// OBSOLETE   {">=", GEQ}
// OBSOLETE };
// OBSOLETE 
// OBSOLETE /* Read one token, getting characters through lexptr.  */
// OBSOLETE /* This is where we will check to make sure that the language and the
// OBSOLETE    operators used are compatible.  */
// OBSOLETE 
// OBSOLETE static enum ch_terminal
// OBSOLETE ch_lex (void)
// OBSOLETE {
// OBSOLETE   unsigned int i;
// OBSOLETE   enum ch_terminal token;
// OBSOLETE   char *inputname;
// OBSOLETE   struct symbol *sym;
// OBSOLETE 
// OBSOLETE   /* Skip over any leading whitespace. */
// OBSOLETE   while (isspace (*lexptr))
// OBSOLETE     {
// OBSOLETE       lexptr++;
// OBSOLETE     }
// OBSOLETE   /* Look for special single character cases which can't be the first
// OBSOLETE      character of some other multicharacter token. */
// OBSOLETE   switch (*lexptr)
// OBSOLETE     {
// OBSOLETE     case '\0':
// OBSOLETE       return END_TOKEN;
// OBSOLETE     case ',':
// OBSOLETE     case '=':
// OBSOLETE     case ';':
// OBSOLETE     case '!':
// OBSOLETE     case '+':
// OBSOLETE     case '*':
// OBSOLETE     case '(':
// OBSOLETE     case ')':
// OBSOLETE     case '[':
// OBSOLETE     case ']':
// OBSOLETE       return (*lexptr++);
// OBSOLETE     }
// OBSOLETE   /* Look for characters which start a particular kind of multicharacter
// OBSOLETE      token, such as a character literal, register name, convenience
// OBSOLETE      variable name, string literal, etc. */
// OBSOLETE   switch (*lexptr)
// OBSOLETE     {
// OBSOLETE     case '\'':
// OBSOLETE     case '\"':
// OBSOLETE       /* First try to match a string literal, which is any
// OBSOLETE          sequence of characters enclosed in matching single or double
// OBSOLETE          quotes, except that a single character inside single quotes
// OBSOLETE          is a character literal, so we have to catch that case also. */
// OBSOLETE       token = match_string_literal ();
// OBSOLETE       if (token != 0)
// OBSOLETE     {
// OBSOLETE       return (token);
// OBSOLETE     }
// OBSOLETE       if (*lexptr == '\'')
// OBSOLETE     {
// OBSOLETE       token = match_character_literal ();
// OBSOLETE       if (token != 0)
// OBSOLETE         {
// OBSOLETE           return (token);
// OBSOLETE         }
// OBSOLETE     }
// OBSOLETE       break;
// OBSOLETE     case 'C':
// OBSOLETE     case 'c':
// OBSOLETE       token = match_character_literal ();
// OBSOLETE       if (token != 0)
// OBSOLETE     {
// OBSOLETE       return (token);
// OBSOLETE     }
// OBSOLETE       break;
// OBSOLETE     case '$':
// OBSOLETE       yylval.sval.ptr = lexptr;
// OBSOLETE       do
// OBSOLETE     {
// OBSOLETE       lexptr++;
// OBSOLETE     }
// OBSOLETE       while (isalnum (*lexptr) || *lexptr == '_' || *lexptr == '$');
// OBSOLETE       yylval.sval.length = lexptr - yylval.sval.ptr;
// OBSOLETE       write_dollar_variable (yylval.sval);
// OBSOLETE       return GDB_VARIABLE;
// OBSOLETE       break;
// OBSOLETE     }
// OBSOLETE   /* See if it is a special token of length 2.  */
// OBSOLETE   for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
// OBSOLETE     {
// OBSOLETE       if (STREQN (lexptr, tokentab2[i].operator, 2))
// OBSOLETE     {
// OBSOLETE       lexptr += 2;
// OBSOLETE       return (tokentab2[i].token);
// OBSOLETE     }
// OBSOLETE     }
// OBSOLETE   /* Look for single character cases which which could be the first
// OBSOLETE      character of some other multicharacter token, but aren't, or we
// OBSOLETE      would already have found it. */
// OBSOLETE   switch (*lexptr)
// OBSOLETE     {
// OBSOLETE     case '-':
// OBSOLETE     case ':':
// OBSOLETE     case '/':
// OBSOLETE     case '<':
// OBSOLETE     case '>':
// OBSOLETE       return (*lexptr++);
// OBSOLETE     }
// OBSOLETE   /* Look for a float literal before looking for an integer literal, so
// OBSOLETE      we match as much of the input stream as possible. */
// OBSOLETE   token = match_float_literal ();
// OBSOLETE   if (token != 0)
// OBSOLETE     {
// OBSOLETE       return (token);
// OBSOLETE     }
// OBSOLETE   token = match_bitstring_literal ();
// OBSOLETE   if (token != 0)
// OBSOLETE     {
// OBSOLETE       return (token);
// OBSOLETE     }
// OBSOLETE   token = match_integer_literal ();
// OBSOLETE   if (token != 0)
// OBSOLETE     {
// OBSOLETE       return (token);
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* Try to match a simple name string, and if a match is found, then
// OBSOLETE      further classify what sort of name it is and return an appropriate
// OBSOLETE      token.  Note that attempting to match a simple name string consumes
// OBSOLETE      the token from lexptr, so we can't back out if we later find that
// OBSOLETE      we can't classify what sort of name it is. */
// OBSOLETE 
// OBSOLETE   inputname = match_simple_name_string ();
// OBSOLETE 
// OBSOLETE   if (inputname != NULL)
// OBSOLETE     {
// OBSOLETE       char *simplename = (char *) alloca (strlen (inputname) + 1);
// OBSOLETE 
// OBSOLETE       char *dptr = simplename, *sptr = inputname;
// OBSOLETE       for (; *sptr; sptr++)
// OBSOLETE     *dptr++ = isupper (*sptr) ? tolower (*sptr) : *sptr;
// OBSOLETE       *dptr = '\0';
// OBSOLETE 
// OBSOLETE       /* See if it is a reserved identifier. */
// OBSOLETE       for (i = 0; i < sizeof (idtokentab) / sizeof (idtokentab[0]); i++)
// OBSOLETE     {
// OBSOLETE       if (STREQ (simplename, idtokentab[i].operator))
// OBSOLETE         {
// OBSOLETE           return (idtokentab[i].token);
// OBSOLETE         }
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE       /* Look for other special tokens. */
// OBSOLETE       if (STREQ (simplename, "true"))
// OBSOLETE     {
// OBSOLETE       yylval.ulval = 1;
// OBSOLETE       return (BOOLEAN_LITERAL);
// OBSOLETE     }
// OBSOLETE       if (STREQ (simplename, "false"))
// OBSOLETE     {
// OBSOLETE       yylval.ulval = 0;
// OBSOLETE       return (BOOLEAN_LITERAL);
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE       sym = lookup_symbol (inputname, expression_context_block,
// OBSOLETE                        VAR_NAMESPACE, (int *) NULL,
// OBSOLETE                        (struct symtab **) NULL);
// OBSOLETE       if (sym == NULL && strcmp (inputname, simplename) != 0)
// OBSOLETE     {
// OBSOLETE       sym = lookup_symbol (simplename, expression_context_block,
// OBSOLETE                            VAR_NAMESPACE, (int *) NULL,
// OBSOLETE                            (struct symtab **) NULL);
// OBSOLETE     }
// OBSOLETE       if (sym != NULL)
// OBSOLETE     {
// OBSOLETE       yylval.ssym.stoken.ptr = NULL;
// OBSOLETE       yylval.ssym.stoken.length = 0;
// OBSOLETE       yylval.ssym.sym = sym;
// OBSOLETE       yylval.ssym.is_a_field_of_this = 0;   /* FIXME, C++'ism */
// OBSOLETE       switch (SYMBOL_CLASS (sym))
// OBSOLETE         {
// OBSOLETE         case LOC_BLOCK:
// OBSOLETE           /* Found a procedure name. */
// OBSOLETE           return (GENERAL_PROCEDURE_NAME);
// OBSOLETE         case LOC_STATIC:
// OBSOLETE           /* Found a global or local static variable. */
// OBSOLETE           return (LOCATION_NAME);
// OBSOLETE         case LOC_REGISTER:
// OBSOLETE         case LOC_ARG:
// OBSOLETE         case LOC_REF_ARG:
// OBSOLETE         case LOC_REGPARM:
// OBSOLETE         case LOC_REGPARM_ADDR:
// OBSOLETE         case LOC_LOCAL:
// OBSOLETE         case LOC_LOCAL_ARG:
// OBSOLETE         case LOC_BASEREG:
// OBSOLETE         case LOC_BASEREG_ARG:
// OBSOLETE           if (innermost_block == NULL
// OBSOLETE               || contained_in (block_found, innermost_block))
// OBSOLETE             {
// OBSOLETE               innermost_block = block_found;
// OBSOLETE             }
// OBSOLETE           return (LOCATION_NAME);
// OBSOLETE           break;
// OBSOLETE         case LOC_CONST:
// OBSOLETE         case LOC_LABEL:
// OBSOLETE           return (LOCATION_NAME);
// OBSOLETE           break;
// OBSOLETE         case LOC_TYPEDEF:
// OBSOLETE           yylval.tsym.type = SYMBOL_TYPE (sym);
// OBSOLETE           return TYPENAME;
// OBSOLETE         case LOC_UNDEF:
// OBSOLETE         case LOC_CONST_BYTES:
// OBSOLETE         case LOC_OPTIMIZED_OUT:
// OBSOLETE           error ("Symbol \"%s\" names no location.", inputname);
// OBSOLETE           break;
// OBSOLETE         default:
// OBSOLETE           internal_error (__FILE__, __LINE__,
// OBSOLETE                           "unhandled SYMBOL_CLASS in ch_lex()");
// OBSOLETE           break;
// OBSOLETE         }
// OBSOLETE     }
// OBSOLETE       else if (!have_full_symbols () && !have_partial_symbols ())
// OBSOLETE     {
// OBSOLETE       error ("No symbol table is loaded.  Use the \"file\" command.");
// OBSOLETE     }
// OBSOLETE       else
// OBSOLETE     {
// OBSOLETE       error ("No symbol \"%s\" in current context.", inputname);
// OBSOLETE     }
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   /* Catch single character tokens which are not part of some
// OBSOLETE      longer token. */
// OBSOLETE 
// OBSOLETE   switch (*lexptr)
// OBSOLETE     {
// OBSOLETE     case '.':                       /* Not float for example. */
// OBSOLETE       lexptr++;
// OBSOLETE       while (isspace (*lexptr))
// OBSOLETE     lexptr++;
// OBSOLETE       inputname = match_simple_name_string ();
// OBSOLETE       if (!inputname)
// OBSOLETE     return '.';
// OBSOLETE       return DOT_FIELD_NAME;
// OBSOLETE     }
// OBSOLETE 
// OBSOLETE   return (ILLEGAL_TOKEN);
// OBSOLETE }
// OBSOLETE 
// OBSOLETE static void
// OBSOLETE write_lower_upper_value (enum exp_opcode opcode,    /* Either UNOP_LOWER or UNOP_UPPER */
// OBSOLETE                      struct type *type)
// OBSOLETE {
// OBSOLETE   if (type == NULL)
// OBSOLETE     write_exp_elt_opcode (opcode);
// OBSOLETE   else
// OBSOLETE     {
// OBSOLETE       struct type *result_type;
// OBSOLETE       LONGEST val = type_lower_upper (opcode, type, &result_type);
// OBSOLETE       write_exp_elt_opcode (OP_LONG);
// OBSOLETE       write_exp_elt_type (result_type);
// OBSOLETE       write_exp_elt_longcst (val);
// OBSOLETE       write_exp_elt_opcode (OP_LONG);
// OBSOLETE     }
// OBSOLETE }
// OBSOLETE 
// OBSOLETE void
// OBSOLETE chill_error (char *msg)
// OBSOLETE {
// OBSOLETE   /* Never used. */
// OBSOLETE }

Line No.	Rev	Author	Line
1	1181	sfurman	`// OBSOLETE /* Parser for GNU CHILL (CCITT High-Level Language) -- C --`
2			`// OBSOLETE Copyright 1992, 1993, 1995, 1996, 1997, 1999, 2000, 2001`
3			`// OBSOLETE Free Software Foundation, Inc.`
4			`// OBSOLETE`
5			`// OBSOLETE This file is part of GDB.`
6			`// OBSOLETE`
7			`// OBSOLETE This program is free software; you can redistribute it and/or modify`
8			`// OBSOLETE it under the terms of the GNU General Public License as published by`
9			`// OBSOLETE the Free Software Foundation; either version 2 of the License, or`
10			`// OBSOLETE (at your option) any later version.`
11			`// OBSOLETE`
12			`// OBSOLETE This program is distributed in the hope that it will be useful,`
13			`// OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`// OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`// OBSOLETE GNU General Public License for more details.`
16			`// OBSOLETE`
17			`// OBSOLETE You should have received a copy of the GNU General Public License`
18			`// OBSOLETE along with this program; if not, write to the Free Software`
19			`// OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330,`
20			`// OBSOLETE Boston, MA 02111-1307, USA. */`
21			`// OBSOLETE`
22			`// OBSOLETE /* Parse a Chill expression from text in a string,`
23			`// OBSOLETE and return the result as a struct expression pointer.`
24			`// OBSOLETE That structure contains arithmetic operations in reverse polish,`
25			`// OBSOLETE with constants represented by operations that are followed by special data.`
26			`// OBSOLETE See expression.h for the details of the format.`
27			`// OBSOLETE What is important here is that it can be built up sequentially`
28			`// OBSOLETE during the process of parsing; the lower levels of the tree always`
29			`// OBSOLETE come first in the result.`
30			`// OBSOLETE`
31			`// OBSOLETE Note that the language accepted by this parser is more liberal`
32			`// OBSOLETE than the one accepted by an actual Chill compiler. For example, the`
33			`// OBSOLETE language rule that a simple name string can not be one of the reserved`
34			`// OBSOLETE simple name strings is not enforced (e.g "case" is not treated as a`
35			`// OBSOLETE reserved name). Another example is that Chill is a strongly typed`
36			`// OBSOLETE language, and certain expressions that violate the type constraints`
37			`// OBSOLETE may still be evaluated if gdb can do so in a meaningful manner, while`
38			`// OBSOLETE such expressions would be rejected by the compiler. The reason for`
39			`// OBSOLETE this more liberal behavior is the philosophy that the debugger`
40			`// OBSOLETE is intended to be a tool that is used by the programmer when things`
41			`// OBSOLETE go wrong, and as such, it should provide as few artificial barriers`
42			`// OBSOLETE to it's use as possible. If it can do something meaningful, even`
43			`// OBSOLETE something that violates language contraints that are enforced by the`
44			`// OBSOLETE compiler, it should do so without complaint.`
45			`// OBSOLETE`
46			`// OBSOLETE */`
47			`// OBSOLETE`
48			`// OBSOLETE #include "defs.h"`
49			`// OBSOLETE #include "gdb_string.h"`
50			`// OBSOLETE #include <ctype.h>`
51			`// OBSOLETE #include "expression.h"`
52			`// OBSOLETE #include "language.h"`
53			`// OBSOLETE #include "value.h"`
54			`// OBSOLETE #include "parser-defs.h"`
55			`// OBSOLETE #include "ch-lang.h"`
56			`// OBSOLETE #include "bfd.h" /* Required by objfiles.h. */`
57			`// OBSOLETE #include "symfile.h" /* Required by objfiles.h. */`
58			`// OBSOLETE #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */`
59			`// OBSOLETE`
60			`// OBSOLETE #ifdef __GNUC__`
61			`// OBSOLETE #define INLINE __inline__`
62			`// OBSOLETE #endif`
63			`// OBSOLETE`
64			`// OBSOLETE typedef union`
65			`// OBSOLETE`
66			`// OBSOLETE {`
67			`// OBSOLETE LONGEST lval;`
68			`// OBSOLETE ULONGEST ulval;`
69			`// OBSOLETE struct`
70			`// OBSOLETE {`
71			`// OBSOLETE LONGEST val;`
72			`// OBSOLETE struct type *type;`
73			`// OBSOLETE }`
74			`// OBSOLETE typed_val;`
75			`// OBSOLETE double dval;`
76			`// OBSOLETE struct symbol *sym;`
77			`// OBSOLETE struct type *tval;`
78			`// OBSOLETE struct stoken sval;`
79			`// OBSOLETE struct ttype tsym;`
80			`// OBSOLETE struct symtoken ssym;`
81			`// OBSOLETE }`
82			`// OBSOLETE YYSTYPE;`
83			`// OBSOLETE`
84			`// OBSOLETE enum ch_terminal`
85			`// OBSOLETE {`
86			`// OBSOLETE END_TOKEN = 0,`
87			`// OBSOLETE /* '\001' ... '\xff' come first. */`
88			`// OBSOLETE OPEN_PAREN = '(',`
89			`// OBSOLETE TOKEN_NOT_READ = 999,`
90			`// OBSOLETE INTEGER_LITERAL,`
91			`// OBSOLETE BOOLEAN_LITERAL,`
92			`// OBSOLETE CHARACTER_LITERAL,`
93			`// OBSOLETE FLOAT_LITERAL,`
94			`// OBSOLETE GENERAL_PROCEDURE_NAME,`
95			`// OBSOLETE LOCATION_NAME,`
96			`// OBSOLETE EMPTINESS_LITERAL,`
97			`// OBSOLETE CHARACTER_STRING_LITERAL,`
98			`// OBSOLETE BIT_STRING_LITERAL,`
99			`// OBSOLETE TYPENAME,`
100			`// OBSOLETE DOT_FIELD_NAME, /* '.' followed by <field name> */`
101			`// OBSOLETE CASE,`
102			`// OBSOLETE OF,`
103			`// OBSOLETE ESAC,`
104			`// OBSOLETE LOGIOR,`
105			`// OBSOLETE ORIF,`
106			`// OBSOLETE LOGXOR,`
107			`// OBSOLETE LOGAND,`
108			`// OBSOLETE ANDIF,`
109			`// OBSOLETE NOTEQUAL,`
110			`// OBSOLETE GEQ,`
111			`// OBSOLETE LEQ,`
112			`// OBSOLETE IN,`
113			`// OBSOLETE SLASH_SLASH,`
114			`// OBSOLETE MOD,`
115			`// OBSOLETE REM,`
116			`// OBSOLETE NOT,`
117			`// OBSOLETE POINTER,`
118			`// OBSOLETE RECEIVE,`
119			`// OBSOLETE UP,`
120			`// OBSOLETE IF,`
121			`// OBSOLETE THEN,`
122			`// OBSOLETE ELSE,`
123			`// OBSOLETE FI,`
124			`// OBSOLETE ELSIF,`
125			`// OBSOLETE ILLEGAL_TOKEN,`
126			`// OBSOLETE NUM,`
127			`// OBSOLETE PRED,`
128			`// OBSOLETE SUCC,`
129			`// OBSOLETE ABS,`
130			`// OBSOLETE CARD,`
131			`// OBSOLETE MAX_TOKEN,`
132			`// OBSOLETE MIN_TOKEN,`
133			`// OBSOLETE ADDR_TOKEN,`
134			`// OBSOLETE SIZE,`
135			`// OBSOLETE UPPER,`
136			`// OBSOLETE LOWER,`
137			`// OBSOLETE LENGTH,`
138			`// OBSOLETE ARRAY,`
139			`// OBSOLETE GDB_VARIABLE,`
140			`// OBSOLETE GDB_ASSIGNMENT`
141			`// OBSOLETE };`
142			`// OBSOLETE`
143			`// OBSOLETE /* Forward declarations. */`
144			`// OBSOLETE`
145			`// OBSOLETE static void write_lower_upper_value (enum exp_opcode, struct type *);`
146			`// OBSOLETE static enum ch_terminal match_bitstring_literal (void);`
147			`// OBSOLETE static enum ch_terminal match_integer_literal (void);`
148			`// OBSOLETE static enum ch_terminal match_character_literal (void);`
149			`// OBSOLETE static enum ch_terminal match_string_literal (void);`
150			`// OBSOLETE static enum ch_terminal match_float_literal (void);`
151			`// OBSOLETE static int decode_integer_literal (LONGEST , char *);`
152			`// OBSOLETE static int decode_integer_value (int, char *, LONGEST );`
153			`// OBSOLETE static char *match_simple_name_string (void);`
154			`// OBSOLETE static void growbuf_by_size (int);`
155			`// OBSOLETE static void parse_case_label (void);`
156			`// OBSOLETE static void parse_untyped_expr (void);`
157			`// OBSOLETE static void parse_if_expression (void);`
158			`// OBSOLETE static void parse_if_expression_body (void);`
159			`// OBSOLETE static void parse_else_alternative (void);`
160			`// OBSOLETE static void parse_then_alternative (void);`
161			`// OBSOLETE static void parse_expr (void);`
162			`// OBSOLETE static void parse_operand0 (void);`
163			`// OBSOLETE static void parse_operand1 (void);`
164			`// OBSOLETE static void parse_operand2 (void);`
165			`// OBSOLETE static void parse_operand3 (void);`
166			`// OBSOLETE static void parse_operand4 (void);`
167			`// OBSOLETE static void parse_operand5 (void);`
168			`// OBSOLETE static void parse_operand6 (void);`
169			`// OBSOLETE static void parse_primval (void);`
170			`// OBSOLETE static void parse_tuple (struct type *);`
171			`// OBSOLETE static void parse_opt_element_list (struct type *);`
172			`// OBSOLETE static void parse_tuple_element (struct type *);`
173			`// OBSOLETE static void parse_named_record_element (void);`
174			`// OBSOLETE static void parse_call (void);`
175			`// OBSOLETE static struct type *parse_mode_or_normal_call (void);`
176			`// OBSOLETE #if 0`
177			`// OBSOLETE static struct type *parse_mode_call (void);`
178			`// OBSOLETE #endif`
179			`// OBSOLETE static void parse_unary_call (void);`
180			`// OBSOLETE static int parse_opt_untyped_expr (void);`
181			`// OBSOLETE static int expect (enum ch_terminal, char *);`
182			`// OBSOLETE static enum ch_terminal ch_lex (void);`
183			`// OBSOLETE INLINE static enum ch_terminal PEEK_TOKEN (void);`
184			`// OBSOLETE static enum ch_terminal peek_token_ (int);`
185			`// OBSOLETE static void forward_token_ (void);`
186			`// OBSOLETE static void require (enum ch_terminal);`
187			`// OBSOLETE static int check_token (enum ch_terminal);`
188			`// OBSOLETE`
189			`// OBSOLETE #define MAX_LOOK_AHEAD 2`
190			`// OBSOLETE static enum ch_terminal terminal_buffer[MAX_LOOK_AHEAD + 1] =`
191			`// OBSOLETE {`
192			`// OBSOLETE TOKEN_NOT_READ, TOKEN_NOT_READ, TOKEN_NOT_READ};`
193			`// OBSOLETE static YYSTYPE yylval;`
194			`// OBSOLETE static YYSTYPE val_buffer[MAX_LOOK_AHEAD + 1];`
195			`// OBSOLETE`
196			`// OBSOLETE /int current_token, lookahead_token; /`
197			`// OBSOLETE`
198			`// OBSOLETE INLINE static enum ch_terminal`
199			`// OBSOLETE PEEK_TOKEN (void)`
200			`// OBSOLETE {`
201			`// OBSOLETE if (terminal_buffer[0] == TOKEN_NOT_READ)`
202			`// OBSOLETE {`
203			`// OBSOLETE terminal_buffer[0] = ch_lex ();`
204			`// OBSOLETE val_buffer[0] = yylval;`
205			`// OBSOLETE }`
206			`// OBSOLETE return terminal_buffer[0];`
207			`// OBSOLETE }`
208			`// OBSOLETE #define PEEK_LVAL() val_buffer[0]`
209			`// OBSOLETE #define PEEK_TOKEN1() peek_token_(1)`
210			`// OBSOLETE #define PEEK_TOKEN2() peek_token_(2)`
211			`// OBSOLETE static enum ch_terminal`
212			`// OBSOLETE peek_token_ (int i)`
213			`// OBSOLETE {`
214			`// OBSOLETE if (i > MAX_LOOK_AHEAD)`
215			`// OBSOLETE internal_error (__FILE__, __LINE__,`
216			`// OBSOLETE "too much lookahead");`
217			`// OBSOLETE if (terminal_buffer[i] == TOKEN_NOT_READ)`
218			`// OBSOLETE {`
219			`// OBSOLETE terminal_buffer[i] = ch_lex ();`
220			`// OBSOLETE val_buffer[i] = yylval;`
221			`// OBSOLETE }`
222			`// OBSOLETE return terminal_buffer[i];`
223			`// OBSOLETE }`
224			`// OBSOLETE`
225			`// OBSOLETE #if 0`
226			`// OBSOLETE`
227			`// OBSOLETE static void`
228			`// OBSOLETE pushback_token (enum ch_terminal code, YYSTYPE node)`
229			`// OBSOLETE {`
230			`// OBSOLETE int i;`
231			`// OBSOLETE if (terminal_buffer[MAX_LOOK_AHEAD] != TOKEN_NOT_READ)`
232			`// OBSOLETE internal_error (__FILE__, __LINE__,`
233			`// OBSOLETE "cannot pushback token");`
234			`// OBSOLETE for (i = MAX_LOOK_AHEAD; i > 0; i--)`
235			`// OBSOLETE {`
236			`// OBSOLETE terminal_buffer[i] = terminal_buffer[i - 1];`
237			`// OBSOLETE val_buffer[i] = val_buffer[i - 1];`
238			`// OBSOLETE }`
239			`// OBSOLETE terminal_buffer[0] = code;`
240			`// OBSOLETE val_buffer[0] = node;`
241			`// OBSOLETE }`
242			`// OBSOLETE`
243			`// OBSOLETE #endif`
244			`// OBSOLETE`
245			`// OBSOLETE static void`
246			`// OBSOLETE forward_token_ (void)`
247			`// OBSOLETE {`
248			`// OBSOLETE int i;`
249			`// OBSOLETE for (i = 0; i < MAX_LOOK_AHEAD; i++)`
250			`// OBSOLETE {`
251			`// OBSOLETE terminal_buffer[i] = terminal_buffer[i + 1];`
252			`// OBSOLETE val_buffer[i] = val_buffer[i + 1];`
253			`// OBSOLETE }`
254			`// OBSOLETE terminal_buffer[MAX_LOOK_AHEAD] = TOKEN_NOT_READ;`
255			`// OBSOLETE }`
256			`// OBSOLETE #define FORWARD_TOKEN() forward_token_()`
257			`// OBSOLETE`
258			`// OBSOLETE /* Skip the next token.`
259			`// OBSOLETE if it isn't TOKEN, the parser is broken. */`
260			`// OBSOLETE`
261			`// OBSOLETE static void`
262			`// OBSOLETE require (enum ch_terminal token)`
263			`// OBSOLETE {`
264			`// OBSOLETE if (PEEK_TOKEN () != token)`
265			`// OBSOLETE {`
266			`// OBSOLETE internal_error (__FILE__, __LINE__,`
267			`// OBSOLETE "expected token %d", (int) token);`
268			`// OBSOLETE }`
269			`// OBSOLETE FORWARD_TOKEN ();`
270			`// OBSOLETE }`
271			`// OBSOLETE`
272			`// OBSOLETE static int`
273			`// OBSOLETE check_token (enum ch_terminal token)`
274			`// OBSOLETE {`
275			`// OBSOLETE if (PEEK_TOKEN () != token)`
276			`// OBSOLETE return 0;`
277			`// OBSOLETE FORWARD_TOKEN ();`
278			`// OBSOLETE return 1;`
279			`// OBSOLETE }`
280			`// OBSOLETE`
281			`// OBSOLETE /* return 0 if expected token was not found,`
282			`// OBSOLETE else return 1.`
283			`// OBSOLETE */`
284			`// OBSOLETE static int`
285			`// OBSOLETE expect (enum ch_terminal token, char *message)`
286			`// OBSOLETE {`
287			`// OBSOLETE if (PEEK_TOKEN () != token)`
288			`// OBSOLETE {`
289			`// OBSOLETE if (message)`
290			`// OBSOLETE error (message);`
291			`// OBSOLETE else if (token < 256)`
292			`// OBSOLETE error ("syntax error - expected a '%c' here \"%s\"", token, lexptr);`
293			`// OBSOLETE else`
294			`// OBSOLETE error ("syntax error");`
295			`// OBSOLETE return 0;`
296			`// OBSOLETE }`
297			`// OBSOLETE else`
298			`// OBSOLETE FORWARD_TOKEN ();`
299			`// OBSOLETE return 1;`
300			`// OBSOLETE }`
301			`// OBSOLETE`
302			`// OBSOLETE #if 0`
303			`// OBSOLETE /* Parse a name string. If ALLOW_ALL is 1, ALL is allowed as a postfix. */`
304			`// OBSOLETE`
305			`// OBSOLETE static tree`
306			`// OBSOLETE parse_opt_name_string (int allow_all)`
307			`// OBSOLETE {`
308			`// OBSOLETE int token = PEEK_TOKEN ();`
309			`// OBSOLETE tree name;`
310			`// OBSOLETE if (token != NAME)`
311			`// OBSOLETE {`
312			`// OBSOLETE if (token == ALL && allow_all)`
313			`// OBSOLETE {`
314			`// OBSOLETE FORWARD_TOKEN ();`
315			`// OBSOLETE return ALL_POSTFIX;`
316			`// OBSOLETE }`
317			`// OBSOLETE return NULL_TREE;`
318			`// OBSOLETE }`
319			`// OBSOLETE name = PEEK_LVAL ();`
320			`// OBSOLETE for (;;)`
321			`// OBSOLETE {`
322			`// OBSOLETE FORWARD_TOKEN ();`
323			`// OBSOLETE token = PEEK_TOKEN ();`
324			`// OBSOLETE if (token != '!')`
325			`// OBSOLETE return name;`
326			`// OBSOLETE FORWARD_TOKEN ();`
327			`// OBSOLETE token = PEEK_TOKEN ();`
328			`// OBSOLETE if (token == ALL && allow_all)`
329			`// OBSOLETE return get_identifier3 (IDENTIFIER_POINTER (name), "!", "*");`
330			`// OBSOLETE if (token != NAME)`
331			`// OBSOLETE {`
332			`// OBSOLETE if (pass == 1)`
333			`// OBSOLETE error ("'%s!' is not followed by an identifier",`
334			`// OBSOLETE IDENTIFIER_POINTER (name));`
335			`// OBSOLETE return name;`
336			`// OBSOLETE }`
337			`// OBSOLETE name = get_identifier3 (IDENTIFIER_POINTER (name),`
338			`// OBSOLETE "!", IDENTIFIER_POINTER (PEEK_LVAL ()));`
339			`// OBSOLETE }`
340			`// OBSOLETE }`
341			`// OBSOLETE`
342			`// OBSOLETE static tree`
343			`// OBSOLETE parse_simple_name_string (void)`
344			`// OBSOLETE {`
345			`// OBSOLETE int token = PEEK_TOKEN ();`
346			`// OBSOLETE tree name;`
347			`// OBSOLETE if (token != NAME)`
348			`// OBSOLETE {`
349			`// OBSOLETE error ("expected a name here");`
350			`// OBSOLETE return error_mark_node;`
351			`// OBSOLETE }`
352			`// OBSOLETE name = PEEK_LVAL ();`
353			`// OBSOLETE FORWARD_TOKEN ();`
354			`// OBSOLETE return name;`
355			`// OBSOLETE }`
356			`// OBSOLETE`
357			`// OBSOLETE static tree`
358			`// OBSOLETE parse_name_string (void)`
359			`// OBSOLETE {`
360			`// OBSOLETE tree name = parse_opt_name_string (0);`
361			`// OBSOLETE if (name)`
362			`// OBSOLETE return name;`
363			`// OBSOLETE if (pass == 1)`
364			`// OBSOLETE error ("expected a name string here");`
365			`// OBSOLETE return error_mark_node;`
366			`// OBSOLETE }`
367			`// OBSOLETE`
368			`// OBSOLETE /* Matches: <name_string>`
369			`// OBSOLETE Returns if pass 1: the identifier.`
370			`// OBSOLETE Returns if pass 2: a decl or value for identifier. */`
371			`// OBSOLETE`
372			`// OBSOLETE static tree`
373			`// OBSOLETE parse_name (void)`
374			`// OBSOLETE {`
375			`// OBSOLETE tree name = parse_name_string ();`
376			`// OBSOLETE if (pass == 1 \|\| ignoring)`
377			`// OBSOLETE return name;`
378			`// OBSOLETE else`
379			`// OBSOLETE {`
380			`// OBSOLETE tree decl = lookup_name (name);`
381			`// OBSOLETE if (decl == NULL_TREE)`
382			`// OBSOLETE {`
383			// OBSOLETE error ("`%s' undeclared", IDENTIFIER_POINTER (name));
384			`// OBSOLETE return error_mark_node;`
385			`// OBSOLETE }`
386			`// OBSOLETE else if (TREE_CODE (TREE_TYPE (decl)) == ERROR_MARK)`
387			`// OBSOLETE return error_mark_node;`
388			`// OBSOLETE else if (TREE_CODE (decl) == CONST_DECL)`
389			`// OBSOLETE return DECL_INITIAL (decl);`
390			`// OBSOLETE else if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)`
391			`// OBSOLETE return convert_from_reference (decl);`
392			`// OBSOLETE else`
393			`// OBSOLETE return decl;`
394			`// OBSOLETE }`
395			`// OBSOLETE }`
396			`// OBSOLETE #endif`
397			`// OBSOLETE`
398			`// OBSOLETE #if 0`
399			`// OBSOLETE static void`
400			`// OBSOLETE pushback_paren_expr (tree expr)`
401			`// OBSOLETE {`
402			`// OBSOLETE if (pass == 1 && !ignoring)`
403			`// OBSOLETE expr = build1 (PAREN_EXPR, NULL_TREE, expr);`
404			`// OBSOLETE pushback_token (EXPR, expr);`
405			`// OBSOLETE }`
406			`// OBSOLETE #endif`
407			`// OBSOLETE`
408			`// OBSOLETE /* Matches: <case label> */`
409			`// OBSOLETE`
410			`// OBSOLETE static void`
411			`// OBSOLETE parse_case_label (void)`
412			`// OBSOLETE {`
413			`// OBSOLETE if (check_token (ELSE))`
414			`// OBSOLETE error ("ELSE in tuples labels not implemented");`
415			`// OBSOLETE /* Does not handle the case of a mode name. FIXME */`
416			`// OBSOLETE parse_expr ();`
417			`// OBSOLETE if (check_token (':'))`
418			`// OBSOLETE {`
419			`// OBSOLETE parse_expr ();`
420			`// OBSOLETE write_exp_elt_opcode (BINOP_RANGE);`
421			`// OBSOLETE }`
422			`// OBSOLETE }`
423			`// OBSOLETE`
424			`// OBSOLETE static int`
425			`// OBSOLETE parse_opt_untyped_expr (void)`
426			`// OBSOLETE {`
427			`// OBSOLETE switch (PEEK_TOKEN ())`
428			`// OBSOLETE {`
429			`// OBSOLETE case ',':`
430			`// OBSOLETE case ':':`
431			`// OBSOLETE case ')':`
432			`// OBSOLETE return 0;`
433			`// OBSOLETE default:`
434			`// OBSOLETE parse_untyped_expr ();`
435			`// OBSOLETE return 1;`
436			`// OBSOLETE }`
437			`// OBSOLETE }`
438			`// OBSOLETE`
439			`// OBSOLETE static void`
440			`// OBSOLETE parse_unary_call (void)`
441			`// OBSOLETE {`
442			`// OBSOLETE FORWARD_TOKEN ();`
443			`// OBSOLETE expect ('(', NULL);`
444			`// OBSOLETE parse_expr ();`
445			`// OBSOLETE expect (')', NULL);`
446			`// OBSOLETE }`
447			`// OBSOLETE`
448			`// OBSOLETE /* Parse NAME '(' MODENAME ')'. */`
449			`// OBSOLETE`
450			`// OBSOLETE #if 0`
451			`// OBSOLETE`
452			`// OBSOLETE static struct type *`
453			`// OBSOLETE parse_mode_call (void)`
454			`// OBSOLETE {`
455			`// OBSOLETE struct type *type;`
456			`// OBSOLETE FORWARD_TOKEN ();`
457			`// OBSOLETE expect ('(', NULL);`
458			`// OBSOLETE if (PEEK_TOKEN () != TYPENAME)`
459			// OBSOLETE error ("expect MODENAME here `%s'", lexptr);
460			`// OBSOLETE type = PEEK_LVAL ().tsym.type;`
461			`// OBSOLETE FORWARD_TOKEN ();`
462			`// OBSOLETE expect (')', NULL);`
463			`// OBSOLETE return type;`
464			`// OBSOLETE }`
465			`// OBSOLETE`
466			`// OBSOLETE #endif`
467			`// OBSOLETE`
468			`// OBSOLETE static struct type *`
469			`// OBSOLETE parse_mode_or_normal_call (void)`
470			`// OBSOLETE {`
471			`// OBSOLETE struct type *type;`
472			`// OBSOLETE FORWARD_TOKEN ();`
473			`// OBSOLETE expect ('(', NULL);`
474			`// OBSOLETE if (PEEK_TOKEN () == TYPENAME)`
475			`// OBSOLETE {`
476			`// OBSOLETE type = PEEK_LVAL ().tsym.type;`
477			`// OBSOLETE FORWARD_TOKEN ();`
478			`// OBSOLETE }`
479			`// OBSOLETE else`
480			`// OBSOLETE {`
481			`// OBSOLETE parse_expr ();`
482			`// OBSOLETE type = NULL;`
483			`// OBSOLETE }`
484			`// OBSOLETE expect (')', NULL);`
485			`// OBSOLETE return type;`
486			`// OBSOLETE }`
487			`// OBSOLETE`
488			`// OBSOLETE /* Parse something that looks like a function call.`
489			`// OBSOLETE Assume we have parsed the function, and are at the '('. */`
490			`// OBSOLETE`
491			`// OBSOLETE static void`
492			`// OBSOLETE parse_call (void)`
493			`// OBSOLETE {`
494			`// OBSOLETE int arg_count;`
495			`// OBSOLETE require ('(');`
496			`// OBSOLETE /* This is to save the value of arglist_len`
497			`// OBSOLETE being accumulated for each dimension. */`
498			`// OBSOLETE start_arglist ();`
499			`// OBSOLETE if (parse_opt_untyped_expr ())`
500			`// OBSOLETE {`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [VER_5_3/] [gdb-5.3/] [gdb/] [ch-exp.c] - Blame information for rev 1782