/*
* Automatically generated from the files:
* /mnt/gmirror/ports/lang/TenDRA/work/tendra/src/producers/c/syntax/syntax.sid
* and
* /mnt/gmirror/ports/lang/TenDRA/work/tendra/src/producers/c/syntax/syntax.act
* by:
* /mnt/gmirror/ports/lang/TenDRA/work/tendra/obj/utilities/sid/sid
*/
/* BEGINNING OF HEADER */
#define __SID_SPLIT
/*
* Crown Copyright (c) 1997, 1998
*
* This TenDRA(r) Computer Program is subject to Copyright
* owned by the United Kingdom Secretary of State for Defence
* acting through the Defence Evaluation and Research Agency
* (DERA). It is made available to Recipients with a
* royalty-free licence for its use, reproduction, transfer
* to other parties and amendment for any purpose not excluding
* product development provided that any such use et cetera
* shall be deemed to be acceptance of the following conditions:-
*
* (1) Its Recipients shall ensure that this Notice is
* reproduced upon any copies or amended versions of it;
*
* (2) Any amended version of it shall be clearly marked to
* show both the nature of and the organisation responsible
* for the relevant amendment or amendments;
*
* (3) Its onward transfer from a recipient to another
* party shall be deemed to be that party's acceptance of
* these conditions;
*
* (4) DERA gives no warranty or assurance as to its
* quality or suitability for any purpose and DERA accepts
* no liability whatsoever in relation to any use to which
* it may be put.
*/
#include "config.h"
#include "producer.h"
#include "c_types.h"
#include "exp_ops.h"
#include "hashid_ops.h"
#include "id_ops.h"
#include "type_ops.h"
#include "error.h"
#include "catalog.h"
#include "option.h"
#include "access.h"
#include "allocate.h"
#include "assign.h"
#include "basetype.h"
#include "cast.h"
#include "chktype.h"
#include "class.h"
#include "constant.h"
#include "construct.h"
#include "convert.h"
#include "declare.h"
#include "derive.h"
#include "dump.h"
#include "exception.h"
#include "expression.h"
#include "function.h"
#include "hash.h"
#include "identifier.h"
#include "initialise.h"
#include "inttype.h"
#include "label.h"
#include "lex.h"
#include "literal.h"
#include "member.h"
#include "namespace.h"
#include "parse.h"
#include "pragma.h"
#include "predict.h"
#include "preproc.h"
#include "redeclare.h"
#include "rewrite.h"
#include "statement.h"
#include "symbols.h"
#include "template.h"
#include "tokdef.h"
#include "token.h"
#include "typeid.h"
#include "variable.h"
/*
* COMPOUND TYPE ALIASES
*
* These are the aliases for the compound types used in the parser.
*/
typedef LIST (EXP) SID_LIST_EXP;
/*
* FUNCTION DECLARATIONS
*
* The function declarations are included at this point so that the
* type definitions are in scope.
*/
#include "syntax.h"
/*
* COMPILATION MODE
*
* The output of sid is automatically generated. Hence it is not
* necessarily appropriate to apply the same level of checking to this
* as to the rest of the program. These pragmas describe the relaxations
* allowed for the sid output.
*/
#if FS_TENDRA
#pragma TenDRA begin
#pragma TenDRA const conditional allow
#pragma TenDRA unreachable code allow
#pragma TenDRA variable analysis off
#endif
void
ZR572 (EXP *ZO892, EXP *ZO893, int *ZO894)
{
EXP ZI892;
EXP ZI893;
int ZI894;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI471;
EXP ZI424;
int ZI541;
EXP ZI420;
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_hash_Hif:
{
ZI471 = crt_token->pp_data.exp;
}
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
EXP c = crt_hash_cond;
crt_hash_cond = make_if_cond ((ZI471), c);
(ZI424) = c;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
ZR556 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_prev = (ZI541);
}
{
(ZI408) = begin_hash_if_stmt ((ZI471), (ZI420));
}
ZR895 (ZI408, ZI424, ZI541, &ZI892, &ZI893, &ZI894);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO892 = ZI892;
*ZO893 = ZI893;
*ZO894 = ZI894;
}
void
ZR639 (CV_SPEC *ZO637)
{
CV_SPEC ZI637;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
CV_SPEC ZI420;
ZR638 (&ZI420);
{
switch (CURRENT_TERMINAL) {
case lex_const: case lex_volatile: case lex_restrict:
{
CV_SPEC ZI452;
ZR639 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CV_SPEC c = ((ZI420) & (ZI452));
if (c) report (crt_loc, ERR_dcl_type_cv_dup (c));
(ZI637) = ((ZI420) | (ZI452));
}
}
break;
default:
{
ZI637 = ZI420;
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
}
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO637 = ZI637;
}
void
ZR1091 (IDENTIFIER *ZI403, EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_and_H1: case lex_and_Heq_H1: case lex_arrow:
case lex_assign: case lex_comma: case lex_div:
case lex_div_Heq: case lex_dot: case lex_eq:
case lex_greater: case lex_greater_Heq: case lex_less:
case lex_less_Heq: case lex_logical_Hand_H1: case lex_logical_Hor_H1:
case lex_lshift: case lex_lshift_Heq: case lex_minus:
case lex_minus_Heq: case lex_minus_Hminus: case lex_not_Heq_H1:
case lex_open_Hround: case lex_open_Hsquare_H1: case lex_or_H1:
case lex_or_Heq_H1: case lex_plus: case lex_plus_Heq:
case lex_plus_Hplus: case lex_question: case lex_rem:
case lex_rem_Heq: case lex_rshift: case lex_rshift_Heq:
case lex_semicolon: case lex_star: case lex_star_Heq:
case lex_xor_H1: case lex_xor_Heq_H1: case lex_max:
case lex_min:
{
EXP ZI1022;
EXP ZI1023;
EXP ZI1035;
EXP ZI420;
int ZI541;
{
(ZI1022) = make_id_exp ((*ZI403));
}
ZR943 (ZI1022, &ZI1023);
ZR1015 (&ZI1023, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_colon:
{
EXP ZI420;
EXP ZI452;
{
if (unreached_code) unreached_fall = 0;
}
{
(ZI420) = begin_label_stmt ((*ZI403), lex_identifier);
}
ADVANCE_LEXER;
ZR532 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = end_label_stmt ((ZI420), (ZI452));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR557 (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI471;
int ZI552;
EXP ZI452;
EXP ZI541;
EXP ZI420;
{
(ZI471) = begin_compound_stmt (1);
}
{
if (option (OPT_func_id) == OPTION_ALLOW) {
declare_func_id ();
}
}
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
COPY_int (exp_sequence_block ((ZI471)), 2);
(ZI552) = 1;
}
ZR553 (ZI471, ZI552, &ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = fall_return_stmt ();
}
{
(ZI420) = add_compound_stmt ((ZI452), (ZI541));
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI408) = end_compound_stmt ((ZI420));
}
{
RESCAN_LEXER;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR1092 (IDENTIFIER *ZI403, EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
default:
{
EXP ZI420;
{
(ZI420) = make_id_exp ((*ZI403));
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
}
break;
case lex_colon:
{
EXP ZI420;
EXP ZI452;
{
if (unreached_code) unreached_fall = 0;
}
{
(ZI420) = begin_label_stmt ((*ZI403), lex_identifier);
}
ADVANCE_LEXER;
ZR532 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = end_label_stmt ((ZI420), (ZI452));
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR642 (CV_SPEC *ZO637)
{
CV_SPEC ZI637;
switch (CURRENT_TERMINAL) {
case lex_const: case lex_volatile: case lex_restrict:
{
ZR639 (&ZI637);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI637) = cv_none;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO637 = ZI637;
}
void
ZR533 (void)
{
switch (CURRENT_TERMINAL) {
case lex_fall:
{
ADVANCE_LEXER;
ZR1109 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
break;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR638 (CV_SPEC *ZO637)
{
CV_SPEC ZI637;
switch (CURRENT_TERMINAL) {
case lex_const:
{
ADVANCE_LEXER;
{
(ZI637) = cv_const;
}
}
break;
case lex_restrict:
{
ADVANCE_LEXER;
{
(ZI637) = cv_restrict;
}
}
break;
case lex_volatile:
{
ADVANCE_LEXER;
{
(ZI637) = cv_volatile;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO637 = ZI637;
}
void
ZR473 (void)
{
switch (CURRENT_TERMINAL) {
case lex_abs:
{
ADVANCE_LEXER;
}
break;
case lex_minus:
{
ADVANCE_LEXER;
}
break;
case lex_plus:
{
ADVANCE_LEXER;
}
break;
case lex_compl_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_compl_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case 358:
return;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR834 (TYPE ZI424, BASE_TYPE ZI427)
{
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
{
TYPE ZI1048;
IDENTIFIER ZI1049;
TYPE ZI1045;
IDENTIFIER ZI403;
TYPE ZI399;
ADVANCE_LEXER;
ZR752 (&ZI1048, &ZI1049);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (IS_NULL_type ((ZI1048))) {
report (crt_loc, ERR_dcl_meaning_paren ());
}
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR878 (ZI1048, ZI1049, &ZI1045, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI1045)) ? (ZI424): inject_pre_type ((ZI1045), (ZI424), 1));
}
{
IDENTIFIER id = make_member_decl (dspec_none, (ZI399), (ZI403), 0);
if (do_dump) dump_declare (id, &decl_loc, 0);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
}
break;
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
{
IDENTIFIER ZI1052;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI1052 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI1052 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI1052 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
ZR1053 (&ZI424, &ZI427, &ZI1052);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_star:
{
TYPE ZI1046;
TYPE ZI1047;
IDENTIFIER ZI403;
TYPE ZI1045;
TYPE ZI399;
ZR741 (&ZI1046);
ZR752 (&ZI1047, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1045) = (IS_NULL_type ((ZI1047)) ? (ZI1046): inject_pre_type ((ZI1047), (ZI1046), 0));
}
{
(ZI399) = (IS_NULL_type ((ZI1045)) ? (ZI424): inject_pre_type ((ZI1045), (ZI424), 1));
}
{
IDENTIFIER id = make_member_decl (dspec_none, (ZI399), (ZI403), 0);
if (do_dump) dump_declare (id, &decl_loc, 0);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
}
break;
case lex_colon:
{
IDENTIFIER ZI403;
EXP ZI471;
TYPE ZI399;
{
HASHID nm = lookup_anon ();
(ZI403) = DEREF_id (hashid_id (nm));
}
{
IDENTIFIER pid = underlying_id ((ZI403));
DEREF_loc (id_loc (pid), decl_loc);
}
ADVANCE_LEXER;
ZR522 (&ZI471);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* Check for anonymous bitfields */
HASHID nm = DEREF_hashid (id_name ((ZI403)));
int z = IS_hashid_anon (nm);
(ZI399) = make_bitfield_type ((ZI424), (ZI427), (ZI471), z);
}
{
IDENTIFIER id = make_member_decl (dspec_none, (ZI399), (ZI403), 0);
if (do_dump) dump_declare (id, &decl_loc, 0);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR973 (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
TYPE ZI399;
int ZI476;
EXP ZI420;
{
/* Resolve type-ids from expressions */
(ZI0) = predict_typeid (0);
}
if (!ZI0)
goto ZL2;
ZR448 (&ZI399, &ZI476);
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* n is the number of type definitions in t */
(ZI408) = make_cast_exp ((ZI399), (ZI420), (ZI476));
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_char_Hexp: case lex_wchar_Hexp:
case lex_string_Hexp: case lex_wstring_Hexp: case lex_integer_Hexp:
case lex_floating_Hexp: case lex_complex_Hexp: case lex_and_H1:
case lex_compl_H1: case lex_minus: case lex_minus_Hminus:
case lex_not_H1: case lex_open_Hround: case lex_plus:
case lex_plus_Hplus: case lex_star: case lex_abs:
case lex_sizeof: case lex_alignof: case lex_discard:
case lex_ellipsis_Hexp: case lex_set: case lex_unused:
case lex_inset_Hstart:
{
EXP ZI420;
EXP ZI972;
{
IGNORE incr_value (OPT_VAL_paren_depth);
}
ZR418 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI972) = make_paren_exp ((ZI420));
decr_value (OPT_VAL_paren_depth);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR943 (ZI972, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR798 (IDENTIFIER ZI552, EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_char_Hexp: case lex_wchar_Hexp:
case lex_string_Hexp: case lex_wstring_Hexp: case lex_integer_Hexp:
case lex_floating_Hexp: case lex_complex_Hexp: case lex_and_H1:
case lex_compl_H1: case lex_minus: case lex_minus_Hminus:
case lex_not_H1: case lex_open_Hround: case lex_plus:
case lex_plus_Hplus: case lex_star: case lex_abs:
case lex_sizeof: case lex_alignof: case lex_discard:
case lex_ellipsis_Hexp:
{
ZR520 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hbrace_H1:
{
SID_LIST_EXP ZI424;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR1082 (&ZI552, &ZI424);
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
/* The expression type is a dummy */
MAKE_exp_aggregate (type_void, (ZI424), NULL_list (OFFSET), (ZI408));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR483 (EXP *ZO934)
{
EXP ZI934;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR480 (&ZI408);
ZR935 (ZI408, &ZI934);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO934 = ZI934;
}
void
ZR761 (TYPE *ZO876, IDENTIFIER *ZO877)
{
TYPE ZI876;
IDENTIFIER ZI877;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
{
TYPE ZI399;
IDENTIFIER ZI403;
ADVANCE_LEXER;
ZR752 (&ZI399, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (IS_NULL_type ((ZI399))) {
report (crt_loc, ERR_dcl_meaning_paren ());
}
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR878 (ZI399, ZI403, &ZI876, &ZI877);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
{
IDENTIFIER ZI403;
TYPE ZI399;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
(ZI399) = NULL_type;
}
{
IDENTIFIER pid = underlying_id ((ZI403));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR878 (ZI399, ZI403, &ZI876, &ZI877);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO876 = ZI876;
*ZO877 = ZI877;
}
void
ZR585 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_if:
{
unsigned ZI586;
int ZI541;
EXP ZI471;
EXP ZI420;
EXP ZI587;
EXP ZI452;
EXP ZI552;
EXP ZI590;
ADVANCE_LEXER;
{
(ZI586) = crt_condition;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
ZR398 ();
ZR418 (&ZI471);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI420) = begin_if_stmt ((ZI471));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI587) = begin_compound_stmt (1);
}
ZR561 (ZI587, &ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_prev = (ZI541);
}
{
(ZI552) = cont_if_stmt ((ZI420), (ZI452));
}
{
{
EXP ZI589;
switch (CURRENT_TERMINAL) {
case lex_else:
break;
default:
goto ZL3;
}
ADVANCE_LEXER;
{
check_empty_stmt (lex_else);
}
{
(ZI589) = begin_compound_stmt (1);
}
ZR561 (ZI589, &ZI590);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL3;
}
}
goto ZL2;
ZL3:;
{
{
report (crt_loc, ERR_stmt_if_no_else ());
(ZI590) = NULL_exp;
}
}
ZL2:;
}
{
unreached_prev = (ZI541);
}
{
(ZI408) = end_if_stmt ((ZI552), (ZI590));
}
{
crt_condition = (ZI586);
}
{
unreached_fall = 1;
}
}
break;
case lex_switch:
{
int ZI541;
EXP ZI471;
EXP ZI420;
int ZI592;
EXP ZI587;
EXP ZI452;
ADVANCE_LEXER;
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR418 (&ZI471);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI420) = begin_switch_stmt ((ZI471));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
switch (CURRENT_TERMINAL) {
case lex_exhaustive:
{
ADVANCE_LEXER;
{
(ZI592) = 1;
}
}
break;
default:
{
{
(ZI592) = 0;
}
}
break;
}
}
{
(ZI587) = begin_compound_stmt (1);
}
ZR561 (ZI587, &ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_prev = (ZI541);
}
{
(ZI408) = end_switch_stmt ((ZI420), (ZI452), (ZI592));
}
{
unreached_fall = 1;
}
}
break;
case lex_hash_Hif:
{
ZR574 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_fall = 1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR1104 (EXP *ZI1103, EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_inset_Hend:
{
SID_LIST_EXP ZI427;
SID_LIST_EXP ZI424;
EXP ZI420;
int ZI541;
ADVANCE_LEXER;
ZR519 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((*ZI1103), (ZI427), (ZI424));
}
{
(ZI420) = make_comma_exp ((ZI424));
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_semicolon:
{
int ZI541;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_inset_Hend:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((*ZI1103));
}
{
unreached_fall = 1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR418 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_char_Hexp: case lex_wchar_Hexp:
case lex_string_Hexp: case lex_wstring_Hexp: case lex_integer_Hexp:
case lex_floating_Hexp: case lex_complex_Hexp: case lex_and_H1:
case lex_compl_H1: case lex_minus: case lex_minus_Hminus:
case lex_not_H1: case lex_open_Hround: case lex_plus:
case lex_plus_Hplus: case lex_star: case lex_abs:
case lex_sizeof: case lex_alignof: case lex_discard:
case lex_ellipsis_Hexp:
{
EXP ZI1035;
ZR423 (&ZI1035);
ZR1037 (&ZI1035, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_set: case lex_unused:
{
EXP ZI420;
SID_LIST_EXP ZI427;
SID_LIST_EXP ZI424;
ZR514 (&ZI420);
ZR519 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((ZI420), (ZI427), (ZI424));
}
{
(ZI408) = make_comma_exp ((ZI424));
}
}
break;
case lex_inset_Hstart:
{
EXP ZI420;
SID_LIST_EXP ZI427;
SID_LIST_EXP ZI424;
ZR515 (&ZI420);
ZR519 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((ZI420), (ZI427), (ZI424));
}
{
(ZI408) = make_comma_exp ((ZI424));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR553 (EXP ZI471, int ZI552, EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
ZL2_553:;
{
EXP ZI420;
EXP ZI452;
{
/* Resolve declaration-statements from expression-statements */
int b = predict_decl ();
if (b) {
if (!(ZI552)) report (crt_loc, ERR_stmt_dcl_start ());
in_declaration++;
}
(ZI0) = b;
}
if (!ZI0)
goto ZL3;
ZR564 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
in_declaration--;
(ZI420) = NULL_exp;
}
{
unreached_fall = 1;
}
{
(ZI452) = add_compound_stmt ((ZI471), (ZI420));
}
ZI471 = ZI452;
goto ZL2_553;
}
/*UNREACHED*/
ZL3:;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
case lex_char_Hexp: case lex_wchar_Hexp: case lex_string_Hexp:
case lex_wstring_Hexp: case lex_integer_Hexp: case lex_floating_Hexp:
case lex_complex_Hexp: case lex_complex_Hstmt: case lex_hash_Hif:
case lex_and_H1: case lex_compl_H1: case lex_minus:
case lex_minus_Hminus: case lex_not_H1: case lex_open_Hbrace_H1:
case lex_open_Hround: case lex_plus: case lex_plus_Hplus:
case lex_semicolon: case lex_star: case lex_abs:
case lex_break: case lex_case: case lex_continue:
case lex_default: case lex_do: case lex_for:
case lex_goto: case lex_if: case lex_return:
case lex_sizeof: case lex_switch: case lex_while:
case lex_asm: case lex_alignof: case lex_discard:
case lex_ellipsis_Hexp: case lex_fall: case lex_reachable:
case lex_set: case lex_unreachable: case lex_unused:
case lex_inset_Hstart:
{
EXP ZI420;
EXP ZI452;
int ZI554;
ZR532 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI452) = add_compound_stmt ((ZI471), (ZI420));
}
{
(ZI554) = 0;
}
ZI471 = ZI452;
ZI552 = ZI554;
goto ZL2_553;
}
/*UNREACHED*/
default:
{
ZI408 = ZI471;
}
break;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR560 (EXP ZI471, EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
{
int ZI552;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
COPY_int (exp_sequence_block ((ZI471)), 2);
(ZI552) = 1;
}
ZR553 (ZI471, ZI552, &ZI408);
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
case lex_char_Hexp: case lex_wchar_Hexp: case lex_string_Hexp:
case lex_wstring_Hexp: case lex_integer_Hexp: case lex_floating_Hexp:
case lex_complex_Hexp: case lex_complex_Hstmt: case lex_hash_Hif:
case lex_and_H1: case lex_compl_H1: case lex_minus:
case lex_minus_Hminus: case lex_not_H1: case lex_open_Hround:
case lex_plus: case lex_plus_Hplus: case lex_semicolon:
case lex_star: case lex_abs: case lex_break:
case lex_case: case lex_continue: case lex_default:
case lex_do: case lex_for: case lex_goto:
case lex_if: case lex_return: case lex_sizeof:
case lex_switch: case lex_while: case lex_asm:
case lex_alignof: case lex_discard: case lex_ellipsis_Hexp:
case lex_fall: case lex_reachable: case lex_set:
case lex_unreachable: case lex_unused: case lex_inset_Hstart:
{
EXP ZI420;
ZR559 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = add_compound_stmt ((ZI471), (ZI420));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR718 (DECL_SPEC *ZO611)
{
DECL_SPEC ZI611;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
switch (CURRENT_TERMINAL) {
case lex_inline:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI611) = dspec_inline;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO611 = ZI611;
}
void
ZR532 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
{
ZR556 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
case lex_char_Hexp: case lex_wchar_Hexp: case lex_string_Hexp:
case lex_wstring_Hexp: case lex_integer_Hexp: case lex_floating_Hexp:
case lex_complex_Hexp: case lex_complex_Hstmt: case lex_hash_Hif:
case lex_and_H1: case lex_compl_H1: case lex_minus:
case lex_minus_Hminus: case lex_not_H1: case lex_open_Hround:
case lex_plus: case lex_plus_Hplus: case lex_semicolon:
case lex_star: case lex_abs: case lex_break:
case lex_case: case lex_continue: case lex_default:
case lex_do: case lex_for: case lex_goto:
case lex_if: case lex_return: case lex_sizeof:
case lex_switch: case lex_while: case lex_asm:
case lex_alignof: case lex_discard: case lex_ellipsis_Hexp:
case lex_fall: case lex_reachable: case lex_set:
case lex_unreachable: case lex_unused: case lex_inset_Hstart:
{
ZR559 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR1109 (void)
{
switch (CURRENT_TERMINAL) {
case lex_semicolon:
{
ADVANCE_LEXER;
{
unreached_fall = 0;
}
}
break;
default:
{
{
unreached_fall = 0;
}
}
break;
case 358:
return;
}
}
void
ZR769 (TYPE *ZO861)
{
TYPE ZI861;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
{
ADVANCE_LEXER;
ZR1070 (&ZI861);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_weak:
{
IDENTIFIER ZI403;
int ZI757;
TYPE ZI399;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI403) = NULL_id;
}
{
func_type_defn (0);
begin_param ((ZI403));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR760 (&ZI757);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = make_func_type (NULL_type, ((ZI757) | FUNC_WEAK), cv_c, empty_type_set);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
ZR862 (ZI399, &ZI861);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hsquare_H1:
{
EXP ZI408;
TYPE ZI399;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR759 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
NAT n = make_array_dim ((ZI408));
MAKE_type_array (cv_none, NULL_type, n, (ZI399));
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR862 (ZI399, &ZI861);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO861 = ZI861;
}
void
ZR608 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_do:
{
unsigned ZI586;
int ZI541;
EXP ZI420;
EXP ZI587;
EXP ZI452;
EXP ZI609;
EXP ZI471;
ADVANCE_LEXER;
{
(ZI586) = crt_condition;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI420) = begin_do_stmt ();
}
{
(ZI587) = begin_compound_stmt (1);
}
ZR561 (ZI587, &ZI452);
switch (CURRENT_TERMINAL) {
case lex_while:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR418 (&ZI609);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI471) = bind_temporary ((ZI609));
}
{
unreached_prev = (ZI541);
}
{
(ZI408) = end_do_stmt ((ZI420), (ZI452), (ZI471));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
crt_condition = (ZI586);
}
{
unreached_fall = 1;
}
ZR400 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_for:
{
unsigned ZI586;
int ZI541;
EXP ZI590;
EXP ZI420;
EXP ZI610;
EXP ZI471;
EXP ZI611;
EXP ZI452;
EXP ZI612;
EXP ZI552;
ADVANCE_LEXER;
{
(ZI586) = crt_condition;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
in_for_decl++;
(ZI590) = begin_for_stmt ();
}
ZR604 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI610) = init_for_stmt ((ZI590), &(ZI420));
in_for_decl--;
}
ZR605 (&ZI471);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI611) = begin_compound_stmt (1);
}
ZR607 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI612) = cond_for_stmt ((ZI610), (ZI471), (ZI452));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
mark_compound_stmt ((ZI611));
}
ZR561 (ZI611, &ZI552);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_prev = (ZI541);
}
{
(ZI408) = end_for_stmt ((ZI612), (ZI552));
}
{
crt_condition = (ZI586);
}
{
unreached_fall = 1;
}
{
RESCAN_LEXER;
}
}
break;
case lex_while:
{
unsigned ZI586;
int ZI541;
EXP ZI609;
EXP ZI471;
EXP ZI420;
EXP ZI587;
EXP ZI452;
ADVANCE_LEXER;
{
(ZI586) = crt_condition;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR418 (&ZI609);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI471) = bind_temporary ((ZI609));
}
{
(ZI420) = begin_while_stmt ((ZI471));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI587) = begin_compound_stmt (1);
}
ZR561 (ZI587, &ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_prev = (ZI541);
}
{
(ZI408) = end_while_stmt ((ZI420), (ZI452));
}
{
crt_condition = (ZI586);
}
{
unreached_fall = 1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR510 (void)
{
switch (CURRENT_TERMINAL) {
case lex_div_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_lshift_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_minus_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_plus_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_rem_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_rshift_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_star_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_and_Heq_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_and_Heq_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_or_Heq_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_or_Heq_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_xor_Heq_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_xor_Heq_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case 358:
return;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR540 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_inset_Hstart:
{
ADVANCE_LEXER;
ZR1088 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_semicolon:
{
ADVANCE_LEXER;
{
(ZI408) = NULL_exp;
}
}
break;
case lex_identifier: case lex_char_Hexp: case lex_wchar_Hexp:
case lex_string_Hexp: case lex_wstring_Hexp: case lex_integer_Hexp:
case lex_floating_Hexp: case lex_complex_Hexp: case lex_and_H1:
case lex_compl_H1: case lex_minus: case lex_minus_Hminus:
case lex_not_H1: case lex_open_Hround: case lex_plus:
case lex_plus_Hplus: case lex_star: case lex_abs:
case lex_sizeof: case lex_alignof: case lex_discard:
case lex_ellipsis_Hexp:
{
EXP ZI1035;
EXP ZI420;
int ZI541;
ZR423 (&ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_set: case lex_unused:
{
EXP ZI1083;
EXP ZI420;
int ZI541;
ZR514 (&ZI1083);
ZR1085 (&ZI1083, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR844 (OFFSET ZI452, TYPE ZI573, OFFSET *ZO420, TYPE *ZO399)
{
OFFSET ZI420;
TYPE ZI399;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
NAMESPACE ZI430;
IDENTIFIER ZI403;
{
(ZI430) = offset_nspace ((ZI573));
}
{
RESCAN_LEXER;
}
ZR431 (ZI430, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
OFFSET off = offset_member ((ZI573), (ZI403), &(ZI399), (ZI430), 1);
(ZI420) = offset_add ((ZI452), off);
}
{
RESCAN_LEXER;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO420 = ZI420;
*ZO399 = ZI399;
}
void
ZR734 (BASE_TYPE *ZI696, TYPE *ZI697, CV_SPEC *ZI698, DECL_SPEC *ZI726, BASE_TYPE *ZO666, TYPE *ZO399, CV_SPEC *ZO637, DECL_SPEC *ZO611)
{
BASE_TYPE ZI666;
TYPE ZI399;
CV_SPEC ZI637;
DECL_SPEC ZI611;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI1105;
TYPE ZI1106;
CV_SPEC ZI1107;
DECL_SPEC ZI1108;
BASE_TYPE ZI700;
TYPE ZI701;
CV_SPEC ZI702;
DECL_SPEC ZI728;
{
/* Resolve declaration-specifiers from other declarators */
(ZI0) = predict_dspec (0);
}
if (!ZI0)
goto ZL2;
ZR723 (&ZI1105, &ZI1106, &ZI1107, &ZI1108);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* A type-name can be a declarator-id */
if (have_type_specifier && crt_lex_token == lex_type_Hname) {
crt_lex_token = lex_identifier;
}
}
ZR734 (&ZI1105, &ZI1106, &ZI1107, &ZI1108, &ZI700, &ZI701, &ZI702, &ZI728);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if ((*ZI696) & (ZI700)) {
(ZI666) = join_pre_types ((*ZI696), (ZI700));
} else {
(ZI666) = ((*ZI696) | (ZI700));
}
}
{
/* Join two partial types */
if (IS_NULL_type ((*ZI697))) {
(ZI399) = (ZI701);
} else if (IS_NULL_type ((ZI701))) {
(ZI399) = (*ZI697);
} else {
report (crt_loc, ERR_dcl_type_simple_many ((*ZI697), (ZI701)));
(ZI399) = (ZI701);
}
}
{
CV_SPEC c = ((*ZI698) & (ZI702));
if (c) report (crt_loc, ERR_dcl_type_cv_dup (c));
(ZI637) = ((*ZI698) | (ZI702));
}
{
/* Combine two declaration specifiers */
DECL_SPEC d = (((*ZI726) & (ZI728)) & dspec_duplicate);
/* Duplicate inline is allowed */
if (d & ~dspec_inline) report (crt_loc, ERR_dcl_spec_dup (d));
(ZI611) = ((*ZI726) | (ZI728));
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
default:
{
ZI666 = *ZI696;
ZI399 = *ZI697;
ZI637 = *ZI698;
ZI611 = *ZI726;
}
break;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO666 = ZI666;
*ZO399 = ZI399;
*ZO637 = ZI637;
*ZO611 = ZI611;
}
void
ZR816 (void)
{
switch (CURRENT_TERMINAL) {
case lex_hash_Hpragma:
{
ADVANCE_LEXER;
}
break;
case lex_hash_Hif:
{
EXP ZI424;
ZR815 (&ZI424);
{
switch (CURRENT_TERMINAL) {
case lex_hash_Helse:
{
ADVANCE_LEXER;
{
crt_hash_cond = make_else_cond (crt_hash_cond);
}
{
target_decl (lex_else, NULL_exp);
}
ZR814 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
break;
}
}
{
crt_hash_cond = (ZI424);
}
switch (CURRENT_TERMINAL) {
case lex_hash_Hendif:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
target_decl (lex_endif, NULL_exp);
}
}
break;
case 358:
return;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR862 (TYPE ZI860, TYPE *ZO861)
{
TYPE ZI861;
ZL2_862:;
switch (CURRENT_TERMINAL) {
case lex_open_Hround: case lex_open_Hsquare_H1: case lex_weak:
{
TYPE ZI427;
TYPE ZI399;
ZR764 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI860)) ? (ZI427): inject_pre_type ((ZI860), (ZI427), 0));
}
ZI860 = ZI399;
goto ZL2_862;
}
/*UNREACHED*/
default:
{
ZI861 = ZI860;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO861 = ZI861;
}
void
ZR993 (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
TYPE ZI399;
int ZI476;
EXP ZI420;
EXP ZI971;
EXP ZI970;
EXP ZI969;
EXP ZI968;
EXP ZI967;
EXP ZI966;
EXP ZI965;
EXP ZI964;
EXP ZI963;
EXP ZI962;
EXP ZI961;
EXP ZI958;
{
/* Resolve type-ids from expressions */
(ZI0) = predict_typeid (0);
}
if (!ZI0)
goto ZL2;
ZR448 (&ZI399, &ZI476);
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* n is the number of type definitions in t */
(ZI971) = make_cast_exp ((ZI399), (ZI420), (ZI476));
}
ZR939 (ZI971, &ZI970);
ZR935 (ZI970, &ZI969);
ZR931 (ZI969, &ZI968);
ZR927 (ZI968, &ZI967);
ZR923 (ZI967, &ZI966);
ZR919 (ZI966, &ZI965);
ZR915 (ZI965, &ZI964);
ZR911 (ZI964, &ZI963);
ZR907 (ZI963, &ZI962);
ZR903 (ZI962, &ZI961);
ZR899 (ZI961, &ZI958);
ZR960 (&ZI958, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_char_Hexp: case lex_wchar_Hexp:
case lex_string_Hexp: case lex_wstring_Hexp: case lex_integer_Hexp:
case lex_floating_Hexp: case lex_complex_Hexp: case lex_and_H1:
case lex_compl_H1: case lex_minus: case lex_minus_Hminus:
case lex_not_H1: case lex_open_Hround: case lex_plus:
case lex_plus_Hplus: case lex_star: case lex_abs:
case lex_sizeof: case lex_alignof: case lex_discard:
case lex_ellipsis_Hexp: case lex_set: case lex_unused:
case lex_inset_Hstart:
{
EXP ZI1031;
EXP ZI1032;
EXP ZI1033;
{
IGNORE incr_value (OPT_VAL_paren_depth);
}
ZR418 (&ZI1031);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1032) = make_paren_exp ((ZI1031));
decr_value (OPT_VAL_paren_depth);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR943 (ZI1032, &ZI1033);
ZR1015 (&ZI1033, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
parse_mem_type (TYPE *ZO399)
{
TYPE ZI399;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI666;
TYPE ZI424;
CV_SPEC ZI637;
TYPE ZI427;
ZR695 (&ZI666, &ZI424, &ZI637);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI427) = complete_pre_type ((ZI666), (ZI424), (ZI637), 1);
have_type_specifier = 0;
}
{
switch (CURRENT_TERMINAL) {
case lex_rem:
{
EXP ZI471;
ADVANCE_LEXER;
ZR522 (&ZI471);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = make_bitfield_type ((ZI427), (ZI666), (ZI471), 0);
}
}
break;
default:
{
ZR770 (ZI427, &ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
}
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
}
void
ZR870 (TYPE ZI866, IDENTIFIER ZI867, TYPE *ZO868, IDENTIFIER *ZO869)
{
TYPE ZI868;
IDENTIFIER ZI869;
ZL2_870:;
switch (CURRENT_TERMINAL) {
case lex_open_Hround: case lex_open_Hsquare_H1: case lex_weak:
{
IDENTIFIER ZI403;
TYPE ZI427;
TYPE ZI399;
ZI403 = ZI867;
ZR764 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI866)) ? (ZI427): inject_pre_type ((ZI866), (ZI427), 0));
}
ZI866 = ZI399;
ZI867 = ZI403;
goto ZL2_870;
}
/*UNREACHED*/
default:
{
ZI868 = ZI866;
ZI869 = ZI867;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO868 = ZI868;
*ZO869 = ZI869;
}
void
parse_operator (IDENTIFIER *ZO403)
{
IDENTIFIER ZI403;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI403) = NULL_id;
}
}
*ZO403 = ZI403;
}
void
ZR501 (EXP *ZO906)
{
EXP ZI906;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR499 (&ZI408);
ZR907 (ZI408, &ZI906);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO906 = ZI906;
}
void
ZR619 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_case:
{
EXP ZI471;
ADVANCE_LEXER;
ZR522 (&ZI471);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
report (crt_loc, ERR_stmt_goto_case (lex_case));
(ZI408) = begin_case_stmt ((ZI471), 1);
}
}
break;
case lex_default:
{
ADVANCE_LEXER;
{
report (crt_loc, ERR_stmt_goto_case (lex_default));
(ZI408) = begin_default_stmt (1);
}
}
break;
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
{
IDENTIFIER ZI403;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
(ZI408) = make_goto_stmt ((ZI403));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR621 (EXP *ZO420)
{
EXP ZI420;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_char_Hexp: case lex_wchar_Hexp:
case lex_string_Hexp: case lex_wstring_Hexp: case lex_integer_Hexp:
case lex_floating_Hexp: case lex_complex_Hexp: case lex_and_H1:
case lex_compl_H1: case lex_minus: case lex_minus_Hminus:
case lex_not_H1: case lex_open_Hround: case lex_plus:
case lex_plus_Hplus: case lex_star: case lex_abs:
case lex_sizeof: case lex_alignof: case lex_discard:
case lex_ellipsis_Hexp: case lex_set: case lex_unused:
case lex_inset_Hstart:
{
ZR418 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI420) = NULL_exp;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO420 = ZI420;
}
void
ZR519 (SID_LIST_EXP *ZO424)
{
SID_LIST_EXP ZI424;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_char_Hexp: case lex_wchar_Hexp:
case lex_string_Hexp: case lex_wstring_Hexp: case lex_integer_Hexp:
case lex_floating_Hexp: case lex_complex_Hexp: case lex_and_H1:
case lex_compl_H1: case lex_minus: case lex_minus_Hminus:
case lex_not_H1: case lex_open_Hround: case lex_plus:
case lex_plus_Hplus: case lex_star: case lex_abs:
case lex_sizeof: case lex_alignof: case lex_discard:
case lex_ellipsis_Hexp:
{
EXP ZI420;
ZR423 (&ZI420);
ZR1038 (&ZI420, &ZI424);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_set: case lex_unused:
{
EXP ZI420;
SID_LIST_EXP ZI427;
ZR514 (&ZI420);
ZR519 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((ZI420), (ZI427), (ZI424));
}
}
break;
case lex_inset_Hstart:
{
EXP ZI420;
SID_LIST_EXP ZI427;
ZR515 (&ZI420);
ZR519 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((ZI420), (ZI427), (ZI424));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO424 = ZI424;
}
void
ZR753 (int *ZO757)
{
int ZI757;
ZL2_753:;
switch (CURRENT_TERMINAL) {
case lex_ellipsis:
{
ADVANCE_LEXER;
{
(ZI757) = 1;
}
}
break;
case lex_type_Hname: case lex_complex_Htype: case lex_auto:
case lex_char: case lex_const: case lex_double:
case lex_enum: case lex_extern: case lex_float:
case lex_int: case lex_long: case lex_register:
case lex_short: case lex_signed: case lex_static:
case lex_struct: case lex_typedef: case lex_union:
case lex_unsigned: case lex_void: case lex_volatile:
case lex_restrict: case lex_bool: case lex_inline:
case lex_wchar_Ht: case lex_bottom: case lex_ptrdiff_Ht:
case lex_size_Ht:
{
IDENTIFIER ZI552;
ZR780 (&ZI552);
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
goto ZL2_753;
}
/*UNREACHED*/
default:
{
{
(ZI757) = 0;
}
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
}
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO757 = ZI757;
}
void
ZR413 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_char_Hexp: case lex_wchar_Hexp:
{
{
switch (CURRENT_TERMINAL) {
case lex_char_Hexp:
{
{
ZI408 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
case lex_wchar_Hexp:
{
{
ZI408 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
}
break;
case lex_floating_Hexp:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_floating_Hexp:
{
ZI408 = crt_token->pp_data.exp;
}
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_integer_Hexp:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_integer_Hexp:
{
ZI408 = crt_token->pp_data.exp;
}
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_string_Hexp: case lex_wstring_Hexp:
{
{
switch (CURRENT_TERMINAL) {
case lex_string_Hexp:
{
{
ZI408 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
case lex_wstring_Hexp:
{
{
ZI408 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR787 (IDENTIFIER *ZO403)
{
IDENTIFIER ZI403;
switch (CURRENT_TERMINAL) {
case lex_type_Hname:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
{
report (crt_loc, ERR_dcl_fct_par_typedef ((ZI403)));
}
}
break;
case lex_identifier: case lex_statement_Hname:
{
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO403 = ZI403;
}
void
parse_decl (TYPE ZI399, DECL_SPEC ZI611)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI696;
TYPE ZI1093;
CV_SPEC ZI698;
DECL_SPEC ZI1094;
BASE_TYPE ZI666;
TYPE ZI697;
CV_SPEC ZI637;
DECL_SPEC ZI726;
{
/* Resolve declaration-specifiers from other declarators */
(ZI0) = predict_dspec (0);
}
if (!ZI0)
goto ZL1;
ZR723 (&ZI696, &ZI1093, &ZI698, &ZI1094);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* A type-name can be a declarator-id */
if (have_type_specifier && crt_lex_token == lex_type_Hname) {
crt_lex_token = lex_identifier;
}
}
ZR734 (&ZI696, &ZI1093, &ZI698, &ZI1094, &ZI666, &ZI697, &ZI637, &ZI726);
ZR823 (&ZI666, &ZI697, &ZI637, &ZI726);
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
return;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
}
}
void
ZR878 (TYPE ZI874, IDENTIFIER ZI875, TYPE *ZO876, IDENTIFIER *ZO877)
{
TYPE ZI876;
IDENTIFIER ZI877;
ZL2_878:;
switch (CURRENT_TERMINAL) {
case lex_open_Hround: case lex_open_Hsquare_H1: case lex_weak:
{
IDENTIFIER ZI403;
TYPE ZI427;
TYPE ZI399;
ZI403 = ZI875;
ZR755 (ZI403, &ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI874)) ? (ZI427): inject_pre_type ((ZI874), (ZI427), 0));
}
ZI874 = ZI399;
ZI875 = ZI403;
goto ZL2_878;
}
/*UNREACHED*/
default:
{
ZI876 = ZI874;
ZI877 = ZI875;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO876 = ZI876;
*ZO877 = ZI877;
}
void
ZR499 (EXP *ZO910)
{
EXP ZI910;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR497 (&ZI408);
ZR911 (ZI408, &ZI910);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO910 = ZI910;
}
void
ZR556 (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI471;
int ZI552;
EXP ZI420;
{
(ZI471) = begin_compound_stmt (1);
}
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
COPY_int (exp_sequence_block ((ZI471)), 2);
(ZI552) = 1;
}
ZR553 (ZI471, ZI552, &ZI420);
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI408) = end_compound_stmt ((ZI420));
}
{
RESCAN_LEXER;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR400 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
return;
ZL1:;
{
int ZI399;
{
(ZI399) = lex_semicolon;
}
{
/* Expected symbol */
int p = primary_form (crt_lex_token);
if (p != (ZI399)) report (crt_loc, ERR_lex_expect ((ZI399)));
}
}
}
void
ZR505 (EXP *ZO898)
{
EXP ZI898;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR503 (&ZI408);
ZR899 (ZI408, &ZI898);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO898 = ZI898;
}
void
ZR522 (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI420;
ZR507 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = convert_reference ((ZI420), REF_NORMAL);
(ZI408) = convert_lvalue ((ZI408));
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR741 (TYPE *ZO424)
{
TYPE ZI424;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
CV_SPEC ZI637;
switch (CURRENT_TERMINAL) {
case lex_star:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR642 (&ZI637);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
MAKE_type_ptr ((ZI637), NULL_type, (ZI424));
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO424 = ZI424;
}
void
ZR884 (EXP ZI882, EXP *ZO883)
{
EXP ZI883;
ZL2_884:;
switch (CURRENT_TERMINAL) {
case lex_hash_Helif:
{
EXP ZI424;
EXP ZI471;
ZI424 = ZI882;
{
ZI471 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
{
EXP c = make_else_cond (crt_hash_cond);
crt_hash_cond = make_if_cond ((ZI471), c);
}
{
target_decl (lex_elif, (ZI471));
}
ZR814 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
} else {
ZI882 = ZI424;
goto ZL2_884;
}
}
/*UNREACHED*/
default:
{
ZI883 = ZI882;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO883 = ZI883;
}
void
ZR630 (SID_LIST_EXP *ZO424)
{
SID_LIST_EXP ZI424;
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
ZR425 (&ZI424);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI424) = NULL_list (EXP);
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO424 = ZI424;
}
void
ZR492 (EXP *ZO922)
{
EXP ZI922;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR489 (&ZI408);
ZR923 (ZI408, &ZI922);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO922 = ZI922;
}
void
ZR807 (DECL_SPEC ZI611, BASE_TYPE ZI666, TYPE ZI399)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
ZL2_807:;
{
ZR806 (ZI611, ZI666, ZI399);
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
goto ZL2_807;
}
/*UNREACHED*/
case 358:
RESTORE_LEXER;
goto ZL1;
default:
break;
}
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR759 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_char_Hexp: case lex_wchar_Hexp:
case lex_string_Hexp: case lex_wstring_Hexp: case lex_integer_Hexp:
case lex_floating_Hexp: case lex_complex_Hexp: case lex_and_H1:
case lex_compl_H1: case lex_minus: case lex_minus_Hminus:
case lex_not_H1: case lex_open_Hround: case lex_plus:
case lex_plus_Hplus: case lex_star: case lex_abs:
case lex_sizeof: case lex_alignof: case lex_discard:
case lex_ellipsis_Hexp:
{
ZR522 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI408) = NULL_exp;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR760 (int *ZO757)
{
int ZI757;
switch (CURRENT_TERMINAL) {
case lex_type_Hname: case lex_complex_Htype: case lex_ellipsis:
case lex_auto: case lex_char: case lex_const:
case lex_double: case lex_enum: case lex_extern:
case lex_float: case lex_int: case lex_long:
case lex_register: case lex_short: case lex_signed:
case lex_static: case lex_struct: case lex_typedef:
case lex_union: case lex_unsigned: case lex_void:
case lex_volatile: case lex_restrict: case lex_bool:
case lex_inline: case lex_wchar_Ht: case lex_bottom:
case lex_ptrdiff_Ht: case lex_size_Ht:
{
ZR753 (&ZI757);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI757) = 0;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO757 = ZI757;
}
void
ZR480 (EXP *ZO938)
{
EXP ZI938;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR463 (&ZI408);
ZR939 (ZI408, &ZI938);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO938 = ZI938;
}
void
ZR1015 (EXP *ZI1014, EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_assign:
{
EXP ZI452;
ADVANCE_LEXER;
ZR423 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_assign_exp ((*ZI1014), (ZI452), 1);
}
}
break;
default:
{
EXP ZI970;
EXP ZI969;
EXP ZI968;
EXP ZI967;
EXP ZI966;
EXP ZI965;
EXP ZI964;
EXP ZI963;
EXP ZI962;
EXP ZI961;
EXP ZI958;
ZR939 (*ZI1014, &ZI970);
ZR935 (ZI970, &ZI969);
ZR931 (ZI969, &ZI968);
ZR927 (ZI968, &ZI967);
ZR923 (ZI967, &ZI966);
ZR919 (ZI966, &ZI965);
ZR915 (ZI965, &ZI964);
ZR911 (ZI964, &ZI963);
ZR907 (ZI963, &ZI962);
ZR903 (ZI962, &ZI961);
ZR899 (ZI961, &ZI958);
ZR960 (&ZI958, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_and_Heq_H1: case lex_div_Heq: case lex_lshift_Heq:
case lex_minus_Heq: case lex_or_Heq_H1: case lex_plus_Heq:
case lex_rem_Heq: case lex_rshift_Heq: case lex_star_Heq:
case lex_xor_Heq_H1:
{
int ZI464;
EXP ZI452;
{
(ZI464) = crt_lex_token;
}
ZR510 ();
ZR423 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* op will be in its primary form */
(ZI408) = make_become_exp ((ZI464), (*ZI1014), (ZI452));
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
/* BEGINNING OF TRAILER */
/* END OF FILE */
syntax highlighted by Code2HTML, v. 0.9.1