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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [ch-exp.c] - Diff between revs 105 and 1765

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 105	Rev 1765
`/* Parser for GNU CHILL (CCITT High-Level Language) -- C --`	`/* Parser for GNU CHILL (CCITT High-Level Language) -- C --`
`Copyright (C) 1992, 1993, 1995 Free Software Foundation, Inc.`	`Copyright (C) 1992, 1993, 1995 Free Software Foundation, Inc.`

`This file is part of GDB.`	`This file is part of GDB.`

`This program is free software; you can redistribute it and/or modify`	`This program is free software; you can redistribute it and/or modify`
`it under the terms of the GNU General Public License as published by`	`it under the terms of the GNU General Public License as published by`
`the Free Software Foundation; either version 2 of the License, or`	`the Free Software Foundation; either version 2 of the License, or`
`(at your option) any later version.`	`(at your option) any later version.`

`This program is distributed in the hope that it will be useful,`	`This program is distributed in the hope that it will be useful,`
`but WITHOUT ANY WARRANTY; without even the implied warranty of`	`but WITHOUT ANY WARRANTY; without even the implied warranty of`
`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`	`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
`GNU General Public License for more details.`	`GNU General Public License for more details.`

`You should have received a copy of the GNU General Public License`	`You should have received a copy of the GNU General Public License`
`along with this program; if not, write to the Free Software`	`along with this program; if not, write to the Free Software`
`Foundation, Inc., 59 Temple Place - Suite 330,`	`Foundation, Inc., 59 Temple Place - Suite 330,`
`Boston, MA 02111-1307, USA. */`	`Boston, MA 02111-1307, USA. */`

`/* Parse a Chill expression from text in a string,`	`/* Parse a Chill expression from text in a string,`
`and return the result as a struct expression pointer.`	`and return the result as a struct expression pointer.`
`That structure contains arithmetic operations in reverse polish,`	`That structure contains arithmetic operations in reverse polish,`
`with constants represented by operations that are followed by special data.`	`with constants represented by operations that are followed by special data.`
`See expression.h for the details of the format.`	`See expression.h for the details of the format.`
`What is important here is that it can be built up sequentially`	`What is important here is that it can be built up sequentially`
`during the process of parsing; the lower levels of the tree always`	`during the process of parsing; the lower levels of the tree always`
`come first in the result.`	`come first in the result.`

`Note that the language accepted by this parser is more liberal`	`Note that the language accepted by this parser is more liberal`
`than the one accepted by an actual Chill compiler. For example, the`	`than the one accepted by an actual Chill compiler. For example, the`
`language rule that a simple name string can not be one of the reserved`	`language rule that a simple name string can not be one of the reserved`
`simple name strings is not enforced (e.g "case" is not treated as a`	`simple name strings is not enforced (e.g "case" is not treated as a`
`reserved name). Another example is that Chill is a strongly typed`	`reserved name). Another example is that Chill is a strongly typed`
`language, and certain expressions that violate the type constraints`	`language, and certain expressions that violate the type constraints`
`may still be evaluated if gdb can do so in a meaningful manner, while`	`may still be evaluated if gdb can do so in a meaningful manner, while`
`such expressions would be rejected by the compiler. The reason for`	`such expressions would be rejected by the compiler. The reason for`
`this more liberal behavior is the philosophy that the debugger`	`this more liberal behavior is the philosophy that the debugger`
`is intended to be a tool that is used by the programmer when things`	`is intended to be a tool that is used by the programmer when things`
`go wrong, and as such, it should provide as few artificial barriers`	`go wrong, and as such, it should provide as few artificial barriers`
`to it's use as possible. If it can do something meaningful, even`	`to it's use as possible. If it can do something meaningful, even`
`something that violates language contraints that are enforced by the`	`something that violates language contraints that are enforced by the`
`compiler, it should do so without complaint.`	`compiler, it should do so without complaint.`

`*/`	`*/`

`#include "defs.h"`	`#include "defs.h"`
`#include "gdb_string.h"`	`#include "gdb_string.h"`
`#include <ctype.h>`	`#include <ctype.h>`
`#include "expression.h"`	`#include "expression.h"`
`#include "language.h"`	`#include "language.h"`
`#include "value.h"`	`#include "value.h"`
`#include "parser-defs.h"`	`#include "parser-defs.h"`
`#include "ch-lang.h"`	`#include "ch-lang.h"`
`#include "bfd.h" /* Required by objfiles.h. */`	`#include "bfd.h" /* Required by objfiles.h. */`
`#include "symfile.h" /* Required by objfiles.h. */`	`#include "symfile.h" /* Required by objfiles.h. */`
`#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */`	`#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */`

`#ifdef __GNUC__`	`#ifdef __GNUC__`
`#define INLINE __inline__`	`#define INLINE __inline__`
`#endif`	`#endif`

`typedef union`	`typedef union`

`{`	`{`
`LONGEST lval;`	`LONGEST lval;`
`ULONGEST ulval;`	`ULONGEST ulval;`
`struct`	`struct`
`{`	`{`
`LONGEST val;`	`LONGEST val;`
`struct type *type;`	`struct type *type;`
`}`	`}`
`typed_val;`	`typed_val;`
`double dval;`	`double dval;`
`struct symbol *sym;`	`struct symbol *sym;`
`struct type *tval;`	`struct type *tval;`
`struct stoken sval;`	`struct stoken sval;`
`struct ttype tsym;`	`struct ttype tsym;`
`struct symtoken ssym;`	`struct symtoken ssym;`
`}`	`}`
`YYSTYPE;`	`YYSTYPE;`

`enum ch_terminal`	`enum ch_terminal`
`{`	`{`
`END_TOKEN = 0,`	`END_TOKEN = 0,`
`/* '\001' ... '\xff' come first. */`	`/* '\001' ... '\xff' come first. */`
`OPEN_PAREN = '(',`	`OPEN_PAREN = '(',`
`TOKEN_NOT_READ = 999,`	`TOKEN_NOT_READ = 999,`
`INTEGER_LITERAL,`	`INTEGER_LITERAL,`
`BOOLEAN_LITERAL,`	`BOOLEAN_LITERAL,`
`CHARACTER_LITERAL,`	`CHARACTER_LITERAL,`
`FLOAT_LITERAL,`	`FLOAT_LITERAL,`
`GENERAL_PROCEDURE_NAME,`	`GENERAL_PROCEDURE_NAME,`
`LOCATION_NAME,`	`LOCATION_NAME,`
`EMPTINESS_LITERAL,`	`EMPTINESS_LITERAL,`
`CHARACTER_STRING_LITERAL,`	`CHARACTER_STRING_LITERAL,`
`BIT_STRING_LITERAL,`	`BIT_STRING_LITERAL,`
`TYPENAME,`	`TYPENAME,`
`DOT_FIELD_NAME, /* '.' followed by <field name> */`	`DOT_FIELD_NAME, /* '.' followed by <field name> */`
`CASE,`	`CASE,`
`OF,`	`OF,`
`ESAC,`	`ESAC,`
`LOGIOR,`	`LOGIOR,`
`ORIF,`	`ORIF,`
`LOGXOR,`	`LOGXOR,`
`LOGAND,`	`LOGAND,`
`ANDIF,`	`ANDIF,`
`NOTEQUAL,`	`NOTEQUAL,`
`GEQ,`	`GEQ,`
`LEQ,`	`LEQ,`
`IN,`	`IN,`
`SLASH_SLASH,`	`SLASH_SLASH,`
`MOD,`	`MOD,`
`REM,`	`REM,`
`NOT,`	`NOT,`
`POINTER,`	`POINTER,`
`RECEIVE,`	`RECEIVE,`
`UP,`	`UP,`
`IF,`	`IF,`
`THEN,`	`THEN,`
`ELSE,`	`ELSE,`
`FI,`	`FI,`
`ELSIF,`	`ELSIF,`
`ILLEGAL_TOKEN,`	`ILLEGAL_TOKEN,`
`NUM,`	`NUM,`
`PRED,`	`PRED,`
`SUCC,`	`SUCC,`
`ABS,`	`ABS,`
`CARD,`	`CARD,`
`MAX_TOKEN,`	`MAX_TOKEN,`
`MIN_TOKEN,`	`MIN_TOKEN,`
`ADDR_TOKEN,`	`ADDR_TOKEN,`
`SIZE,`	`SIZE,`
`UPPER,`	`UPPER,`
`LOWER,`	`LOWER,`
`LENGTH,`	`LENGTH,`
`ARRAY,`	`ARRAY,`
`GDB_VARIABLE,`	`GDB_VARIABLE,`
`GDB_ASSIGNMENT`	`GDB_ASSIGNMENT`
`};`	`};`

`/* Forward declarations. */`	`/* Forward declarations. */`

`static void write_lower_upper_value PARAMS ((enum exp_opcode, struct type *));`	`static void write_lower_upper_value PARAMS ((enum exp_opcode, struct type *));`
`static enum ch_terminal match_bitstring_literal PARAMS ((void));`	`static enum ch_terminal match_bitstring_literal PARAMS ((void));`
`static enum ch_terminal match_integer_literal PARAMS ((void));`	`static enum ch_terminal match_integer_literal PARAMS ((void));`
`static enum ch_terminal match_character_literal PARAMS ((void));`	`static enum ch_terminal match_character_literal PARAMS ((void));`
`static enum ch_terminal match_string_literal PARAMS ((void));`	`static enum ch_terminal match_string_literal PARAMS ((void));`
`static enum ch_terminal match_float_literal PARAMS ((void));`	`static enum ch_terminal match_float_literal PARAMS ((void));`
`static enum ch_terminal match_float_literal PARAMS ((void));`	`static enum ch_terminal match_float_literal PARAMS ((void));`
`static int decode_integer_literal PARAMS ((LONGEST , char *));`	`static int decode_integer_literal PARAMS ((LONGEST , char *));`
`static int decode_integer_value PARAMS ((int, char *, LONGEST ));`	`static int decode_integer_value PARAMS ((int, char *, LONGEST ));`
`static char *match_simple_name_string PARAMS ((void));`	`static char *match_simple_name_string PARAMS ((void));`
`static void growbuf_by_size PARAMS ((int));`	`static void growbuf_by_size PARAMS ((int));`
`static void parse_untyped_expr PARAMS ((void));`	`static void parse_untyped_expr PARAMS ((void));`
`static void parse_if_expression PARAMS ((void));`	`static void parse_if_expression PARAMS ((void));`
`static void parse_else_alternative PARAMS ((void));`	`static void parse_else_alternative PARAMS ((void));`
`static void parse_then_alternative PARAMS ((void));`	`static void parse_then_alternative PARAMS ((void));`
`static void parse_expr PARAMS ((void));`	`static void parse_expr PARAMS ((void));`
`static void parse_operand0 PARAMS ((void));`	`static void parse_operand0 PARAMS ((void));`
`static void parse_operand1 PARAMS ((void));`	`static void parse_operand1 PARAMS ((void));`
`static void parse_operand2 PARAMS ((void));`	`static void parse_operand2 PARAMS ((void));`
`static void parse_operand3 PARAMS ((void));`	`static void parse_operand3 PARAMS ((void));`
`static void parse_operand4 PARAMS ((void));`	`static void parse_operand4 PARAMS ((void));`
`static void parse_operand5 PARAMS ((void));`	`static void parse_operand5 PARAMS ((void));`
`static void parse_operand6 PARAMS ((void));`	`static void parse_operand6 PARAMS ((void));`
`static void parse_primval PARAMS ((void));`	`static void parse_primval PARAMS ((void));`
`static void parse_tuple PARAMS ((struct type *));`	`static void parse_tuple PARAMS ((struct type *));`
`static void parse_opt_element_list PARAMS ((struct type *));`	`static void parse_opt_element_list PARAMS ((struct type *));`
`static void parse_tuple_element PARAMS ((struct type *));`	`static void parse_tuple_element PARAMS ((struct type *));`
`static void parse_named_record_element PARAMS ((void));`	`static void parse_named_record_element PARAMS ((void));`
`static void parse_call PARAMS ((void));`	`static void parse_call PARAMS ((void));`
`static struct type *parse_mode_or_normal_call PARAMS ((void));`	`static struct type *parse_mode_or_normal_call PARAMS ((void));`
`#if 0`	`#if 0`
`static struct type *parse_mode_call PARAMS ((void));`	`static struct type *parse_mode_call PARAMS ((void));`
`#endif`	`#endif`
`static void parse_unary_call PARAMS ((void));`	`static void parse_unary_call PARAMS ((void));`
`static int parse_opt_untyped_expr PARAMS ((void));`	`static int parse_opt_untyped_expr PARAMS ((void));`
`static void parse_case_label PARAMS ((void));`	`static void parse_case_label PARAMS ((void));`
`static int expect PARAMS ((enum ch_terminal, char *));`	`static int expect PARAMS ((enum ch_terminal, char *));`
`static void parse_expr PARAMS ((void));`	`static void parse_expr PARAMS ((void));`
`static void parse_primval PARAMS ((void));`	`static void parse_primval PARAMS ((void));`
`static void parse_untyped_expr PARAMS ((void));`	`static void parse_untyped_expr PARAMS ((void));`
`static int parse_opt_untyped_expr PARAMS ((void));`	`static int parse_opt_untyped_expr PARAMS ((void));`
`static void parse_if_expression_body PARAMS ((void));`	`static void parse_if_expression_body PARAMS ((void));`
`static enum ch_terminal ch_lex PARAMS ((void));`	`static enum ch_terminal ch_lex PARAMS ((void));`
`INLINE static enum ch_terminal PEEK_TOKEN PARAMS ((void));`	`INLINE static enum ch_terminal PEEK_TOKEN PARAMS ((void));`
`static enum ch_terminal peek_token_ PARAMS ((int));`	`static enum ch_terminal peek_token_ PARAMS ((int));`
`static void forward_token_ PARAMS ((void));`	`static void forward_token_ PARAMS ((void));`
`static void require PARAMS ((enum ch_terminal));`	`static void require PARAMS ((enum ch_terminal));`
`static int check_token PARAMS ((enum ch_terminal));`	`static int check_token PARAMS ((enum ch_terminal));`

`#define MAX_LOOK_AHEAD 2`	`#define MAX_LOOK_AHEAD 2`
`static enum ch_terminal terminal_buffer[MAX_LOOK_AHEAD + 1] =`	`static enum ch_terminal terminal_buffer[MAX_LOOK_AHEAD + 1] =`
`{`	`{`
`TOKEN_NOT_READ, TOKEN_NOT_READ, TOKEN_NOT_READ};`	`TOKEN_NOT_READ, TOKEN_NOT_READ, TOKEN_NOT_READ};`
`static YYSTYPE yylval;`	`static YYSTYPE yylval;`
`static YYSTYPE val_buffer[MAX_LOOK_AHEAD + 1];`	`static YYSTYPE val_buffer[MAX_LOOK_AHEAD + 1];`

`/int current_token, lookahead_token; /`	`/int current_token, lookahead_token; /`

