2002-12-16 Andrew Cagney <ac131313@redhat.com>

	* config/arc/arc.mt, config/arc/tm-arc.h: Delete.
	* config/d30v/d30v.mt, config/d30v/tm-d30v.h: Delete.
	* config/fr30/fr30.mt, config/fr30/tm-fr30.h: Delete.
	* config/i386/i386aix.mh, config/i386/i386aix.mt: Delete.
	* config/i386/i386m3.mh, config/i386/i386m3.mt: Delete.
	* config/i386/i386mach.mh, config/i386/i386os9k.mt: Delete.
	* config/i386/nm-i386aix.h, config/i386/nm-i386mach.h: Delete.
	* config/i386/nm-m3.h, config/i386/tm-i386aix.h: Delete.
	* config/i386/tm-i386m3.h, config/i386/tm-i386mk.h: Delete.
	* config/i386/xm-i386aix.h, config/i386/xm-i386m3.h: Delete.
	* config/i386/xm-i386mach.h, config/i386/xm-i386mk.h: Delete.
	* config/i960/mon960.mt, config/i960/nindy960.mt: Delete.
	* config/i960/tm-i960.h, config/i960/tm-mon960.h: Delete.
	* config/i960/tm-nindy960.h, config/i960/tm-vx960.h: Delete.
	* config/i960/vxworks960.mt, config/m68k/apollo68b.mh: Delete.
	* config/m68k/apollo68b.mt, config/m68k/apollo68v.mh: Delete.
	* config/m68k/hp300bsd.mh, config/m68k/hp300bsd.mt: Delete.
	* config/m68k/hp300hpux.mh, config/m68k/hp300hpux.mt: Delete.
	* config/m88k/delta88.mh, config/m88k/delta88.mt: Delete.
	* config/m88k/delta88v4.mh, config/m88k/delta88v4.mt: Delete.
	* config/m88k/m88k.mh, config/m88k/m88k.mt: Delete.
	* config/m88k/nm-delta88v4.h, config/m88k/nm-m88k.h: Delete.
	* config/m88k/tm-delta88.h, config/m88k/tm-delta88v4.h: Delete.
	* config/m88k/tm-m88k.h, config/m88k/xm-delta88.h: Delete.
	* config/m88k/xm-dgux.h: Delete.
	* fr30-tdep.c, i386aix-nat.c, i386m3-nat.c: Delete.
	* i386mach-nat.c, i960-tdep.c, m88k-nat.c: Delete.
	* os9kread.c, remote-bug.c, remote-nindy.c: Delete.
	* remote-nrom.c, remote-os9k.c, remote-vx960.c: Delete.
	* d30v-tdep.c, arc-tdep.c, cxux-nat.c, dst.h, dstread.c: Delete.
	* ch-exp.c, ch-lang.c, ch-lang.h, ch-typeprint.c: Delete.
	* ch-valprint.c: Delete.

1 files changed, 0 insertions, 2233 deletions

diff --git a/gdb/ch-exp.c b/gdb/ch-exp.c
deleted file mode 100644
index d588ec2..0000000
--- a/gdb/ch-exp.c
+++ /dev/null
@@ -1,2233 +0,0 @@
-// 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 }