OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
binutils-gdb/gdb/ch-exp.c

2234 lines
76 KiB
C
Raw Blame History

// 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 }
Reference in New Issue View Git Blame Copy Permalink