`INLINE static enum ch_terminal`	`INLINE static enum ch_terminal`
`PEEK_TOKEN ()`	`PEEK_TOKEN ()`
`{`	`{`
`if (terminal_buffer[0] == TOKEN_NOT_READ)`	`if (terminal_buffer[0] == TOKEN_NOT_READ)`
`{`	`{`
`terminal_buffer[0] = ch_lex ();`	`terminal_buffer[0] = ch_lex ();`
`val_buffer[0] = yylval;`	`val_buffer[0] = yylval;`
`}`	`}`
`return terminal_buffer[0];`	`return terminal_buffer[0];`
`}`	`}`
`#define PEEK_LVAL() val_buffer[0]`	`#define PEEK_LVAL() val_buffer[0]`
`#define PEEK_TOKEN1() peek_token_(1)`	`#define PEEK_TOKEN1() peek_token_(1)`
`#define PEEK_TOKEN2() peek_token_(2)`	`#define PEEK_TOKEN2() peek_token_(2)`
`static enum ch_terminal`	`static enum ch_terminal`
`peek_token_ (i)`	`peek_token_ (i)`
`int i;`	`int i;`
`{`	`{`
`if (i > MAX_LOOK_AHEAD)`	`if (i > MAX_LOOK_AHEAD)`
`internal_error ("ch-exp.c - too much lookahead");`	`internal_error ("ch-exp.c - too much lookahead");`
`if (terminal_buffer[i] == TOKEN_NOT_READ)`	`if (terminal_buffer[i] == TOKEN_NOT_READ)`
`{`	`{`
`terminal_buffer[i] = ch_lex ();`	`terminal_buffer[i] = ch_lex ();`
`val_buffer[i] = yylval;`	`val_buffer[i] = yylval;`
`}`	`}`
`return terminal_buffer[i];`	`return terminal_buffer[i];`
`}`	`}`

`#if 0`	`#if 0`

`static void`	`static void`
`pushback_token (code, node)`	`pushback_token (code, node)`
`enum ch_terminal code;`	`enum ch_terminal code;`
`YYSTYPE node;`	`YYSTYPE node;`
`{`	`{`
`int i;`	`int i;`
`if (terminal_buffer[MAX_LOOK_AHEAD] != TOKEN_NOT_READ)`	`if (terminal_buffer[MAX_LOOK_AHEAD] != TOKEN_NOT_READ)`
`internal_error ("ch-exp.c - cannot pushback token");`	`internal_error ("ch-exp.c - cannot pushback token");`
`for (i = MAX_LOOK_AHEAD; i > 0; i--)`	`for (i = MAX_LOOK_AHEAD; i > 0; i--)`
`{`	`{`
`terminal_buffer[i] = terminal_buffer[i - 1];`	`terminal_buffer[i] = terminal_buffer[i - 1];`
`val_buffer[i] = val_buffer[i - 1];`	`val_buffer[i] = val_buffer[i - 1];`
`}`	`}`
`terminal_buffer[0] = code;`	`terminal_buffer[0] = code;`
`val_buffer[0] = node;`	`val_buffer[0] = node;`
`}`	`}`

`#endif`	`#endif`

`static void`	`static void`
`forward_token_ ()`	`forward_token_ ()`
`{`	`{`
`int i;`	`int i;`
`for (i = 0; i < MAX_LOOK_AHEAD; i++)`	`for (i = 0; i < MAX_LOOK_AHEAD; i++)`
`{`	`{`
`terminal_buffer[i] = terminal_buffer[i + 1];`	`terminal_buffer[i] = terminal_buffer[i + 1];`
`val_buffer[i] = val_buffer[i + 1];`	`val_buffer[i] = val_buffer[i + 1];`
`}`	`}`
`terminal_buffer[MAX_LOOK_AHEAD] = TOKEN_NOT_READ;`	`terminal_buffer[MAX_LOOK_AHEAD] = TOKEN_NOT_READ;`
`}`	`}`
`#define FORWARD_TOKEN() forward_token_()`	`#define FORWARD_TOKEN() forward_token_()`

`/* Skip the next token.`	`/* Skip the next token.`
`if it isn't TOKEN, the parser is broken. */`	`if it isn't TOKEN, the parser is broken. */`

`static void`	`static void`
`require (token)`	`require (token)`
`enum ch_terminal token;`	`enum ch_terminal token;`
`{`	`{`
`if (PEEK_TOKEN () != token)`	`if (PEEK_TOKEN () != token)`
`{`	`{`
`internal_error ("ch-exp.c - expected token %d", (int) token);`	`internal_error ("ch-exp.c - expected token %d", (int) token);`
`}`	`}`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`}`	`}`

`static int`	`static int`
`check_token (token)`	`check_token (token)`
`enum ch_terminal token;`	`enum ch_terminal token;`
`{`	`{`
`if (PEEK_TOKEN () != token)`	`if (PEEK_TOKEN () != token)`
`return 0;`	`return 0;`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`return 1;`	`return 1;`
`}`	`}`

`/* return 0 if expected token was not found,`	`/* return 0 if expected token was not found,`
`else return 1.`	`else return 1.`
`*/`	`*/`
`static int`	`static int`
`expect (token, message)`	`expect (token, message)`
`enum ch_terminal token;`	`enum ch_terminal token;`
`char *message;`	`char *message;`
`{`	`{`
`if (PEEK_TOKEN () != token)`	`if (PEEK_TOKEN () != token)`
`{`	`{`
`if (message)`	`if (message)`
`error (message);`	`error (message);`
`else if (token < 256)`	`else if (token < 256)`
`error ("syntax error - expected a '%c' here \"%s\"", token, lexptr);`	`error ("syntax error - expected a '%c' here \"%s\"", token, lexptr);`
`else`	`else`
`error ("syntax error");`	`error ("syntax error");`
`return 0;`	`return 0;`
`}`	`}`
`else`	`else`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`return 1;`	`return 1;`
`}`	`}`

`#if 0`	`#if 0`
`static tree`	`static tree`
`parse_opt_name_string (allow_all)`	`parse_opt_name_string (allow_all)`
`int allow_all; /* 1 if ALL is allowed as a postfix */`	`int allow_all; /* 1 if ALL is allowed as a postfix */`
`{`	`{`
`int token = PEEK_TOKEN ();`	`int token = PEEK_TOKEN ();`
`tree name;`	`tree name;`
`if (token != NAME)`	`if (token != NAME)`
`{`	`{`
`if (token == ALL && allow_all)`	`if (token == ALL && allow_all)`
`{`	`{`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`return ALL_POSTFIX;`	`return ALL_POSTFIX;`
`}`	`}`
`return NULL_TREE;`	`return NULL_TREE;`
`}`	`}`
`name = PEEK_LVAL ();`	`name = PEEK_LVAL ();`
`for (;;)`	`for (;;)`
`{`	`{`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`token = PEEK_TOKEN ();`	`token = PEEK_TOKEN ();`
`if (token != '!')`	`if (token != '!')`
`return name;`	`return name;`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`token = PEEK_TOKEN ();`	`token = PEEK_TOKEN ();`
`if (token == ALL && allow_all)`	`if (token == ALL && allow_all)`
`return get_identifier3 (IDENTIFIER_POINTER (name), "!", "*");`	`return get_identifier3 (IDENTIFIER_POINTER (name), "!", "*");`
`if (token != NAME)`	`if (token != NAME)`
`{`	`{`
`if (pass == 1)`	`if (pass == 1)`
`error ("'%s!' is not followed by an identifier",`	`error ("'%s!' is not followed by an identifier",`
`IDENTIFIER_POINTER (name));`	`IDENTIFIER_POINTER (name));`
`return name;`	`return name;`
`}`	`}`
`name = get_identifier3 (IDENTIFIER_POINTER (name),`	`name = get_identifier3 (IDENTIFIER_POINTER (name),`
`"!", IDENTIFIER_POINTER (PEEK_LVAL ()));`	`"!", IDENTIFIER_POINTER (PEEK_LVAL ()));`
`}`	`}`
`}`	`}`

`static tree`	`static tree`
`parse_simple_name_string ()`	`parse_simple_name_string ()`
`{`	`{`
`int token = PEEK_TOKEN ();`	`int token = PEEK_TOKEN ();`
`tree name;`	`tree name;`
`if (token != NAME)`	`if (token != NAME)`
`{`	`{`
`error ("expected a name here");`	`error ("expected a name here");`
`return error_mark_node;`	`return error_mark_node;`
`}`	`}`
`name = PEEK_LVAL ();`	`name = PEEK_LVAL ();`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`return name;`	`return name;`
`}`	`}`

`static tree`	`static tree`
`parse_name_string ()`	`parse_name_string ()`
`{`	`{`
`tree name = parse_opt_name_string (0);`	`tree name = parse_opt_name_string (0);`
`if (name)`	`if (name)`
`return name;`	`return name;`
`if (pass == 1)`	`if (pass == 1)`
`error ("expected a name string here");`	`error ("expected a name string here");`
`return error_mark_node;`	`return error_mark_node;`
`}`	`}`

`/* Matches: <name_string>`	`/* Matches: <name_string>`
`Returns if pass 1: the identifier.`	`Returns if pass 1: the identifier.`
`Returns if pass 2: a decl or value for identifier. */`	`Returns if pass 2: a decl or value for identifier. */`

`static tree`	`static tree`
`parse_name ()`	`parse_name ()`
`{`	`{`
`tree name = parse_name_string ();`	`tree name = parse_name_string ();`
`if (pass == 1 \|\| ignoring)`	`if (pass == 1 \|\| ignoring)`
`return name;`	`return name;`
`else`	`else`
`{`	`{`
`tree decl = lookup_name (name);`	`tree decl = lookup_name (name);`
`if (decl == NULL_TREE)`	`if (decl == NULL_TREE)`
`{`	`{`
error ("`%s' undeclared", IDENTIFIER_POINTER (name));	error ("`%s' undeclared", IDENTIFIER_POINTER (name));
`return error_mark_node;`	`return error_mark_node;`
`}`	`}`
`else if (TREE_CODE (TREE_TYPE (decl)) == ERROR_MARK)`	`else if (TREE_CODE (TREE_TYPE (decl)) == ERROR_MARK)`
`return error_mark_node;`	`return error_mark_node;`
`else if (TREE_CODE (decl) == CONST_DECL)`	`else if (TREE_CODE (decl) == CONST_DECL)`
`return DECL_INITIAL (decl);`	`return DECL_INITIAL (decl);`
`else if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)`	`else if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)`
`return convert_from_reference (decl);`	`return convert_from_reference (decl);`
`else`	`else`
`return decl;`	`return decl;`
`}`	`}`
`}`	`}`
`#endif`	`#endif`

`#if 0`	`#if 0`
`static void`	`static void`
`pushback_paren_expr (expr)`	`pushback_paren_expr (expr)`
`tree expr;`	`tree expr;`
`{`	`{`
`if (pass == 1 && !ignoring)`	`if (pass == 1 && !ignoring)`
`expr = build1 (PAREN_EXPR, NULL_TREE, expr);`	`expr = build1 (PAREN_EXPR, NULL_TREE, expr);`
`pushback_token (EXPR, expr);`	`pushback_token (EXPR, expr);`
`}`	`}`
`#endif`	`#endif`

`/* Matches: <case label> */`	`/* Matches: <case label> */`

`static void`	`static void`
`parse_case_label ()`	`parse_case_label ()`
`{`	`{`
`if (check_token (ELSE))`	`if (check_token (ELSE))`
`error ("ELSE in tuples labels not implemented");`	`error ("ELSE in tuples labels not implemented");`
`/* Does not handle the case of a mode name. FIXME */`	`/* Does not handle the case of a mode name. FIXME */`
`parse_expr ();`	`parse_expr ();`
`if (check_token (':'))`	`if (check_token (':'))`
`{`	`{`
`parse_expr ();`	`parse_expr ();`
`write_exp_elt_opcode (BINOP_RANGE);`	`write_exp_elt_opcode (BINOP_RANGE);`
`}`	`}`
`}`	`}`

`static int`	`static int`
`parse_opt_untyped_expr ()`	`parse_opt_untyped_expr ()`
`{`	`{`
`switch (PEEK_TOKEN ())`	`switch (PEEK_TOKEN ())`
`{`	`{`
`case ',':`	`case ',':`
`case ':':`	`case ':':`
`case ')':`	`case ')':`
`return 0;`	`return 0;`
`default:`	`default:`
`parse_untyped_expr ();`	`parse_untyped_expr ();`
`return 1;`	`return 1;`
`}`	`}`
`}`	`}`

`static void`	`static void`
`parse_unary_call ()`	`parse_unary_call ()`
`{`	`{`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`expect ('(', NULL);`	`expect ('(', NULL);`
`parse_expr ();`	`parse_expr ();`
`expect (')', NULL);`	`expect (')', NULL);`
`}`	`}`

`/* Parse NAME '(' MODENAME ')'. */`	`/* Parse NAME '(' MODENAME ')'. */`

`#if 0`	`#if 0`

`static struct type *`	`static struct type *`
`parse_mode_call ()`	`parse_mode_call ()`
`{`	`{`
`struct type *type;`	`struct type *type;`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`expect ('(', NULL);`	`expect ('(', NULL);`
`if (PEEK_TOKEN () != TYPENAME)`	`if (PEEK_TOKEN () != TYPENAME)`
error ("expect MODENAME here `%s'", lexptr);	error ("expect MODENAME here `%s'", lexptr);
`type = PEEK_LVAL ().tsym.type;`	`type = PEEK_LVAL ().tsym.type;`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`expect (')', NULL);`	`expect (')', NULL);`
`return type;`	`return type;`
`}`	`}`

`#endif`	`#endif`

`static struct type *`	`static struct type *`
`parse_mode_or_normal_call ()`	`parse_mode_or_normal_call ()`
`{`	`{`
`struct type *type;`	`struct type *type;`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`expect ('(', NULL);`	`expect ('(', NULL);`
`if (PEEK_TOKEN () == TYPENAME)`	`if (PEEK_TOKEN () == TYPENAME)`
`{`	`{`
`type = PEEK_LVAL ().tsym.type;`	`type = PEEK_LVAL ().tsym.type;`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`}`	`}`
`else`	`else`
`{`	`{`
`parse_expr ();`	`parse_expr ();`
`type = NULL;`	`type = NULL;`
`}`	`}`
`expect (')', NULL);`	`expect (')', NULL);`
`return type;`	`return type;`
`}`	`}`

`/* Parse something that looks like a function call.`	`/* Parse something that looks like a function call.`
`Assume we have parsed the function, and are at the '('. */`	`Assume we have parsed the function, and are at the '('. */`

`static void`	`static void`
`parse_call ()`	`parse_call ()`
`{`	`{`
`int arg_count;`	`int arg_count;`
`require ('(');`	`require ('(');`
`/* This is to save the value of arglist_len`	`/* This is to save the value of arglist_len`
`being accumulated for each dimension. */`	`being accumulated for each dimension. */`
`start_arglist ();`	`start_arglist ();`
`if (parse_opt_untyped_expr ())`	`if (parse_opt_untyped_expr ())`
`{`	`{`
`int tok = PEEK_TOKEN ();`	`int tok = PEEK_TOKEN ();`
`arglist_len = 1;`	`arglist_len = 1;`
`if (tok == UP \|\| tok == ':')`	`if (tok == UP \|\| tok == ':')`
`{`	`{`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`parse_expr ();`	`parse_expr ();`
`expect (')', "expected ')' to terminate slice");`	`expect (')', "expected ')' to terminate slice");`
`end_arglist ();`	`end_arglist ();`
`write_exp_elt_opcode (tok == UP ? TERNOP_SLICE_COUNT`	`write_exp_elt_opcode (tok == UP ? TERNOP_SLICE_COUNT`
`: TERNOP_SLICE);`	`: TERNOP_SLICE);`
`return;`	`return;`
`}`	`}`
`while (check_token (','))`	`while (check_token (','))`
`{`	`{`
`parse_untyped_expr ();`	`parse_untyped_expr ();`
`arglist_len++;`	`arglist_len++;`
`}`	`}`
`}`	`}`
`else`	`else`
`arglist_len = 0;`	`arglist_len = 0;`
`expect (')', NULL);`	`expect (')', NULL);`
`arg_count = end_arglist ();`	`arg_count = end_arglist ();`
`write_exp_elt_opcode (MULTI_SUBSCRIPT);`	`write_exp_elt_opcode (MULTI_SUBSCRIPT);`
`write_exp_elt_longcst (arg_count);`	`write_exp_elt_longcst (arg_count);`
`write_exp_elt_opcode (MULTI_SUBSCRIPT);`	`write_exp_elt_opcode (MULTI_SUBSCRIPT);`
`}`	`}`

