| // 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, ©); |
| // 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 } |