`static void`	`static void`
`parse_named_record_element ()`	`parse_named_record_element ()`
`{`	`{`
`struct stoken label;`	`struct stoken label;`
`char buf[256];`	`char buf[256];`

`label = PEEK_LVAL ().sval;`	`label = PEEK_LVAL ().sval;`
sprintf (buf, "expected a field name here `%s'", lexptr);	sprintf (buf, "expected a field name here `%s'", lexptr);
`expect (DOT_FIELD_NAME, buf);`	`expect (DOT_FIELD_NAME, buf);`
`if (check_token (','))`	`if (check_token (','))`
`parse_named_record_element ();`	`parse_named_record_element ();`
`else if (check_token (':'))`	`else if (check_token (':'))`
`parse_expr ();`	`parse_expr ();`
`else`	`else`
error ("syntax error near `%s' in named record tuple element", lexptr);	error ("syntax error near `%s' in named record tuple element", lexptr);
`write_exp_elt_opcode (OP_LABELED);`	`write_exp_elt_opcode (OP_LABELED);`
`write_exp_string (label);`	`write_exp_string (label);`
`write_exp_elt_opcode (OP_LABELED);`	`write_exp_elt_opcode (OP_LABELED);`
`}`	`}`

`/* Returns one or more TREE_LIST nodes, in reverse order. */`	`/* Returns one or more TREE_LIST nodes, in reverse order. */`

`static void`	`static void`
`parse_tuple_element (type)`	`parse_tuple_element (type)`
`struct type *type;`	`struct type *type;`
`{`	`{`
`if (PEEK_TOKEN () == DOT_FIELD_NAME)`	`if (PEEK_TOKEN () == DOT_FIELD_NAME)`
`{`	`{`
`/* Parse a labelled structure tuple. */`	`/* Parse a labelled structure tuple. */`
`parse_named_record_element ();`	`parse_named_record_element ();`
`return;`	`return;`
`}`	`}`

`if (check_token ('('))`	`if (check_token ('('))`
`{`	`{`
`if (check_token ('*'))`	`if (check_token ('*'))`
`{`	`{`
`expect (')', "missing ')' after '*' case label list");`	`expect (')', "missing ')' after '*' case label list");`
`if (type)`	`if (type)`
`{`	`{`
`if (TYPE_CODE (type) == TYPE_CODE_ARRAY)`	`if (TYPE_CODE (type) == TYPE_CODE_ARRAY)`
`{`	`{`
`/* do this as a range from low to high */`	`/* do this as a range from low to high */`
`struct type *range_type = TYPE_FIELD_TYPE (type, 0);`	`struct type *range_type = TYPE_FIELD_TYPE (type, 0);`
`LONGEST low_bound, high_bound;`	`LONGEST low_bound, high_bound;`
`if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)`	`if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)`
`error ("cannot determine bounds for (*)");`	`error ("cannot determine bounds for (*)");`
`/* lower bound */`	`/* lower bound */`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`write_exp_elt_type (range_type);`	`write_exp_elt_type (range_type);`
`write_exp_elt_longcst (low_bound);`	`write_exp_elt_longcst (low_bound);`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`/* upper bound */`	`/* upper bound */`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`write_exp_elt_type (range_type);`	`write_exp_elt_type (range_type);`
`write_exp_elt_longcst (high_bound);`	`write_exp_elt_longcst (high_bound);`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`write_exp_elt_opcode (BINOP_RANGE);`	`write_exp_elt_opcode (BINOP_RANGE);`
`}`	`}`
`else`	`else`
`error ("(*) in invalid context");`	`error ("(*) in invalid context");`
`}`	`}`
`else`	`else`
`error ("(*) only possible with modename in front of tuple (mode[..])");`	`error ("(*) only possible with modename in front of tuple (mode[..])");`
`}`	`}`
`else`	`else`
`{`	`{`
`parse_case_label ();`	`parse_case_label ();`
`while (check_token (','))`	`while (check_token (','))`
`{`	`{`
`parse_case_label ();`	`parse_case_label ();`
`write_exp_elt_opcode (BINOP_COMMA);`	`write_exp_elt_opcode (BINOP_COMMA);`
`}`	`}`
`expect (')', NULL);`	`expect (')', NULL);`
`}`	`}`
`}`	`}`
`else`	`else`
`parse_untyped_expr ();`	`parse_untyped_expr ();`
`if (check_token (':'))`	`if (check_token (':'))`
`{`	`{`
`/* A powerset range or a labeled Array. */`	`/* A powerset range or a labeled Array. */`
`parse_untyped_expr ();`	`parse_untyped_expr ();`
`write_exp_elt_opcode (BINOP_RANGE);`	`write_exp_elt_opcode (BINOP_RANGE);`
`}`	`}`
`}`	`}`

`/* Matches: a COMMA-separated list of tuple elements.`	`/* Matches: a COMMA-separated list of tuple elements.`
`Returns a list (of TREE_LIST nodes). */`	`Returns a list (of TREE_LIST nodes). */`
`static void`	`static void`
`parse_opt_element_list (type)`	`parse_opt_element_list (type)`
`struct type *type;`	`struct type *type;`
`{`	`{`
`arglist_len = 0;`	`arglist_len = 0;`
`if (PEEK_TOKEN () == ']')`	`if (PEEK_TOKEN () == ']')`
`return;`	`return;`
`for (;;)`	`for (;;)`
`{`	`{`
`parse_tuple_element (type);`	`parse_tuple_element (type);`
`arglist_len++;`	`arglist_len++;`
`if (PEEK_TOKEN () == ']')`	`if (PEEK_TOKEN () == ']')`
`break;`	`break;`
`if (!check_token (','))`	`if (!check_token (','))`
`error ("bad syntax in tuple");`	`error ("bad syntax in tuple");`
`}`	`}`
`}`	`}`

`/* Parses: '[' elements ']'`	`/* Parses: '[' elements ']'`
`If modename is non-NULL it prefixed the tuple. */`	`If modename is non-NULL it prefixed the tuple. */`

`static void`	`static void`
`parse_tuple (mode)`	`parse_tuple (mode)`
`struct type *mode;`	`struct type *mode;`
`{`	`{`
`struct type *type;`	`struct type *type;`
`if (mode)`	`if (mode)`
`type = check_typedef (mode);`	`type = check_typedef (mode);`
`else`	`else`
`type = 0;`	`type = 0;`
`require ('[');`	`require ('[');`
`start_arglist ();`	`start_arglist ();`
`parse_opt_element_list (type);`	`parse_opt_element_list (type);`
`expect (']', "missing ']' after tuple");`	`expect (']', "missing ']' after tuple");`
`write_exp_elt_opcode (OP_ARRAY);`	`write_exp_elt_opcode (OP_ARRAY);`
`write_exp_elt_longcst ((LONGEST) 0);`	`write_exp_elt_longcst ((LONGEST) 0);`
`write_exp_elt_longcst ((LONGEST) end_arglist () - 1);`	`write_exp_elt_longcst ((LONGEST) end_arglist () - 1);`
`write_exp_elt_opcode (OP_ARRAY);`	`write_exp_elt_opcode (OP_ARRAY);`
`if (type)`	`if (type)`
`{`	`{`
`if (TYPE_CODE (type) != TYPE_CODE_ARRAY`	`if (TYPE_CODE (type) != TYPE_CODE_ARRAY`
`&& TYPE_CODE (type) != TYPE_CODE_STRUCT`	`&& TYPE_CODE (type) != TYPE_CODE_STRUCT`
`&& TYPE_CODE (type) != TYPE_CODE_SET)`	`&& TYPE_CODE (type) != TYPE_CODE_SET)`
`error ("invalid tuple mode");`	`error ("invalid tuple mode");`
`write_exp_elt_opcode (UNOP_CAST);`	`write_exp_elt_opcode (UNOP_CAST);`
`write_exp_elt_type (mode);`	`write_exp_elt_type (mode);`
`write_exp_elt_opcode (UNOP_CAST);`	`write_exp_elt_opcode (UNOP_CAST);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`parse_primval ()`	`parse_primval ()`
`{`	`{`
`struct type *type;`	`struct type *type;`
`enum exp_opcode op;`	`enum exp_opcode op;`
`char *op_name;`	`char *op_name;`
`switch (PEEK_TOKEN ())`	`switch (PEEK_TOKEN ())`
`{`	`{`
`case INTEGER_LITERAL:`	`case INTEGER_LITERAL:`
`case CHARACTER_LITERAL:`	`case CHARACTER_LITERAL:`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`write_exp_elt_type (PEEK_LVAL ().typed_val.type);`	`write_exp_elt_type (PEEK_LVAL ().typed_val.type);`
`write_exp_elt_longcst (PEEK_LVAL ().typed_val.val);`	`write_exp_elt_longcst (PEEK_LVAL ().typed_val.val);`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`break;`	`break;`
`case BOOLEAN_LITERAL:`	`case BOOLEAN_LITERAL:`
`write_exp_elt_opcode (OP_BOOL);`	`write_exp_elt_opcode (OP_BOOL);`
`write_exp_elt_longcst ((LONGEST) PEEK_LVAL ().ulval);`	`write_exp_elt_longcst ((LONGEST) PEEK_LVAL ().ulval);`
`write_exp_elt_opcode (OP_BOOL);`	`write_exp_elt_opcode (OP_BOOL);`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`break;`	`break;`
`case FLOAT_LITERAL:`	`case FLOAT_LITERAL:`
`write_exp_elt_opcode (OP_DOUBLE);`	`write_exp_elt_opcode (OP_DOUBLE);`
`write_exp_elt_type (builtin_type_double);`	`write_exp_elt_type (builtin_type_double);`
`write_exp_elt_dblcst (PEEK_LVAL ().dval);`	`write_exp_elt_dblcst (PEEK_LVAL ().dval);`
`write_exp_elt_opcode (OP_DOUBLE);`	`write_exp_elt_opcode (OP_DOUBLE);`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`break;`	`break;`
`case EMPTINESS_LITERAL:`	`case EMPTINESS_LITERAL:`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`write_exp_elt_type (lookup_pointer_type (builtin_type_void));`	`write_exp_elt_type (lookup_pointer_type (builtin_type_void));`
`write_exp_elt_longcst (0);`	`write_exp_elt_longcst (0);`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`break;`	`break;`
`case CHARACTER_STRING_LITERAL:`	`case CHARACTER_STRING_LITERAL:`
`write_exp_elt_opcode (OP_STRING);`	`write_exp_elt_opcode (OP_STRING);`
`write_exp_string (PEEK_LVAL ().sval);`	`write_exp_string (PEEK_LVAL ().sval);`
`write_exp_elt_opcode (OP_STRING);`	`write_exp_elt_opcode (OP_STRING);`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`break;`	`break;`
`case BIT_STRING_LITERAL:`	`case BIT_STRING_LITERAL:`
`write_exp_elt_opcode (OP_BITSTRING);`	`write_exp_elt_opcode (OP_BITSTRING);`
`write_exp_bitstring (PEEK_LVAL ().sval);`	`write_exp_bitstring (PEEK_LVAL ().sval);`
`write_exp_elt_opcode (OP_BITSTRING);`	`write_exp_elt_opcode (OP_BITSTRING);`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`break;`	`break;`
`case ARRAY:`	`case ARRAY:`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`/* This is pseudo-Chill, similar to C's '(TYPE[])EXPR'`	`/* This is pseudo-Chill, similar to C's '(TYPE[])EXPR'`
`which casts to an artificial array. */`	`which casts to an artificial array. */`
`expect ('(', NULL);`	`expect ('(', NULL);`
`expect (')', NULL);`	`expect (')', NULL);`
`if (PEEK_TOKEN () != TYPENAME)`	`if (PEEK_TOKEN () != TYPENAME)`
`error ("missing MODENAME after ARRAY()");`	`error ("missing MODENAME after ARRAY()");`
`type = PEEK_LVAL ().tsym.type;`	`type = PEEK_LVAL ().tsym.type;`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`expect ('(', NULL);`	`expect ('(', NULL);`
`parse_expr ();`	`parse_expr ();`
`expect (')', "missing right parenthesis");`	`expect (')', "missing right parenthesis");`
`type = create_array_type ((struct type *) NULL, type,`	`type = create_array_type ((struct type *) NULL, type,`
`create_range_type ((struct type *) NULL,`	`create_range_type ((struct type *) NULL,`
`builtin_type_int, 0, 0));`	`builtin_type_int, 0, 0));`
`TYPE_ARRAY_UPPER_BOUND_TYPE (type) = BOUND_CANNOT_BE_DETERMINED;`	`TYPE_ARRAY_UPPER_BOUND_TYPE (type) = BOUND_CANNOT_BE_DETERMINED;`
`write_exp_elt_opcode (UNOP_CAST);`	`write_exp_elt_opcode (UNOP_CAST);`
`write_exp_elt_type (type);`	`write_exp_elt_type (type);`
`write_exp_elt_opcode (UNOP_CAST);`	`write_exp_elt_opcode (UNOP_CAST);`
`break;`	`break;`
`#if 0`	`#if 0`
`case CONST:`	`case CONST:`
`case EXPR:`	`case EXPR:`
`val = PEEK_LVAL ();`	`val = PEEK_LVAL ();`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`break;`	`break;`
`#endif`	`#endif`
`case '(':`	`case '(':`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`parse_expr ();`	`parse_expr ();`
`expect (')', "missing right parenthesis");`	`expect (')', "missing right parenthesis");`
`break;`	`break;`
`case '[':`	`case '[':`
`parse_tuple (NULL);`	`parse_tuple (NULL);`
`break;`	`break;`
`case GENERAL_PROCEDURE_NAME:`	`case GENERAL_PROCEDURE_NAME:`
`case LOCATION_NAME:`	`case LOCATION_NAME:`
`write_exp_elt_opcode (OP_VAR_VALUE);`	`write_exp_elt_opcode (OP_VAR_VALUE);`
`write_exp_elt_block (NULL);`	`write_exp_elt_block (NULL);`
`write_exp_elt_sym (PEEK_LVAL ().ssym.sym);`	`write_exp_elt_sym (PEEK_LVAL ().ssym.sym);`
`write_exp_elt_opcode (OP_VAR_VALUE);`	`write_exp_elt_opcode (OP_VAR_VALUE);`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`break;`	`break;`
`case GDB_VARIABLE: /* gdb specific */`	`case GDB_VARIABLE: /* gdb specific */`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`break;`	`break;`
`case NUM:`	`case NUM:`
`parse_unary_call ();`	`parse_unary_call ();`
`write_exp_elt_opcode (UNOP_CAST);`	`write_exp_elt_opcode (UNOP_CAST);`
`write_exp_elt_type (builtin_type_int);`	`write_exp_elt_type (builtin_type_int);`
`write_exp_elt_opcode (UNOP_CAST);`	`write_exp_elt_opcode (UNOP_CAST);`
`break;`	`break;`
`case CARD:`	`case CARD:`
`parse_unary_call ();`	`parse_unary_call ();`
`write_exp_elt_opcode (UNOP_CARD);`	`write_exp_elt_opcode (UNOP_CARD);`
`break;`	`break;`
`case MAX_TOKEN:`	`case MAX_TOKEN:`
`parse_unary_call ();`	`parse_unary_call ();`
`write_exp_elt_opcode (UNOP_CHMAX);`	`write_exp_elt_opcode (UNOP_CHMAX);`
`break;`	`break;`
`case MIN_TOKEN:`	`case MIN_TOKEN:`
`parse_unary_call ();`	`parse_unary_call ();`
`write_exp_elt_opcode (UNOP_CHMIN);`	`write_exp_elt_opcode (UNOP_CHMIN);`
`break;`	`break;`
`case PRED:`	`case PRED:`
`op_name = "PRED";`	`op_name = "PRED";`
`goto unimplemented_unary_builtin;`	`goto unimplemented_unary_builtin;`
`case SUCC:`	`case SUCC:`
`op_name = "SUCC";`	`op_name = "SUCC";`
`goto unimplemented_unary_builtin;`	`goto unimplemented_unary_builtin;`
`case ABS:`	`case ABS:`
`op_name = "ABS";`	`op_name = "ABS";`
`goto unimplemented_unary_builtin;`	`goto unimplemented_unary_builtin;`
`unimplemented_unary_builtin:`	`unimplemented_unary_builtin:`
`parse_unary_call ();`	`parse_unary_call ();`
`error ("not implemented: %s builtin function", op_name);`	`error ("not implemented: %s builtin function", op_name);`
`break;`	`break;`
`case ADDR_TOKEN:`	`case ADDR_TOKEN:`
`parse_unary_call ();`	`parse_unary_call ();`
`write_exp_elt_opcode (UNOP_ADDR);`	`write_exp_elt_opcode (UNOP_ADDR);`
`break;`	`break;`
`case SIZE:`	`case SIZE:`
`type = parse_mode_or_normal_call ();`	`type = parse_mode_or_normal_call ();`
`if (type)`	`if (type)`
`{`	`{`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`write_exp_elt_type (builtin_type_int);`	`write_exp_elt_type (builtin_type_int);`
`CHECK_TYPEDEF (type);`	`CHECK_TYPEDEF (type);`
`write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (type));`	`write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (type));`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`}`	`}`
`else`	`else`
`write_exp_elt_opcode (UNOP_SIZEOF);`	`write_exp_elt_opcode (UNOP_SIZEOF);`
`break;`	`break;`
`case LOWER:`	`case LOWER:`
`op = UNOP_LOWER;`	`op = UNOP_LOWER;`
`goto lower_upper;`	`goto lower_upper;`
`case UPPER:`	`case UPPER:`
`op = UNOP_UPPER;`	`op = UNOP_UPPER;`
`goto lower_upper;`	`goto lower_upper;`
`lower_upper:`	`lower_upper:`
`type = parse_mode_or_normal_call ();`	`type = parse_mode_or_normal_call ();`
`write_lower_upper_value (op, type);`	`write_lower_upper_value (op, type);`
`break;`	`break;`
`case LENGTH:`	`case LENGTH:`
`parse_unary_call ();`	`parse_unary_call ();`
`write_exp_elt_opcode (UNOP_LENGTH);`	`write_exp_elt_opcode (UNOP_LENGTH);`
`break;`	`break;`
`case TYPENAME:`	`case TYPENAME:`
`type = PEEK_LVAL ().tsym.type;`	`type = PEEK_LVAL ().tsym.type;`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`switch (PEEK_TOKEN ())`	`switch (PEEK_TOKEN ())`
`{`	`{`
`case '[':`	`case '[':`
`parse_tuple (type);`	`parse_tuple (type);`
`break;`	`break;`
`case '(':`	`case '(':`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`parse_expr ();`	`parse_expr ();`
`expect (')', "missing right parenthesis");`	`expect (')', "missing right parenthesis");`
`write_exp_elt_opcode (UNOP_CAST);`	`write_exp_elt_opcode (UNOP_CAST);`
`write_exp_elt_type (type);`	`write_exp_elt_type (type);`
`write_exp_elt_opcode (UNOP_CAST);`	`write_exp_elt_opcode (UNOP_CAST);`
`break;`	`break;`
`default:`	`default:`
`error ("typename in invalid context");`	`error ("typename in invalid context");`
`}`	`}`
`break;`	`break;`

`default:`	`default:`
error ("invalid expression syntax at `%s'", lexptr);	error ("invalid expression syntax at `%s'", lexptr);
`}`	`}`
`for (;;)`	`for (;;)`
`{`	`{`
`switch (PEEK_TOKEN ())`	`switch (PEEK_TOKEN ())`
`{`	`{`
`case DOT_FIELD_NAME:`	`case DOT_FIELD_NAME:`
`write_exp_elt_opcode (STRUCTOP_STRUCT);`	`write_exp_elt_opcode (STRUCTOP_STRUCT);`
`write_exp_string (PEEK_LVAL ().sval);`	`write_exp_string (PEEK_LVAL ().sval);`
`write_exp_elt_opcode (STRUCTOP_STRUCT);`	`write_exp_elt_opcode (STRUCTOP_STRUCT);`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`continue;`	`continue;`
`case POINTER:`	`case POINTER:`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`if (PEEK_TOKEN () == TYPENAME)`	`if (PEEK_TOKEN () == TYPENAME)`
`{`	`{`
`type = PEEK_LVAL ().tsym.type;`	`type = PEEK_LVAL ().tsym.type;`
`write_exp_elt_opcode (UNOP_CAST);`	`write_exp_elt_opcode (UNOP_CAST);`
`write_exp_elt_type (lookup_pointer_type (type));`	`write_exp_elt_type (lookup_pointer_type (type));`
`write_exp_elt_opcode (UNOP_CAST);`	`write_exp_elt_opcode (UNOP_CAST);`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`}`	`}`
`write_exp_elt_opcode (UNOP_IND);`	`write_exp_elt_opcode (UNOP_IND);`
`continue;`	`continue;`
`case OPEN_PAREN:`	`case OPEN_PAREN:`
`parse_call ();`	`parse_call ();`
`continue;`	`continue;`
`case CHARACTER_STRING_LITERAL:`	`case CHARACTER_STRING_LITERAL:`
`case CHARACTER_LITERAL:`	`case CHARACTER_LITERAL:`
`case BIT_STRING_LITERAL:`	`case BIT_STRING_LITERAL:`
`/* Handle string repetition. (See comment in parse_operand5.) */`	`/* Handle string repetition. (See comment in parse_operand5.) */`
`parse_primval ();`	`parse_primval ();`
`write_exp_elt_opcode (MULTI_SUBSCRIPT);`	`write_exp_elt_opcode (MULTI_SUBSCRIPT);`
`write_exp_elt_longcst (1);`	`write_exp_elt_longcst (1);`
`write_exp_elt_opcode (MULTI_SUBSCRIPT);`	`write_exp_elt_opcode (MULTI_SUBSCRIPT);`
`continue;`	`continue;`
`case END_TOKEN:`	`case END_TOKEN:`
`case TOKEN_NOT_READ:`	`case TOKEN_NOT_READ:`
`case INTEGER_LITERAL:`	`case INTEGER_LITERAL:`
`case BOOLEAN_LITERAL:`	`case BOOLEAN_LITERAL:`
`case FLOAT_LITERAL:`	`case FLOAT_LITERAL:`
`case GENERAL_PROCEDURE_NAME:`	`case GENERAL_PROCEDURE_NAME:`
`case LOCATION_NAME:`	`case LOCATION_NAME:`
`case EMPTINESS_LITERAL:`	`case EMPTINESS_LITERAL:`
`case TYPENAME:`	`case TYPENAME:`
`case CASE:`	`case CASE:`
`case OF:`	`case OF:`
`case ESAC:`	`case ESAC:`
`case LOGIOR:`	`case LOGIOR:`
`case ORIF:`	`case ORIF:`
`case LOGXOR:`	`case LOGXOR:`
`case LOGAND:`	`case LOGAND:`
`case ANDIF:`	`case ANDIF:`
`case NOTEQUAL:`	`case NOTEQUAL:`
`case GEQ:`	`case GEQ:`
`case LEQ:`	`case LEQ:`
`case IN:`	`case IN:`
`case SLASH_SLASH:`	`case SLASH_SLASH:`
`case MOD:`	`case MOD:`
`case REM:`	`case REM:`
`case NOT:`	`case NOT:`
`case RECEIVE:`	`case RECEIVE:`
`case UP:`	`case UP:`
`case IF:`	`case IF:`
`case THEN:`	`case THEN:`
`case ELSE:`	`case ELSE:`
`case FI:`	`case FI:`
`case ELSIF:`	`case ELSIF:`
`case ILLEGAL_TOKEN:`	`case ILLEGAL_TOKEN:`
`case NUM:`	`case NUM:`
`case PRED:`	`case PRED:`
`case SUCC:`	`case SUCC:`
`case ABS:`	`case ABS:`
`case CARD:`	`case CARD:`
`case MAX_TOKEN:`	`case MAX_TOKEN:`
`case MIN_TOKEN:`	`case MIN_TOKEN:`
`case ADDR_TOKEN:`	`case ADDR_TOKEN:`
`case SIZE:`	`case SIZE:`
`case UPPER:`	`case UPPER:`
`case LOWER:`	`case LOWER:`
`case LENGTH:`	`case LENGTH:`
`case ARRAY:`	`case ARRAY:`
`case GDB_VARIABLE:`	`case GDB_VARIABLE:`
`case GDB_ASSIGNMENT:`	`case GDB_ASSIGNMENT:`
`break;`	`break;`
`}`	`}`
`break;`	`break;`
`}`	`}`
`return;`	`return;`
`}`	`}`

`static void`	`static void`
`parse_operand6 ()`	`parse_operand6 ()`
`{`	`{`
`if (check_token (RECEIVE))`	`if (check_token (RECEIVE))`
`{`	`{`
`parse_primval ();`	`parse_primval ();`
`error ("not implemented: RECEIVE expression");`	`error ("not implemented: RECEIVE expression");`
`}`	`}`
`else if (check_token (POINTER))`	`else if (check_token (POINTER))`
`{`	`{`
`parse_primval ();`	`parse_primval ();`
`write_exp_elt_opcode (UNOP_ADDR);`	`write_exp_elt_opcode (UNOP_ADDR);`
`}`	`}`
`else`	`else`
`parse_primval ();`	`parse_primval ();`
`}`	`}`

`static void`	`static void`
`parse_operand5 ()`	`parse_operand5 ()`
`{`	`{`
`enum exp_opcode op;`	`enum exp_opcode op;`
`/* We are supposed to be looking for a <string repetition operator>,`	`/* We are supposed to be looking for a <string repetition operator>,`
`but in general we can't distinguish that from a parenthesized`	`but in general we can't distinguish that from a parenthesized`
`expression. This is especially difficult if we allow the`	`expression. This is especially difficult if we allow the`
`string operand to be a constant expression (as requested by`	`string operand to be a constant expression (as requested by`
`some users), and not just a string literal.`	`some users), and not just a string literal.`
`Consider: LPRN expr RPRN LPRN expr RPRN`	`Consider: LPRN expr RPRN LPRN expr RPRN`
`Is that a function call or string repetition?`	`Is that a function call or string repetition?`
`Instead, we handle string repetition in parse_primval,`	`Instead, we handle string repetition in parse_primval,`
`and build_generalized_call. */`	`and build_generalized_call. */`
`switch (PEEK_TOKEN ())`	`switch (PEEK_TOKEN ())`
`{`	`{`
`case NOT:`	`case NOT:`
`op = UNOP_LOGICAL_NOT;`	`op = UNOP_LOGICAL_NOT;`
`break;`	`break;`
`case '-':`	`case '-':`
`op = UNOP_NEG;`	`op = UNOP_NEG;`
`break;`	`break;`
`default:`	`default:`
`op = OP_NULL;`	`op = OP_NULL;`
`}`	`}`
`if (op != OP_NULL)`	`if (op != OP_NULL)`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`parse_operand6 ();`	`parse_operand6 ();`
`if (op != OP_NULL)`	`if (op != OP_NULL)`
`write_exp_elt_opcode (op);`	`write_exp_elt_opcode (op);`
`}`	`}`

`static void`	`static void`
`parse_operand4 ()`	`parse_operand4 ()`
`{`	`{`
`enum exp_opcode op;`	`enum exp_opcode op;`
`parse_operand5 ();`	`parse_operand5 ();`
`for (;;)`	`for (;;)`
`{`	`{`
`switch (PEEK_TOKEN ())`	`switch (PEEK_TOKEN ())`
`{`	`{`
`case '*':`	`case '*':`
`op = BINOP_MUL;`	`op = BINOP_MUL;`
`break;`	`break;`
`case '/':`	`case '/':`
`op = BINOP_DIV;`	`op = BINOP_DIV;`
`break;`	`break;`
`case MOD:`	`case MOD:`
`op = BINOP_MOD;`	`op = BINOP_MOD;`
`break;`	`break;`
`case REM:`	`case REM:`
`op = BINOP_REM;`	`op = BINOP_REM;`
`break;`	`break;`
`default:`	`default:`
`return;`	`return;`
`}`	`}`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`parse_operand5 ();`	`parse_operand5 ();`
`write_exp_elt_opcode (op);`	`write_exp_elt_opcode (op);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`parse_operand3 ()`	`parse_operand3 ()`
`{`	`{`
`enum exp_opcode op;`	`enum exp_opcode op;`
`parse_operand4 ();`	`parse_operand4 ();`
`for (;;)`	`for (;;)`
`{`	`{`
`switch (PEEK_TOKEN ())`	`switch (PEEK_TOKEN ())`
`{`	`{`
`case '+':`	`case '+':`
`op = BINOP_ADD;`	`op = BINOP_ADD;`
`break;`	`break;`
`case '-':`	`case '-':`
`op = BINOP_SUB;`	`op = BINOP_SUB;`
`break;`	`break;`
`case SLASH_SLASH:`	`case SLASH_SLASH:`
`op = BINOP_CONCAT;`	`op = BINOP_CONCAT;`
`break;`	`break;`
`default:`	`default:`
`return;`	`return;`
`}`	`}`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`parse_operand4 ();`	`parse_operand4 ();`
`write_exp_elt_opcode (op);`	`write_exp_elt_opcode (op);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`parse_operand2 ()`	`parse_operand2 ()`
`{`	`{`
`enum exp_opcode op;`	`enum exp_opcode op;`
`parse_operand3 ();`	`parse_operand3 ();`
`for (;;)`	`for (;;)`
`{`	`{`
`if (check_token (IN))`	`if (check_token (IN))`
`{`	`{`
`parse_operand3 ();`	`parse_operand3 ();`
`write_exp_elt_opcode (BINOP_IN);`	`write_exp_elt_opcode (BINOP_IN);`
`}`	`}`
`else`	`else`
`{`	`{`
`switch (PEEK_TOKEN ())`	`switch (PEEK_TOKEN ())`
`{`	`{`
`case '>':`	`case '>':`
`op = BINOP_GTR;`	`op = BINOP_GTR;`
`break;`	`break;`
`case GEQ:`	`case GEQ:`
`op = BINOP_GEQ;`	`op = BINOP_GEQ;`
`break;`	`break;`
`case '<':`	`case '<':`
`op = BINOP_LESS;`	`op = BINOP_LESS;`
`break;`	`break;`
`case LEQ:`	`case LEQ:`
`op = BINOP_LEQ;`	`op = BINOP_LEQ;`
`break;`	`break;`
`case '=':`	`case '=':`
`op = BINOP_EQUAL;`	`op = BINOP_EQUAL;`
`break;`	`break;`
`case NOTEQUAL:`	`case NOTEQUAL:`
`op = BINOP_NOTEQUAL;`	`op = BINOP_NOTEQUAL;`
`break;`	`break;`
`default:`	`default:`
`return;`	`return;`
`}`	`}`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`parse_operand3 ();`	`parse_operand3 ();`
`write_exp_elt_opcode (op);`	`write_exp_elt_opcode (op);`
`}`	`}`
`}`	`}`
`}`	`}`

`static void`	`static void`
`parse_operand1 ()`	`parse_operand1 ()`
`{`	`{`
`enum exp_opcode op;`	`enum exp_opcode op;`
`parse_operand2 ();`	`parse_operand2 ();`
`for (;;)`	`for (;;)`
`{`	`{`
`switch (PEEK_TOKEN ())`	`switch (PEEK_TOKEN ())`
`{`	`{`
`case LOGAND:`	`case LOGAND:`
`op = BINOP_BITWISE_AND;`	`op = BINOP_BITWISE_AND;`
`break;`	`break;`
`case ANDIF:`	`case ANDIF:`
`op = BINOP_LOGICAL_AND;`	`op = BINOP_LOGICAL_AND;`
`break;`	`break;`
`default:`	`default:`
`return;`	`return;`
`}`	`}`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`parse_operand2 ();`	`parse_operand2 ();`
`write_exp_elt_opcode (op);`	`write_exp_elt_opcode (op);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`parse_operand0 ()`	`parse_operand0 ()`
`{`	`{`
`enum exp_opcode op;`	`enum exp_opcode op;`
`parse_operand1 ();`	`parse_operand1 ();`
`for (;;)`	`for (;;)`
`{`	`{`
`switch (PEEK_TOKEN ())`	`switch (PEEK_TOKEN ())`
`{`	`{`
`case LOGIOR:`	`case LOGIOR:`
`op = BINOP_BITWISE_IOR;`	`op = BINOP_BITWISE_IOR;`
`break;`	`break;`
`case LOGXOR:`	`case LOGXOR:`
`op = BINOP_BITWISE_XOR;`	`op = BINOP_BITWISE_XOR;`
`break;`	`break;`
`case ORIF:`	`case ORIF:`
`op = BINOP_LOGICAL_OR;`	`op = BINOP_LOGICAL_OR;`
`break;`	`break;`
`default:`	`default:`
`return;`	`return;`
`}`	`}`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`parse_operand1 ();`	`parse_operand1 ();`
`write_exp_elt_opcode (op);`	`write_exp_elt_opcode (op);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`parse_expr ()`	`parse_expr ()`
`{`	`{`
`parse_operand0 ();`	`parse_operand0 ();`
`if (check_token (GDB_ASSIGNMENT))`	`if (check_token (GDB_ASSIGNMENT))`
`{`	`{`
`parse_expr ();`	`parse_expr ();`
`write_exp_elt_opcode (BINOP_ASSIGN);`	`write_exp_elt_opcode (BINOP_ASSIGN);`
`}`	`}`
`}`	`}`

`static void`	`static void`
`parse_then_alternative ()`	`parse_then_alternative ()`
`{`	`{`
`expect (THEN, "missing 'THEN' in 'IF' expression");`	`expect (THEN, "missing 'THEN' in 'IF' expression");`
`parse_expr ();`	`parse_expr ();`
`}`	`}`

`static void`	`static void`
`parse_else_alternative ()`	`parse_else_alternative ()`
`{`	`{`
`if (check_token (ELSIF))`	`if (check_token (ELSIF))`
`parse_if_expression_body ();`	`parse_if_expression_body ();`
`else if (check_token (ELSE))`	`else if (check_token (ELSE))`
`parse_expr ();`	`parse_expr ();`
`else`	`else`
`error ("missing ELSE/ELSIF in IF expression");`	`error ("missing ELSE/ELSIF in IF expression");`
`}`	`}`

`/* Matches: <boolean expression> <then alternative> <else alternative> */`	`/* Matches: <boolean expression> <then alternative> <else alternative> */`

`static void`	`static void`
`parse_if_expression_body ()`	`parse_if_expression_body ()`
`{`	`{`
`parse_expr ();`	`parse_expr ();`
`parse_then_alternative ();`	`parse_then_alternative ();`
`parse_else_alternative ();`	`parse_else_alternative ();`
`write_exp_elt_opcode (TERNOP_COND);`	`write_exp_elt_opcode (TERNOP_COND);`
`}`	`}`

`static void`	`static void`
`parse_if_expression ()`	`parse_if_expression ()`
`{`	`{`
`require (IF);`	`require (IF);`
`parse_if_expression_body ();`	`parse_if_expression_body ();`
`expect (FI, "missing 'FI' at end of conditional expression");`	`expect (FI, "missing 'FI' at end of conditional expression");`
`}`	`}`

`/* An <untyped_expr> is a superset of <expr>. It also includes`	`/* An <untyped_expr> is a superset of <expr>. It also includes`
`<conditional expressions> and untyped <tuples>, whose types`	`<conditional expressions> and untyped <tuples>, whose types`
`are not given by their constituents. Hence, these are only`	`are not given by their constituents. Hence, these are only`
`allowed in certain contexts that expect a certain type.`	`allowed in certain contexts that expect a certain type.`
`You should call convert() to fix up the <untyped_expr>. */`	`You should call convert() to fix up the <untyped_expr>. */`

`static void`	`static void`
`parse_untyped_expr ()`	`parse_untyped_expr ()`
`{`	`{`
`switch (PEEK_TOKEN ())`	`switch (PEEK_TOKEN ())`
`{`	`{`
`case IF:`	`case IF:`
`parse_if_expression ();`	`parse_if_expression ();`
`return;`	`return;`
`case CASE:`	`case CASE:`
`error ("not implemented: CASE expression");`	`error ("not implemented: CASE expression");`
`case '(':`	`case '(':`
`switch (PEEK_TOKEN1 ())`	`switch (PEEK_TOKEN1 ())`
`{`	`{`
`case IF:`	`case IF:`
`case CASE:`	`case CASE:`
`goto skip_lprn;`	`goto skip_lprn;`
`case '[':`	`case '[':`
`skip_lprn:`	`skip_lprn:`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`parse_untyped_expr ();`	`parse_untyped_expr ();`
`expect (')', "missing ')'");`	`expect (')', "missing ')'");`
`return;`	`return;`
`default:;`	`default:;`
`/* fall through */`	`/* fall through */`
`}`	`}`
`default:`	`default:`
`parse_operand0 ();`	`parse_operand0 ();`
`}`	`}`
`}`	`}`

`int`	`int`
`chill_parse ()`	`chill_parse ()`
`{`	`{`
`terminal_buffer[0] = TOKEN_NOT_READ;`	`terminal_buffer[0] = TOKEN_NOT_READ;`
`if (PEEK_TOKEN () == TYPENAME && PEEK_TOKEN1 () == END_TOKEN)`	`if (PEEK_TOKEN () == TYPENAME && PEEK_TOKEN1 () == END_TOKEN)`
`{`	`{`
`write_exp_elt_opcode (OP_TYPE);`	`write_exp_elt_opcode (OP_TYPE);`
`write_exp_elt_type (PEEK_LVAL ().tsym.type);`	`write_exp_elt_type (PEEK_LVAL ().tsym.type);`
`write_exp_elt_opcode (OP_TYPE);`	`write_exp_elt_opcode (OP_TYPE);`
`FORWARD_TOKEN ();`	`FORWARD_TOKEN ();`
`}`	`}`
`else`	`else`
`parse_expr ();`	`parse_expr ();`
`if (terminal_buffer[0] != END_TOKEN)`	`if (terminal_buffer[0] != END_TOKEN)`
`{`	`{`
`if (comma_terminates && terminal_buffer[0] == ',')`	`if (comma_terminates && terminal_buffer[0] == ',')`
`lexptr--; /* Put the comma back. */`	`lexptr--; /* Put the comma back. */`
`else`	`else`
`error ("Junk after end of expression.");`	`error ("Junk after end of expression.");`
`}`	`}`
`return 0;`	`return 0;`
`}`	`}`


`/* Implementation of a dynamically expandable buffer for processing input`	`/* Implementation of a dynamically expandable buffer for processing input`
`characters acquired through lexptr and building a value to return in`	`characters acquired through lexptr and building a value to return in`
`yylval. */`	`yylval. */`

`static char tempbuf; / Current buffer contents */`	`static char tempbuf; / Current buffer contents */`
`static int tempbufsize; /* Size of allocated buffer */`	`static int tempbufsize; /* Size of allocated buffer */`
`static int tempbufindex; /* Current index into buffer */`	`static int tempbufindex; /* Current index into buffer */`

`#define GROWBY_MIN_SIZE 64 /* Minimum amount to grow buffer by */`	`#define GROWBY_MIN_SIZE 64 /* Minimum amount to grow buffer by */`

`#define CHECKBUF(size) \`	`#define CHECKBUF(size) \`
`do { \`	`do { \`
`if (tempbufindex + (size) >= tempbufsize) \`	`if (tempbufindex + (size) >= tempbufsize) \`
`{ \`	`{ \`
`growbuf_by_size (size); \`	`growbuf_by_size (size); \`
`} \`	`} \`
`} while (0);`	`} while (0);`

`/* Grow the static temp buffer if necessary, including allocating the first one`	`/* Grow the static temp buffer if necessary, including allocating the first one`
`on demand. */`	`on demand. */`

`static void`	`static void`
`growbuf_by_size (count)`	`growbuf_by_size (count)`
`int count;`	`int count;`
`{`	`{`
`int growby;`	`int growby;`

`growby = max (count, GROWBY_MIN_SIZE);`	`growby = max (count, GROWBY_MIN_SIZE);`
`tempbufsize += growby;`	`tempbufsize += growby;`
`if (tempbuf == NULL)`	`if (tempbuf == NULL)`
`{`	`{`
`tempbuf = (char *) xmalloc (tempbufsize);`	`tempbuf = (char *) xmalloc (tempbufsize);`
`}`	`}`
`else`	`else`
`{`	`{`
`tempbuf = (char *) xrealloc (tempbuf, tempbufsize);`	`tempbuf = (char *) xrealloc (tempbuf, tempbufsize);`
`}`	`}`
`}`	`}`

`/* Try to consume a simple name string token. If successful, returns`	`/* Try to consume a simple name string token. If successful, returns`
`a pointer to a nullbyte terminated copy of the name that can be used`	`a pointer to a nullbyte terminated copy of the name that can be used`
`in symbol table lookups. If not successful, returns NULL. */`	`in symbol table lookups. If not successful, returns NULL. */`

`static char *`	`static char *`
`match_simple_name_string ()`	`match_simple_name_string ()`
`{`	`{`
`char *tokptr = lexptr;`	`char *tokptr = lexptr;`

`if (isalpha (tokptr) \|\| tokptr == '_')`	`if (isalpha (tokptr) \|\| tokptr == '_')`
`{`	`{`
`char *result;`	`char *result;`
`do`	`do`
`{`	`{`
`tokptr++;`	`tokptr++;`
`}`	`}`
`while (isalnum (tokptr) \|\| (tokptr == '_'));`	`while (isalnum (tokptr) \|\| (tokptr == '_'));`
`yylval.sval.ptr = lexptr;`	`yylval.sval.ptr = lexptr;`
`yylval.sval.length = tokptr - lexptr;`	`yylval.sval.length = tokptr - lexptr;`
`lexptr = tokptr;`	`lexptr = tokptr;`
`result = copy_name (yylval.sval);`	`result = copy_name (yylval.sval);`
`return result;`	`return result;`
`}`	`}`
`return (NULL);`	`return (NULL);`
`}`	`}`

`/* Start looking for a value composed of valid digits as set by the base`	`/* Start looking for a value composed of valid digits as set by the base`
`in use. Note that '_' characters are valid anywhere, in any quantity,`	`in use. Note that '_' characters are valid anywhere, in any quantity,`
`and are simply ignored. Since we must find at least one valid digit,`	`and are simply ignored. Since we must find at least one valid digit,`
`or reject this token as an integer literal, we keep track of how many`	`or reject this token as an integer literal, we keep track of how many`
`digits we have encountered. */`	`digits we have encountered. */`

`static int`	`static int`
`decode_integer_value (base, tokptrptr, ivalptr)`	`decode_integer_value (base, tokptrptr, ivalptr)`
`int base;`	`int base;`
`char **tokptrptr;`	`char **tokptrptr;`
`LONGEST *ivalptr;`	`LONGEST *ivalptr;`
`{`	`{`
`char tokptr = tokptrptr;`	`char tokptr = tokptrptr;`
`int temp;`	`int temp;`
`int digits = 0;`	`int digits = 0;`

`while (*tokptr != '\0')`	`while (*tokptr != '\0')`
`{`	`{`
`temp = *tokptr;`	`temp = *tokptr;`
`if (isupper (temp))`	`if (isupper (temp))`
`temp = tolower (temp);`	`temp = tolower (temp);`
`tokptr++;`	`tokptr++;`
`switch (temp)`	`switch (temp)`
`{`	`{`
`case '_':`	`case '_':`
`continue;`	`continue;`
`case '0':`	`case '0':`
`case '1':`	`case '1':`
`case '2':`	`case '2':`
`case '3':`	`case '3':`
`case '4':`	`case '4':`
`case '5':`	`case '5':`
`case '6':`	`case '6':`
`case '7':`	`case '7':`
`case '8':`	`case '8':`
`case '9':`	`case '9':`
`temp -= '0';`	`temp -= '0';`
`break;`	`break;`
`case 'a':`	`case 'a':`
`case 'b':`	`case 'b':`
`case 'c':`	`case 'c':`
`case 'd':`	`case 'd':`
`case 'e':`	`case 'e':`
`case 'f':`	`case 'f':`
`temp -= 'a';`	`temp -= 'a';`
`temp += 10;`	`temp += 10;`
`break;`	`break;`
`default:`	`default:`
`temp = base;`	`temp = base;`
`break;`	`break;`
`}`	`}`
`if (temp < base)`	`if (temp < base)`
`{`	`{`
`digits++;`	`digits++;`
`ivalptr = base;`	`ivalptr = base;`
`*ivalptr += temp;`	`*ivalptr += temp;`
`}`	`}`
`else`	`else`
`{`	`{`
`/* Found something not in domain for current base. */`	`/* Found something not in domain for current base. */`
`tokptr--; /* Unconsume what gave us indigestion. */`	`tokptr--; /* Unconsume what gave us indigestion. */`
`break;`	`break;`
`}`	`}`
`}`	`}`

`/* If we didn't find any digits, then we don't have a valid integer`	`/* If we didn't find any digits, then we don't have a valid integer`
`value, so reject the entire token. Otherwise, update the lexical`	`value, so reject the entire token. Otherwise, update the lexical`
`scan pointer, and return non-zero for success. */`	`scan pointer, and return non-zero for success. */`

`if (digits == 0)`	`if (digits == 0)`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`
`else`	`else`
`{`	`{`
`*tokptrptr = tokptr;`	`*tokptrptr = tokptr;`
`return (1);`	`return (1);`
`}`	`}`
`}`	`}`

`static int`	`static int`
`decode_integer_literal (valptr, tokptrptr)`	`decode_integer_literal (valptr, tokptrptr)`
`LONGEST *valptr;`	`LONGEST *valptr;`
`char **tokptrptr;`	`char **tokptrptr;`
`{`	`{`
`char tokptr = tokptrptr;`	`char tokptr = tokptrptr;`
`int base = 0;`	`int base = 0;`
`LONGEST ival = 0;`	`LONGEST ival = 0;`
`int explicit_base = 0;`	`int explicit_base = 0;`

`/* Look for an explicit base specifier, which is optional. */`	`/* Look for an explicit base specifier, which is optional. */`

`switch (*tokptr)`	`switch (*tokptr)`
`{`	`{`
`case 'd':`	`case 'd':`
`case 'D':`	`case 'D':`
`explicit_base++;`	`explicit_base++;`
`base = 10;`	`base = 10;`
`tokptr++;`	`tokptr++;`
`break;`	`break;`
`case 'b':`	`case 'b':`
`case 'B':`	`case 'B':`
`explicit_base++;`	`explicit_base++;`
`base = 2;`	`base = 2;`
`tokptr++;`	`tokptr++;`
`break;`	`break;`
`case 'h':`	`case 'h':`
`case 'H':`	`case 'H':`
`explicit_base++;`	`explicit_base++;`
`base = 16;`	`base = 16;`
`tokptr++;`	`tokptr++;`
`break;`	`break;`
`case 'o':`	`case 'o':`
`case 'O':`	`case 'O':`
`explicit_base++;`	`explicit_base++;`
`base = 8;`	`base = 8;`
`tokptr++;`	`tokptr++;`
`break;`	`break;`
`default:`	`default:`
`base = 10;`	`base = 10;`
`break;`	`break;`
`}`	`}`

`/* If we found an explicit base ensure that the character after the`	`/* If we found an explicit base ensure that the character after the`
`explicit base is a single quote. */`	`explicit base is a single quote. */`

`if (explicit_base && (*tokptr++ != '\''))`	`if (explicit_base && (*tokptr++ != '\''))`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`

`/* Attempt to decode whatever follows as an integer value in the`	`/* Attempt to decode whatever follows as an integer value in the`
`indicated base, updating the token pointer in the process and`	`indicated base, updating the token pointer in the process and`
`computing the value into ival. Also, if we have an explicit`	`computing the value into ival. Also, if we have an explicit`
`base, then the next character must not be a single quote, or we`	`base, then the next character must not be a single quote, or we`
`have a bitstring literal, so reject the entire token in this case.`	`have a bitstring literal, so reject the entire token in this case.`
`Otherwise, update the lexical scan pointer, and return non-zero`	`Otherwise, update the lexical scan pointer, and return non-zero`
`for success. */`	`for success. */`

`if (!decode_integer_value (base, &tokptr, &ival))`	`if (!decode_integer_value (base, &tokptr, &ival))`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`
`else if (explicit_base && (*tokptr == '\''))`	`else if (explicit_base && (*tokptr == '\''))`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`
`else`	`else`
`{`	`{`
`*valptr = ival;`	`*valptr = ival;`
`*tokptrptr = tokptr;`	`*tokptrptr = tokptr;`
`return (1);`	`return (1);`
`}`	`}`
`}`	`}`

`/* If it wasn't for the fact that floating point values can contain '_'`	`/* If it wasn't for the fact that floating point values can contain '_'`
`characters, we could just let strtod do all the hard work by letting it`	`characters, we could just let strtod do all the hard work by letting it`
`try to consume as much of the current token buffer as possible and`	`try to consume as much of the current token buffer as possible and`
`find a legal conversion. Unfortunately we need to filter out the '_'`	`find a legal conversion. Unfortunately we need to filter out the '_'`
`characters before calling strtod, which we do by copying the other`	`characters before calling strtod, which we do by copying the other`
`legal chars to a local buffer to be converted. However since we also`	`legal chars to a local buffer to be converted. However since we also`
`need to keep track of where the last unconsumed character in the input`	`need to keep track of where the last unconsumed character in the input`
`buffer is, we have transfer only as many characters as may compose a`	`buffer is, we have transfer only as many characters as may compose a`
`legal floating point value. */`	`legal floating point value. */`

`static enum ch_terminal`	`static enum ch_terminal`
`match_float_literal ()`	`match_float_literal ()`
`{`	`{`
`char *tokptr = lexptr;`	`char *tokptr = lexptr;`
`char *buf;`	`char *buf;`
`char *copy;`	`char *copy;`
`double dval;`	`double dval;`
`extern double strtod ();`	`extern double strtod ();`

`/* Make local buffer in which to build the string to convert. This is`	`/* Make local buffer in which to build the string to convert. This is`
`required because underscores are valid in chill floating point numbers`	`required because underscores are valid in chill floating point numbers`
`but not in the string passed to strtod to convert. The string will be`	`but not in the string passed to strtod to convert. The string will be`
`no longer than our input string. */`	`no longer than our input string. */`

`copy = buf = (char *) alloca (strlen (tokptr) + 1);`	`copy = buf = (char *) alloca (strlen (tokptr) + 1);`

`/* Transfer all leading digits to the conversion buffer, discarding any`	`/* Transfer all leading digits to the conversion buffer, discarding any`
`underscores. */`	`underscores. */`

`while (isdigit (tokptr) \|\| tokptr == '_')`	`while (isdigit (tokptr) \|\| tokptr == '_')`
`{`	`{`
`if (*tokptr != '_')`	`if (*tokptr != '_')`
`{`	`{`
`copy++ = tokptr;`	`copy++ = tokptr;`
`}`	`}`
`tokptr++;`	`tokptr++;`
`}`	`}`

`/* Now accept either a '.', or one of [eEdD]. Dot is legal regardless`	`/* Now accept either a '.', or one of [eEdD]. Dot is legal regardless`
`of whether we found any leading digits, and we simply accept it and`	`of whether we found any leading digits, and we simply accept it and`
`continue on to look for the fractional part and/or exponent. One of`	`continue on to look for the fractional part and/or exponent. One of`
`[eEdD] is legal only if we have seen digits, and means that there`	`[eEdD] is legal only if we have seen digits, and means that there`
`is no fractional part. If we find neither of these, then this is`	`is no fractional part. If we find neither of these, then this is`
`not a floating point number, so return failure. */`	`not a floating point number, so return failure. */`

`switch (*tokptr++)`	`switch (*tokptr++)`
`{`	`{`
`case '.':`	`case '.':`
`/* Accept and then look for fractional part and/or exponent. */`	`/* Accept and then look for fractional part and/or exponent. */`
`*copy++ = '.';`	`*copy++ = '.';`
`break;`	`break;`

`case 'e':`	`case 'e':`
`case 'E':`	`case 'E':`
`case 'd':`	`case 'd':`
`case 'D':`	`case 'D':`
`if (copy == buf)`	`if (copy == buf)`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`
`*copy++ = 'e';`	`*copy++ = 'e';`
`goto collect_exponent;`	`goto collect_exponent;`
`break;`	`break;`

`default:`	`default:`
`return (0);`	`return (0);`
`break;`	`break;`
`}`	`}`

`/* We found a '.', copy any fractional digits to the conversion buffer, up`	`/* We found a '.', copy any fractional digits to the conversion buffer, up`
`to the first nondigit, non-underscore character. */`	`to the first nondigit, non-underscore character. */`

`while (isdigit (tokptr) \|\| tokptr == '_')`	`while (isdigit (tokptr) \|\| tokptr == '_')`
`{`	`{`
`if (*tokptr != '_')`	`if (*tokptr != '_')`
`{`	`{`
`copy++ = tokptr;`	`copy++ = tokptr;`
`}`	`}`
`tokptr++;`	`tokptr++;`
`}`	`}`

`/* Look for an exponent, which must start with one of [eEdD]. If none`	`/* Look for an exponent, which must start with one of [eEdD]. If none`
`is found, jump directly to trying to convert what we have collected`	`is found, jump directly to trying to convert what we have collected`
`so far. */`	`so far. */`

`switch (*tokptr)`	`switch (*tokptr)`
`{`	`{`
`case 'e':`	`case 'e':`
`case 'E':`	`case 'E':`
`case 'd':`	`case 'd':`
`case 'D':`	`case 'D':`
`*copy++ = 'e';`	`*copy++ = 'e';`
`tokptr++;`	`tokptr++;`
`break;`	`break;`
`default:`	`default:`
`goto convert_float;`	`goto convert_float;`
`break;`	`break;`
`}`	`}`

`/* Accept an optional '-' or '+' following one of [eEdD]. */`	`/* Accept an optional '-' or '+' following one of [eEdD]. */`

`collect_exponent:`	`collect_exponent:`
`if (tokptr == '+' \|\| tokptr == '-')`	`if (tokptr == '+' \|\| tokptr == '-')`
`{`	`{`
`copy++ = tokptr++;`	`copy++ = tokptr++;`
`}`	`}`

`/* Now copy an exponent into the conversion buffer. Note that at the`	`/* Now copy an exponent into the conversion buffer. Note that at the`
`moment underscores are not allowed in exponents. */`	`moment underscores are not allowed in exponents. */`

`while (isdigit (*tokptr))`	`while (isdigit (*tokptr))`
`{`	`{`
`copy++ = tokptr++;`	`copy++ = tokptr++;`
`}`	`}`

`/* If we transfered any chars to the conversion buffer, try to interpret its`	`/* If we transfered any chars to the conversion buffer, try to interpret its`
`contents as a floating point value. If any characters remain, then we`	`contents as a floating point value. If any characters remain, then we`
`must not have a valid floating point string. */`	`must not have a valid floating point string. */`

`convert_float:`	`convert_float:`
`*copy = '\0';`	`*copy = '\0';`
`if (copy != buf)`	`if (copy != buf)`
`{`	`{`
`dval = strtod (buf, &copy);`	`dval = strtod (buf, &copy);`
`if (*copy == '\0')`	`if (*copy == '\0')`
`{`	`{`
`yylval.dval = dval;`	`yylval.dval = dval;`
`lexptr = tokptr;`	`lexptr = tokptr;`
`return (FLOAT_LITERAL);`	`return (FLOAT_LITERAL);`
`}`	`}`
`}`	`}`
`return (0);`	`return (0);`
`}`	`}`

`/* Recognize a string literal. A string literal is a sequence`	`/* Recognize a string literal. A string literal is a sequence`
`of characters enclosed in matching single or double quotes, except that`	`of characters enclosed in matching single or double quotes, except that`
`a single character inside single quotes is a character literal, which`	`a single character inside single quotes is a character literal, which`
`we reject as a string literal. To embed the terminator character inside`	`we reject as a string literal. To embed the terminator character inside`
`a string, it is simply doubled (I.E. "this""is""one""string") */`	`a string, it is simply doubled (I.E. "this""is""one""string") */`

`static enum ch_terminal`	`static enum ch_terminal`
`match_string_literal ()`	`match_string_literal ()`
`{`	`{`
`char *tokptr = lexptr;`	`char *tokptr = lexptr;`
`int in_ctrlseq = 0;`	`int in_ctrlseq = 0;`
`LONGEST ival;`	`LONGEST ival;`

`for (tempbufindex = 0, tokptr++; *tokptr != '\0'; tokptr++)`	`for (tempbufindex = 0, tokptr++; *tokptr != '\0'; tokptr++)`
`{`	`{`
`CHECKBUF (1);`	`CHECKBUF (1);`
`tryagain:;`	`tryagain:;`
`if (in_ctrlseq)`	`if (in_ctrlseq)`
`{`	`{`
`/* skip possible whitespaces */`	`/* skip possible whitespaces */`
`while ((tokptr == ' ' \|\| tokptr == '\t') && *tokptr)`	`while ((tokptr == ' ' \|\| tokptr == '\t') && *tokptr)`
`tokptr++;`	`tokptr++;`
`if (*tokptr == ')')`	`if (*tokptr == ')')`
`{`	`{`
`in_ctrlseq = 0;`	`in_ctrlseq = 0;`
`tokptr++;`	`tokptr++;`
`goto tryagain;`	`goto tryagain;`
`}`	`}`
`else if (*tokptr != ',')`	`else if (*tokptr != ',')`
`error ("Invalid control sequence");`	`error ("Invalid control sequence");`
`tokptr++;`	`tokptr++;`
`/* skip possible whitespaces */`	`/* skip possible whitespaces */`
`while ((tokptr == ' ' \|\| tokptr == '\t') && *tokptr)`	`while ((tokptr == ' ' \|\| tokptr == '\t') && *tokptr)`
`tokptr++;`	`tokptr++;`
`if (!decode_integer_literal (&ival, &tokptr))`	`if (!decode_integer_literal (&ival, &tokptr))`
`error ("Invalid control sequence");`	`error ("Invalid control sequence");`
`tokptr--;`	`tokptr--;`
`}`	`}`
`else if (tokptr == lexptr)`	`else if (tokptr == lexptr)`
`{`	`{`
`if ((tokptr + 1) == lexptr)`	`if ((tokptr + 1) == lexptr)`
`{`	`{`
`ival = *tokptr++;`	`ival = *tokptr++;`
`}`	`}`
`else`	`else`
`{`	`{`
`break;`	`break;`
`}`	`}`
`}`	`}`
`else if (*tokptr == '^')`	`else if (*tokptr == '^')`
`{`	`{`
`if (*(tokptr + 1) == '(')`	`if (*(tokptr + 1) == '(')`
`{`	`{`
`in_ctrlseq = 1;`	`in_ctrlseq = 1;`
`tokptr += 2;`	`tokptr += 2;`
`if (!decode_integer_literal (&ival, &tokptr))`	`if (!decode_integer_literal (&ival, &tokptr))`
`error ("Invalid control sequence");`	`error ("Invalid control sequence");`
`tokptr--;`	`tokptr--;`
`}`	`}`
`else if (*(tokptr + 1) == '^')`	`else if (*(tokptr + 1) == '^')`
`ival = *tokptr++;`	`ival = *tokptr++;`
`else`	`else`
`error ("Invalid control sequence");`	`error ("Invalid control sequence");`
`}`	`}`
`else`	`else`
`ival = *tokptr;`	`ival = *tokptr;`
`tempbuf[tempbufindex++] = ival;`	`tempbuf[tempbufindex++] = ival;`
`}`	`}`
`if (in_ctrlseq)`	`if (in_ctrlseq)`
`error ("Invalid control sequence");`	`error ("Invalid control sequence");`

`if (tokptr == '\0' / no terminator */`	`if (tokptr == '\0' / no terminator */`
`\|\| (tempbufindex == 1 && tokptr == '\'')) / char literal */`	`\|\| (tempbufindex == 1 && tokptr == '\'')) / char literal */`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`
`else`	`else`
`{`	`{`
`tempbuf[tempbufindex] = '\0';`	`tempbuf[tempbufindex] = '\0';`
`yylval.sval.ptr = tempbuf;`	`yylval.sval.ptr = tempbuf;`
`yylval.sval.length = tempbufindex;`	`yylval.sval.length = tempbufindex;`
`lexptr = ++tokptr;`	`lexptr = ++tokptr;`
`return (CHARACTER_STRING_LITERAL);`	`return (CHARACTER_STRING_LITERAL);`
`}`	`}`
`}`	`}`

`/* Recognize a character literal. A character literal is single character`	`/* Recognize a character literal. A character literal is single character`
`or a control sequence, enclosed in single quotes. A control sequence`	`or a control sequence, enclosed in single quotes. A control sequence`
`is a comma separated list of one or more integer literals, enclosed`	`is a comma separated list of one or more integer literals, enclosed`
`in parenthesis and introduced with a circumflex character.`	`in parenthesis and introduced with a circumflex character.`

`EX: 'a' '^(7)' '^(7,8)'`	`EX: 'a' '^(7)' '^(7,8)'`

`As a GNU chill extension, the syntax C'xx' is also recognized as a`	`As a GNU chill extension, the syntax C'xx' is also recognized as a`
`character literal, where xx is a hex value for the character.`	`character literal, where xx is a hex value for the character.`

`Note that more than a single character, enclosed in single quotes, is`	`Note that more than a single character, enclosed in single quotes, is`
`a string literal.`	`a string literal.`

`Returns CHARACTER_LITERAL if a match is found.`	`Returns CHARACTER_LITERAL if a match is found.`
`*/`	`*/`

`static enum ch_terminal`	`static enum ch_terminal`
`match_character_literal ()`	`match_character_literal ()`
`{`	`{`
`char *tokptr = lexptr;`	`char *tokptr = lexptr;`
`LONGEST ival = 0;`	`LONGEST ival = 0;`

`if ((tokptr == 'c' \|\| tokptr == 'C') && (*(tokptr + 1) == '\''))`	`if ((tokptr == 'c' \|\| tokptr == 'C') && (*(tokptr + 1) == '\''))`
`{`	`{`
`/* We have a GNU chill extension form, so skip the leading "C'",`	`/* We have a GNU chill extension form, so skip the leading "C'",`
`decode the hex value, and then ensure that we have a trailing`	`decode the hex value, and then ensure that we have a trailing`
`single quote character. */`	`single quote character. */`
`tokptr += 2;`	`tokptr += 2;`
`if (!decode_integer_value (16, &tokptr, &ival) \|\| (*tokptr != '\''))`	`if (!decode_integer_value (16, &tokptr, &ival) \|\| (*tokptr != '\''))`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`
`tokptr++;`	`tokptr++;`
`}`	`}`
`else if (*tokptr == '\'')`	`else if (*tokptr == '\'')`
`{`	`{`
`tokptr++;`	`tokptr++;`

`/* Determine which form we have, either a control sequence or the`	`/* Determine which form we have, either a control sequence or the`
`single character form. */`	`single character form. */`

`if (*tokptr == '^')`	`if (*tokptr == '^')`
`{`	`{`
`if (*(tokptr + 1) == '(')`	`if (*(tokptr + 1) == '(')`
`{`	`{`
`/* Match and decode a control sequence. Return zero if we don't`	`/* Match and decode a control sequence. Return zero if we don't`
`find a valid integer literal, or if the next unconsumed character`	`find a valid integer literal, or if the next unconsumed character`
`after the integer literal is not the trailing ')'. */`	`after the integer literal is not the trailing ')'. */`
`tokptr += 2;`	`tokptr += 2;`
`if (!decode_integer_literal (&ival, &tokptr) \|\| (*tokptr++ != ')'))`	`if (!decode_integer_literal (&ival, &tokptr) \|\| (*tokptr++ != ')'))`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`
`}`	`}`
`else if (*(tokptr + 1) == '^')`	`else if (*(tokptr + 1) == '^')`
`{`	`{`
`ival = *tokptr;`	`ival = *tokptr;`
`tokptr += 2;`	`tokptr += 2;`
`}`	`}`
`else`	`else`
`/* fail */`	`/* fail */`
`error ("Invalid control sequence");`	`error ("Invalid control sequence");`
`}`	`}`
`else if (*tokptr == '\'')`	`else if (*tokptr == '\'')`
`{`	`{`
`/* this must be duplicated */`	`/* this must be duplicated */`
`ival = *tokptr;`	`ival = *tokptr;`
`tokptr += 2;`	`tokptr += 2;`
`}`	`}`
`else`	`else`
`{`	`{`
`ival = *tokptr++;`	`ival = *tokptr++;`
`}`	`}`

`/* The trailing quote has not yet been consumed. If we don't find`	`/* The trailing quote has not yet been consumed. If we don't find`
`it, then we have no match. */`	`it, then we have no match. */`

`if (*tokptr++ != '\'')`	`if (*tokptr++ != '\'')`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`
`}`	`}`
`else`	`else`
`{`	`{`
`/* Not a character literal. */`	`/* Not a character literal. */`
`return (0);`	`return (0);`
`}`	`}`
`yylval.typed_val.val = ival;`	`yylval.typed_val.val = ival;`
`yylval.typed_val.type = builtin_type_chill_char;`	`yylval.typed_val.type = builtin_type_chill_char;`
`lexptr = tokptr;`	`lexptr = tokptr;`
`return (CHARACTER_LITERAL);`	`return (CHARACTER_LITERAL);`
`}`	`}`

`/* Recognize an integer literal, as specified in Z.200 sec 5.2.4.2.`	`/* Recognize an integer literal, as specified in Z.200 sec 5.2.4.2.`
`Note that according to 5.2.4.2, a single "_" is also a valid integer`	`Note that according to 5.2.4.2, a single "_" is also a valid integer`
`literal, however GNU-chill requires there to be at least one "digit"`	`literal, however GNU-chill requires there to be at least one "digit"`
`in any integer literal. */`	`in any integer literal. */`

`static enum ch_terminal`	`static enum ch_terminal`
`match_integer_literal ()`	`match_integer_literal ()`
`{`	`{`
`char *tokptr = lexptr;`	`char *tokptr = lexptr;`
`LONGEST ival;`	`LONGEST ival;`

`if (!decode_integer_literal (&ival, &tokptr))`	`if (!decode_integer_literal (&ival, &tokptr))`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`
`else`	`else`
`{`	`{`
`yylval.typed_val.val = ival;`	`yylval.typed_val.val = ival;`
`#if defined(CC_HAS_LONG_LONG) && defined(__STDC__)`	`#if defined(CC_HAS_LONG_LONG) && defined(__STDC__)`
`if (ival > (LONGEST) 2147483647U \|\| ival < -(LONGEST) 2147483648U)`	`if (ival > (LONGEST) 2147483647U \|\| ival < -(LONGEST) 2147483648U)`
`yylval.typed_val.type = builtin_type_long_long;`	`yylval.typed_val.type = builtin_type_long_long;`
`else`	`else`
`#endif`	`#endif`
`yylval.typed_val.type = builtin_type_int;`	`yylval.typed_val.type = builtin_type_int;`
`lexptr = tokptr;`	`lexptr = tokptr;`
`return (INTEGER_LITERAL);`	`return (INTEGER_LITERAL);`
`}`	`}`
`}`	`}`

`/* Recognize a bit-string literal, as specified in Z.200 sec 5.2.4.8`	`/* Recognize a bit-string literal, as specified in Z.200 sec 5.2.4.8`
`Note that according to 5.2.4.8, a single "_" is also a valid bit-string`	`Note that according to 5.2.4.8, a single "_" is also a valid bit-string`
`literal, however GNU-chill requires there to be at least one "digit"`	`literal, however GNU-chill requires there to be at least one "digit"`
`in any bit-string literal. */`	`in any bit-string literal. */`

`static enum ch_terminal`	`static enum ch_terminal`
`match_bitstring_literal ()`	`match_bitstring_literal ()`
`{`	`{`
`register char *tokptr = lexptr;`	`register char *tokptr = lexptr;`
`int bitoffset = 0;`	`int bitoffset = 0;`
`int bitcount = 0;`	`int bitcount = 0;`
`int bits_per_char;`	`int bits_per_char;`
`int digit;`	`int digit;`

`tempbufindex = 0;`	`tempbufindex = 0;`
`CHECKBUF (1);`	`CHECKBUF (1);`
`tempbuf[0] = 0;`	`tempbuf[0] = 0;`

`/* Look for the required explicit base specifier. */`	`/* Look for the required explicit base specifier. */`

`switch (*tokptr++)`	`switch (*tokptr++)`
`{`	`{`
`case 'b':`	`case 'b':`
`case 'B':`	`case 'B':`
`bits_per_char = 1;`	`bits_per_char = 1;`
`break;`	`break;`
`case 'o':`	`case 'o':`
`case 'O':`	`case 'O':`
`bits_per_char = 3;`	`bits_per_char = 3;`
`break;`	`break;`
`case 'h':`	`case 'h':`
`case 'H':`	`case 'H':`
`bits_per_char = 4;`	`bits_per_char = 4;`
`break;`	`break;`
`default:`	`default:`
`return (0);`	`return (0);`
`break;`	`break;`
`}`	`}`

`/* Ensure that the character after the explicit base is a single quote. */`	`/* Ensure that the character after the explicit base is a single quote. */`

`if (*tokptr++ != '\'')`	`if (*tokptr++ != '\'')`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`

`while (tokptr != '\0' && tokptr != '\'')`	`while (tokptr != '\0' && tokptr != '\'')`
`{`	`{`
`digit = *tokptr;`	`digit = *tokptr;`
`if (isupper (digit))`	`if (isupper (digit))`
`digit = tolower (digit);`	`digit = tolower (digit);`
`tokptr++;`	`tokptr++;`
`switch (digit)`	`switch (digit)`
`{`	`{`
`case '_':`	`case '_':`
`continue;`	`continue;`
`case '0':`	`case '0':`
`case '1':`	`case '1':`
`case '2':`	`case '2':`
`case '3':`	`case '3':`
`case '4':`	`case '4':`
`case '5':`	`case '5':`
`case '6':`	`case '6':`
`case '7':`	`case '7':`
`case '8':`	`case '8':`
`case '9':`	`case '9':`
`digit -= '0';`	`digit -= '0';`
`break;`	`break;`
`case 'a':`	`case 'a':`
`case 'b':`	`case 'b':`
`case 'c':`	`case 'c':`
`case 'd':`	`case 'd':`
`case 'e':`	`case 'e':`
`case 'f':`	`case 'f':`
`digit -= 'a';`	`digit -= 'a';`
`digit += 10;`	`digit += 10;`
`break;`	`break;`
`default:`	`default:`
`/* this is not a bitstring literal, probably an integer */`	`/* this is not a bitstring literal, probably an integer */`
`return 0;`	`return 0;`
`}`	`}`
`if (digit >= 1 << bits_per_char)`	`if (digit >= 1 << bits_per_char)`
`{`	`{`
`/* Found something not in domain for current base. */`	`/* Found something not in domain for current base. */`
`error ("Too-large digit in bitstring or integer.");`	`error ("Too-large digit in bitstring or integer.");`
`}`	`}`
`else`	`else`
`{`	`{`
`/* Extract bits from digit, packing them into the bitstring byte. */`	`/* Extract bits from digit, packing them into the bitstring byte. */`
`int k = TARGET_BYTE_ORDER == BIG_ENDIAN ? bits_per_char - 1 : 0;`	`int k = TARGET_BYTE_ORDER == BIG_ENDIAN ? bits_per_char - 1 : 0;`
`for (; TARGET_BYTE_ORDER == BIG_ENDIAN ? k >= 0 : k < bits_per_char;`	`for (; TARGET_BYTE_ORDER == BIG_ENDIAN ? k >= 0 : k < bits_per_char;`
`TARGET_BYTE_ORDER == BIG_ENDIAN ? k-- : k++)`	`TARGET_BYTE_ORDER == BIG_ENDIAN ? k-- : k++)`
`{`	`{`
`bitcount++;`	`bitcount++;`
`if (digit & (1 << k))`	`if (digit & (1 << k))`
`{`	`{`
`tempbuf[tempbufindex] \|=`	`tempbuf[tempbufindex] \|=`
`(TARGET_BYTE_ORDER == BIG_ENDIAN)`	`(TARGET_BYTE_ORDER == BIG_ENDIAN)`
`? (1 << (HOST_CHAR_BIT - 1 - bitoffset))`	`? (1 << (HOST_CHAR_BIT - 1 - bitoffset))`
`: (1 << bitoffset);`	`: (1 << bitoffset);`
`}`	`}`
`bitoffset++;`	`bitoffset++;`
`if (bitoffset == HOST_CHAR_BIT)`	`if (bitoffset == HOST_CHAR_BIT)`
`{`	`{`
`bitoffset = 0;`	`bitoffset = 0;`
`tempbufindex++;`	`tempbufindex++;`
`CHECKBUF (1);`	`CHECKBUF (1);`
`tempbuf[tempbufindex] = 0;`	`tempbuf[tempbufindex] = 0;`
`}`	`}`
`}`	`}`
`}`	`}`
`}`	`}`

`/* Verify that we consumed everything up to the trailing single quote,`	`/* Verify that we consumed everything up to the trailing single quote,`
`and that we found some bits (IE not just underbars). */`	`and that we found some bits (IE not just underbars). */`

`if (*tokptr++ != '\'')`	`if (*tokptr++ != '\'')`
`{`	`{`
`return (0);`	`return (0);`
`}`	`}`
`else`	`else`
`{`	`{`
`yylval.sval.ptr = tempbuf;`	`yylval.sval.ptr = tempbuf;`
`yylval.sval.length = bitcount;`	`yylval.sval.length = bitcount;`
`lexptr = tokptr;`	`lexptr = tokptr;`
`return (BIT_STRING_LITERAL);`	`return (BIT_STRING_LITERAL);`
`}`	`}`
`}`	`}`

`struct token`	`struct token`
`{`	`{`
`char *operator;`	`char *operator;`
`int token;`	`int token;`
`};`	`};`

`static const struct token idtokentab[] =`	`static const struct token idtokentab[] =`
`{`	`{`
`{"array", ARRAY},`	`{"array", ARRAY},`
`{"length", LENGTH},`	`{"length", LENGTH},`
`{"lower", LOWER},`	`{"lower", LOWER},`
`{"upper", UPPER},`	`{"upper", UPPER},`
`{"andif", ANDIF},`	`{"andif", ANDIF},`
`{"pred", PRED},`	`{"pred", PRED},`
`{"succ", SUCC},`	`{"succ", SUCC},`
`{"card", CARD},`	`{"card", CARD},`
`{"size", SIZE},`	`{"size", SIZE},`
`{"orif", ORIF},`	`{"orif", ORIF},`
`{"num", NUM},`	`{"num", NUM},`
`{"abs", ABS},`	`{"abs", ABS},`
`{"max", MAX_TOKEN},`	`{"max", MAX_TOKEN},`
`{"min", MIN_TOKEN},`	`{"min", MIN_TOKEN},`
`{"mod", MOD},`	`{"mod", MOD},`
`{"rem", REM},`	`{"rem", REM},`
`{"not", NOT},`	`{"not", NOT},`
`{"xor", LOGXOR},`	`{"xor", LOGXOR},`
`{"and", LOGAND},`	`{"and", LOGAND},`
`{"in", IN},`	`{"in", IN},`
`{"or", LOGIOR},`	`{"or", LOGIOR},`
`{"up", UP},`	`{"up", UP},`
`{"addr", ADDR_TOKEN},`	`{"addr", ADDR_TOKEN},`
`{"null", EMPTINESS_LITERAL}`	`{"null", EMPTINESS_LITERAL}`
`};`	`};`

`static const struct token tokentab2[] =`	`static const struct token tokentab2[] =`
`{`	`{`
`{":=", GDB_ASSIGNMENT},`	`{":=", GDB_ASSIGNMENT},`
`{"//", SLASH_SLASH},`	`{"//", SLASH_SLASH},`
`{"->", POINTER},`	`{"->", POINTER},`
`{"/=", NOTEQUAL},`	`{"/=", NOTEQUAL},`
`{"<=", LEQ},`	`{"<=", LEQ},`
`{">=", GEQ}`	`{">=", GEQ}`
`};`	`};`

`/* Read one token, getting characters through lexptr. */`	`/* Read one token, getting characters through lexptr. */`
`/* This is where we will check to make sure that the language and the`	`/* This is where we will check to make sure that the language and the`
`operators used are compatible. */`	`operators used are compatible. */`

`static enum ch_terminal`	`static enum ch_terminal`
`ch_lex ()`	`ch_lex ()`
`{`	`{`
`unsigned int i;`	`unsigned int i;`
`enum ch_terminal token;`	`enum ch_terminal token;`
`char *inputname;`	`char *inputname;`
`struct symbol *sym;`	`struct symbol *sym;`

`/* Skip over any leading whitespace. */`	`/* Skip over any leading whitespace. */`
`while (isspace (*lexptr))`	`while (isspace (*lexptr))`
`{`	`{`
`lexptr++;`	`lexptr++;`
`}`	`}`
`/* Look for special single character cases which can't be the first`	`/* Look for special single character cases which can't be the first`
`character of some other multicharacter token. */`	`character of some other multicharacter token. */`
`switch (*lexptr)`	`switch (*lexptr)`
`{`	`{`
`case '\0':`	`case '\0':`
`return END_TOKEN;`	`return END_TOKEN;`
`case ',':`	`case ',':`
`case '=':`	`case '=':`
`case ';':`	`case ';':`
`case '!':`	`case '!':`
`case '+':`	`case '+':`
`case '*':`	`case '*':`
`case '(':`	`case '(':`
`case ')':`	`case ')':`
`case '[':`	`case '[':`
`case ']':`	`case ']':`
`return (*lexptr++);`	`return (*lexptr++);`
`}`	`}`
`/* Look for characters which start a particular kind of multicharacter`	`/* Look for characters which start a particular kind of multicharacter`
`token, such as a character literal, register name, convenience`	`token, such as a character literal, register name, convenience`
`variable name, string literal, etc. */`	`variable name, string literal, etc. */`
`switch (*lexptr)`	`switch (*lexptr)`
`{`	`{`
`case '\'':`	`case '\'':`
`case '\"':`	`case '\"':`
`/* First try to match a string literal, which is any`	`/* First try to match a string literal, which is any`
`sequence of characters enclosed in matching single or double`	`sequence of characters enclosed in matching single or double`
`quotes, except that a single character inside single quotes`	`quotes, except that a single character inside single quotes`
`is a character literal, so we have to catch that case also. */`	`is a character literal, so we have to catch that case also. */`
`token = match_string_literal ();`	`token = match_string_literal ();`
`if (token != 0)`	`if (token != 0)`
`{`	`{`
`return (token);`	`return (token);`
`}`	`}`
`if (*lexptr == '\'')`	`if (*lexptr == '\'')`
`{`	`{`
`token = match_character_literal ();`	`token = match_character_literal ();`
`if (token != 0)`	`if (token != 0)`
`{`	`{`
`return (token);`	`return (token);`
`}`	`}`
`}`	`}`
`break;`	`break;`
`case 'C':`	`case 'C':`
`case 'c':`	`case 'c':`
`token = match_character_literal ();`	`token = match_character_literal ();`
`if (token != 0)`	`if (token != 0)`
`{`	`{`
`return (token);`	`return (token);`
`}`	`}`
`break;`	`break;`
`case '$':`	`case '$':`
`yylval.sval.ptr = lexptr;`	`yylval.sval.ptr = lexptr;`
`do`	`do`
`{`	`{`
`lexptr++;`	`lexptr++;`
`}`	`}`
`while (isalnum (lexptr) \|\| lexptr == '_' \|\| *lexptr == '$');`	`while (isalnum (lexptr) \|\| lexptr == '_' \|\| *lexptr == '$');`
`yylval.sval.length = lexptr - yylval.sval.ptr;`	`yylval.sval.length = lexptr - yylval.sval.ptr;`
`write_dollar_variable (yylval.sval);`	`write_dollar_variable (yylval.sval);`
`return GDB_VARIABLE;`	`return GDB_VARIABLE;`
`break;`	`break;`
`}`	`}`
`/* See if it is a special token of length 2. */`	`/* See if it is a special token of length 2. */`
`for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)`	`for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)`
`{`	`{`
`if (STREQN (lexptr, tokentab2[i].operator, 2))`	`if (STREQN (lexptr, tokentab2[i].operator, 2))`
`{`	`{`
`lexptr += 2;`	`lexptr += 2;`
`return (tokentab2[i].token);`	`return (tokentab2[i].token);`
`}`	`}`
`}`	`}`
`/* Look for single character cases which which could be the first`	`/* Look for single character cases which which could be the first`
`character of some other multicharacter token, but aren't, or we`	`character of some other multicharacter token, but aren't, or we`
`would already have found it. */`	`would already have found it. */`
`switch (*lexptr)`	`switch (*lexptr)`
`{`	`{`
`case '-':`	`case '-':`
`case ':':`	`case ':':`
`case '/':`	`case '/':`
`case '<':`	`case '<':`
`case '>':`	`case '>':`
`return (*lexptr++);`	`return (*lexptr++);`
`}`	`}`
`/* Look for a float literal before looking for an integer literal, so`	`/* Look for a float literal before looking for an integer literal, so`
`we match as much of the input stream as possible. */`	`we match as much of the input stream as possible. */`
`token = match_float_literal ();`	`token = match_float_literal ();`
`if (token != 0)`	`if (token != 0)`
`{`	`{`
`return (token);`	`return (token);`
`}`	`}`
`token = match_bitstring_literal ();`	`token = match_bitstring_literal ();`
`if (token != 0)`	`if (token != 0)`
`{`	`{`
`return (token);`	`return (token);`
`}`	`}`
`token = match_integer_literal ();`	`token = match_integer_literal ();`
`if (token != 0)`	`if (token != 0)`
`{`	`{`
`return (token);`	`return (token);`
`}`	`}`

`/* Try to match a simple name string, and if a match is found, then`	`/* Try to match a simple name string, and if a match is found, then`
`further classify what sort of name it is and return an appropriate`	`further classify what sort of name it is and return an appropriate`
`token. Note that attempting to match a simple name string consumes`	`token. Note that attempting to match a simple name string consumes`
`the token from lexptr, so we can't back out if we later find that`	`the token from lexptr, so we can't back out if we later find that`
`we can't classify what sort of name it is. */`	`we can't classify what sort of name it is. */`

`inputname = match_simple_name_string ();`	`inputname = match_simple_name_string ();`

`if (inputname != NULL)`	`if (inputname != NULL)`
`{`	`{`
`char simplename = (char ) alloca (strlen (inputname) + 1);`	`char simplename = (char ) alloca (strlen (inputname) + 1);`

`char dptr = simplename, sptr = inputname;`	`char dptr = simplename, sptr = inputname;`
`for (; *sptr; sptr++)`	`for (; *sptr; sptr++)`
`dptr++ = isupper (sptr) ? tolower (sptr) : sptr;`	`dptr++ = isupper (sptr) ? tolower (sptr) : sptr;`
`*dptr = '\0';`	`*dptr = '\0';`

`/* See if it is a reserved identifier. */`	`/* See if it is a reserved identifier. */`
`for (i = 0; i < sizeof (idtokentab) / sizeof (idtokentab[0]); i++)`	`for (i = 0; i < sizeof (idtokentab) / sizeof (idtokentab[0]); i++)`
`{`	`{`
`if (STREQ (simplename, idtokentab[i].operator))`	`if (STREQ (simplename, idtokentab[i].operator))`
`{`	`{`
`return (idtokentab[i].token);`	`return (idtokentab[i].token);`
`}`	`}`
`}`	`}`

`/* Look for other special tokens. */`	`/* Look for other special tokens. */`
`if (STREQ (simplename, "true"))`	`if (STREQ (simplename, "true"))`
`{`	`{`
`yylval.ulval = 1;`	`yylval.ulval = 1;`
`return (BOOLEAN_LITERAL);`	`return (BOOLEAN_LITERAL);`
`}`	`}`
`if (STREQ (simplename, "false"))`	`if (STREQ (simplename, "false"))`
`{`	`{`
`yylval.ulval = 0;`	`yylval.ulval = 0;`
`return (BOOLEAN_LITERAL);`	`return (BOOLEAN_LITERAL);`
`}`	`}`

`sym = lookup_symbol (inputname, expression_context_block,`	`sym = lookup_symbol (inputname, expression_context_block,`
`VAR_NAMESPACE, (int *) NULL,`	`VAR_NAMESPACE, (int *) NULL,`
`(struct symtab **) NULL);`	`(struct symtab **) NULL);`
`if (sym == NULL && strcmp (inputname, simplename) != 0)`	`if (sym == NULL && strcmp (inputname, simplename) != 0)`
`{`	`{`
`sym = lookup_symbol (simplename, expression_context_block,`	`sym = lookup_symbol (simplename, expression_context_block,`
`VAR_NAMESPACE, (int *) NULL,`	`VAR_NAMESPACE, (int *) NULL,`
`(struct symtab **) NULL);`	`(struct symtab **) NULL);`
`}`	`}`
`if (sym != NULL)`	`if (sym != NULL)`
`{`	`{`
`yylval.ssym.stoken.ptr = NULL;`	`yylval.ssym.stoken.ptr = NULL;`
`yylval.ssym.stoken.length = 0;`	`yylval.ssym.stoken.length = 0;`
`yylval.ssym.sym = sym;`	`yylval.ssym.sym = sym;`
`yylval.ssym.is_a_field_of_this = 0; /* FIXME, C++'ism */`	`yylval.ssym.is_a_field_of_this = 0; /* FIXME, C++'ism */`
`switch (SYMBOL_CLASS (sym))`	`switch (SYMBOL_CLASS (sym))`
`{`	`{`
`case LOC_BLOCK:`	`case LOC_BLOCK:`
`/* Found a procedure name. */`	`/* Found a procedure name. */`
`return (GENERAL_PROCEDURE_NAME);`	`return (GENERAL_PROCEDURE_NAME);`
`case LOC_STATIC:`	`case LOC_STATIC:`
`/* Found a global or local static variable. */`	`/* Found a global or local static variable. */`
`return (LOCATION_NAME);`	`return (LOCATION_NAME);`
`case LOC_REGISTER:`	`case LOC_REGISTER:`
`case LOC_ARG:`	`case LOC_ARG:`
`case LOC_REF_ARG:`	`case LOC_REF_ARG:`
`case LOC_REGPARM:`	`case LOC_REGPARM:`
`case LOC_REGPARM_ADDR:`	`case LOC_REGPARM_ADDR:`
`case LOC_LOCAL:`	`case LOC_LOCAL:`
`case LOC_LOCAL_ARG:`	`case LOC_LOCAL_ARG:`
`case LOC_BASEREG:`	`case LOC_BASEREG:`
`case LOC_BASEREG_ARG:`	`case LOC_BASEREG_ARG:`
`if (innermost_block == NULL`	`if (innermost_block == NULL`
`\|\| contained_in (block_found, innermost_block))`	`\|\| contained_in (block_found, innermost_block))`
`{`	`{`
`innermost_block = block_found;`	`innermost_block = block_found;`
`}`	`}`
`return (LOCATION_NAME);`	`return (LOCATION_NAME);`
`break;`	`break;`
`case LOC_CONST:`	`case LOC_CONST:`
`case LOC_LABEL:`	`case LOC_LABEL:`
`return (LOCATION_NAME);`	`return (LOCATION_NAME);`
`break;`	`break;`
`case LOC_TYPEDEF:`	`case LOC_TYPEDEF:`
`yylval.tsym.type = SYMBOL_TYPE (sym);`	`yylval.tsym.type = SYMBOL_TYPE (sym);`
`return TYPENAME;`	`return TYPENAME;`
`case LOC_UNDEF:`	`case LOC_UNDEF:`
`case LOC_CONST_BYTES:`	`case LOC_CONST_BYTES:`
`case LOC_OPTIMIZED_OUT:`	`case LOC_OPTIMIZED_OUT:`
`error ("Symbol \"%s\" names no location.", inputname);`	`error ("Symbol \"%s\" names no location.", inputname);`
`break;`	`break;`
`default:`	`default:`
`internal_error ("unhandled SYMBOL_CLASS in ch_lex()");`	`internal_error ("unhandled SYMBOL_CLASS in ch_lex()");`
`break;`	`break;`
`}`	`}`
`}`	`}`
`else if (!have_full_symbols () && !have_partial_symbols ())`	`else if (!have_full_symbols () && !have_partial_symbols ())`
`{`	`{`
`error ("No symbol table is loaded. Use the \"file\" command.");`	`error ("No symbol table is loaded. Use the \"file\" command.");`
`}`	`}`
`else`	`else`
`{`	`{`
`error ("No symbol \"%s\" in current context.", inputname);`	`error ("No symbol \"%s\" in current context.", inputname);`
`}`	`}`
`}`	`}`

`/* Catch single character tokens which are not part of some`	`/* Catch single character tokens which are not part of some`
`longer token. */`	`longer token. */`

`switch (*lexptr)`	`switch (*lexptr)`
`{`	`{`
`case '.': /* Not float for example. */`	`case '.': /* Not float for example. */`
`lexptr++;`	`lexptr++;`
`while (isspace (*lexptr))`	`while (isspace (*lexptr))`
`lexptr++;`	`lexptr++;`
`inputname = match_simple_name_string ();`	`inputname = match_simple_name_string ();`
`if (!inputname)`	`if (!inputname)`
`return '.';`	`return '.';`
`return DOT_FIELD_NAME;`	`return DOT_FIELD_NAME;`
`}`	`}`

`return (ILLEGAL_TOKEN);`	`return (ILLEGAL_TOKEN);`
`}`	`}`

`static void`	`static void`
`write_lower_upper_value (opcode, type)`	`write_lower_upper_value (opcode, type)`
`enum exp_opcode opcode; /* Either UNOP_LOWER or UNOP_UPPER */`	`enum exp_opcode opcode; /* Either UNOP_LOWER or UNOP_UPPER */`
`struct type *type;`	`struct type *type;`
`{`	`{`
`if (type == NULL)`	`if (type == NULL)`
`write_exp_elt_opcode (opcode);`	`write_exp_elt_opcode (opcode);`
`else`	`else`
`{`	`{`
`struct type *result_type;`	`struct type *result_type;`
`LONGEST val = type_lower_upper (opcode, type, &result_type);`	`LONGEST val = type_lower_upper (opcode, type, &result_type);`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`write_exp_elt_type (result_type);`	`write_exp_elt_type (result_type);`
`write_exp_elt_longcst (val);`	`write_exp_elt_longcst (val);`
`write_exp_elt_opcode (OP_LONG);`	`write_exp_elt_opcode (OP_LONG);`
`}`	`}`
`}`	`}`

`void`	`void`
`chill_error (msg)`	`chill_error (msg)`
`char *msg;`	`char *msg;`
`{`	`{`
`/* Never used. */`	`/* Never used. */`
`}`	`}`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [ch-exp.c] - Diff between revs 105 and 1765