/*
* 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
ZR846 (OFFSET ZI452, TYPE ZI573, OFFSET *ZO857, TYPE *ZO858)
{
OFFSET ZI857;
TYPE ZI858;
if ((CURRENT_TERMINAL) == 358) {
return;
}
ZL2_846:;
{
OFFSET ZI420;
TYPE ZI399;
ZR845 (ZI452, ZI573, &ZI420, &ZI399);
{
switch (CURRENT_TERMINAL) {
case lex_dot: case lex_open_Hsquare_H1:
{
ZI452 = ZI420;
ZI573 = ZI399;
goto ZL2_846;
}
/*UNREACHED*/
default:
{
ZI857 = ZI420;
ZI858 = ZI399;
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
}
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO857 = ZI857;
*ZO858 = ZI858;
}
void
ZR927 (EXP ZI925, EXP *ZO926)
{
EXP ZI926;
ZL2_927:;
switch (CURRENT_TERMINAL) {
case lex_greater: case lex_greater_Heq: case lex_less:
case lex_less_Heq:
{
int ZI464;
EXP ZI452;
EXP ZI408;
{
(ZI464) = crt_lex_token;
}
{
switch (CURRENT_TERMINAL) {
case lex_greater:
{
ADVANCE_LEXER;
}
break;
case lex_greater_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_less:
{
ADVANCE_LEXER;
}
break;
case lex_less_Heq:
{
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
ZR486 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* op will be in its primary form */
(ZI408) = make_relation_exp ((ZI464), (ZI925), (ZI452));
}
ZI925 = ZI408;
goto ZL2_927;
}
/*UNREACHED*/
default:
{
ZI926 = ZI925;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO926 = ZI926;
}
void
ZR815 (EXP *ZO883)
{
EXP ZI883;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI471;
EXP ZI424;
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;
}
{
target_decl (lex_if, (ZI471));
}
ZR814 ();
ZR884 (ZI424, &ZI883);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO883 = ZI883;
}
void
ZR665 (TYPE *ZO399)
{
TYPE ZI399;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
switch (CURRENT_TERMINAL) {
case lex_enum:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
switch (CURRENT_TERMINAL) {
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;
}
}
ZR1065 (&ZI403, &ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hbrace_H1:
{
IDENTIFIER ZI403;
IDENTIFIER ZI424;
IDENTIFIER ZI680;
{
HASHID nm = lookup_anon ();
(ZI403) = DEREF_id (hashid_id (nm));
}
{
(ZI424) = begin_enum_defn ((ZI403), NULL_type);
no_type_defns++;
}
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR691 (&ZI424);
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI680) = end_enum_defn ((ZI424));
}
{
MAKE_type_pre (cv_none, btype_alias, qual_none, (ZI399));
COPY_id (type_name ((ZI399)), (ZI680));
have_type_specifier = 1;
}
}
break;
default:
goto ZL1;
}
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
}
void
ZR752 (TYPE *ZO399, IDENTIFIER *ZO403)
{
TYPE ZI399;
IDENTIFIER ZI403;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
case lex_open_Hround:
{
ZR761 (&ZI399, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_star:
{
TYPE ZI424;
TYPE ZI427;
ZR741 (&ZI424);
ZR752 (&ZI427, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (ZI424): inject_pre_type ((ZI427), (ZI424), 0));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
*ZO403 = ZI403;
}
void
ZR1056 (TYPE *ZO868, IDENTIFIER *ZO869)
{
TYPE ZI868;
IDENTIFIER ZI869;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
IDENTIFIER ZI1057;
TYPE ZI1058;
TYPE ZI399;
IDENTIFIER ZI403;
{
/* Resolve parameter declarators from type names */
(ZI0) = predict_param ();
}
if (!ZI0)
goto ZL2;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI1057 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI1057 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI1057 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
(ZI1058) = NULL_type;
}
{
IDENTIFIER pid = underlying_id ((ZI1057));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR870 (ZI1058, ZI1057, &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;
ZR870 (ZI399, ZI403, &ZI868, &ZI869);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
{
TYPE ZI399;
IDENTIFIER ZI403;
ADVANCE_LEXER;
ZR1056 (&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;
ZR870 (ZI399, ZI403, &ZI868, &ZI869);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_weak:
{
IDENTIFIER ZI1055;
int ZI757;
TYPE ZI1061;
IDENTIFIER ZI1062;
TYPE ZI399;
IDENTIFIER ZI403;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI1055) = NULL_id;
}
{
func_type_defn (0);
begin_param ((ZI1055));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR760 (&ZI757);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1061) = 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;
}
{
HASHID nm = lookup_anon ();
(ZI1062) = DEREF_id (hashid_id (nm));
}
{
IDENTIFIER pid = underlying_id ((ZI1062));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR870 (ZI1061, ZI1062, &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;
ZR870 (ZI399, ZI403, &ZI868, &ZI869);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hsquare_H1:
{
EXP ZI408;
TYPE ZI1059;
IDENTIFIER ZI1060;
TYPE ZI399;
IDENTIFIER ZI403;
{
{
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, (ZI1059));
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
HASHID nm = lookup_anon ();
(ZI1060) = DEREF_id (hashid_id (nm));
}
{
IDENTIFIER pid = underlying_id ((ZI1060));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR870 (ZI1059, ZI1060, &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;
ZR870 (ZI399, ZI403, &ZI868, &ZI869);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_star:
{
TYPE ZI424;
TYPE ZI427;
IDENTIFIER ZI403;
TYPE ZI399;
ZR741 (&ZI424);
ZR774 (&ZI427, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (ZI424): inject_pre_type ((ZI427), (ZI424), 0));
}
{
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;
ZR870 (ZI399, ZI403, &ZI868, &ZI869);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_type_Hname: case lex_complex_Htype: case lex_close_Hround:
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:
{
IDENTIFIER ZI1054;
TYPE ZI573;
TYPE ZI399;
IDENTIFIER ZI403;
{
(ZI1054) = NULL_id;
}
{
func_type_defn (0);
begin_param ((ZI1054));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR765 (&ZI573);
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZI399 = ZI573;
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
{
HASHID nm = lookup_anon ();
(ZI403) = DEREF_id (hashid_id (nm));
}
{
IDENTIFIER pid = underlying_id ((ZI403));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR870 (ZI399, ZI403, &ZI868, &ZI869);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO868 = ZI868;
*ZO869 = ZI869;
}
void
ZR486 (EXP *ZO930)
{
EXP ZI930;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR483 (&ZI408);
ZR931 (ZI408, &ZI930);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO930 = ZI930;
}
void
ZR605 (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI420;
EXP ZI452;
ZR621 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI452) = bind_temporary ((ZI420));
}
{
MAKE_exp_location (type_void, crt_loc, (ZI452), (ZI408));
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR686 (IDENTIFIER ZI408)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
IDENTIFIER ZI403;
EXP ZI471;
{
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;
}
}
{
IDENTIFIER pid = underlying_id ((ZI403));
DEREF_loc (id_loc (pid), decl_loc);
}
{
switch (CURRENT_TERMINAL) {
case lex_assign:
{
ADVANCE_LEXER;
ZR522 (&ZI471);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI471) = NULL_exp;
}
}
break;
}
}
{
IGNORE make_enumerator ((ZI408), (ZI403), (ZI471));
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR762 (TYPE ZI424, TYPE *ZO399, IDENTIFIER *ZO403)
{
TYPE ZI399;
IDENTIFIER ZI403;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
TYPE ZI427;
ZR752 (&ZI427, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (ZI424): inject_pre_type ((ZI427), (ZI424), 1));
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
*ZO403 = ZI403;
}
void
ZR802 (IDENTIFIER ZI552, EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_assign:
{
ADVANCE_LEXER;
ZR798 (ZI552, &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
parse_file (TYPE ZI399, DECL_SPEC ZI611)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI947;
TYPE ZI948;
CV_SPEC ZI949;
DECL_SPEC ZI950;
BASE_TYPE ZI951;
TYPE ZI952;
CV_SPEC ZI953;
DECL_SPEC ZI954;
EXP ZI408;
{
/* Resolve declaration-specifiers from other declarators */
(ZI0) = predict_dspec (0);
}
if (!ZI0)
goto ZL2;
ZR723 (&ZI947, &ZI948, &ZI949, &ZI950);
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 (&ZI947, &ZI948, &ZI949, &ZI950, &ZI951, &ZI952, &ZI953, &ZI954);
ZR955 (&ZI951, &ZI952, &ZI953, &ZI954, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
external_declaration ((ZI408), 1);
}
ZR813 ();
switch (CURRENT_TERMINAL) {
case lex_eof:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_eof:
{
ADVANCE_LEXER;
}
break;
case lex_semicolon:
{
ADVANCE_LEXER;
{
report (crt_loc, ERR_dcl_dcl_semicolon ());
}
ZR813 ();
switch (CURRENT_TERMINAL) {
case lex_eof:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_asm:
{
EXP ZI408;
ZR629 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
external_declaration ((ZI408), 1);
}
ZR813 ();
switch (CURRENT_TERMINAL) {
case lex_eof:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_hash_Hif: case lex_hash_Hpragma:
{
ZR816 ();
ZR813 ();
switch (CURRENT_TERMINAL) {
case lex_eof:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
case lex_open_Hround: case lex_star:
{
BASE_TYPE ZI666;
TYPE ZI697;
CV_SPEC ZI637;
DECL_SPEC ZI726;
TYPE ZI956;
DECL_SPEC ZI957;
TYPE ZI573;
IDENTIFIER ZI403;
EXP ZI408;
{
(ZI666) = btype_none;
}
{
(ZI697) = NULL_type;
}
{
(ZI637) = cv_none;
}
{
(ZI726) = dspec_none;
}
{
/* Complete a declaration specifier and a type */
(ZI957) = complete_dspec ((ZI726), (ZI666), (ZI697), (ZI637));
(ZI956) = complete_pre_type ((ZI666), (ZI697), (ZI637), 0);
have_type_specifier = 0;
}
ZR762 (ZI956, &ZI573, &ZI403);
ZR829 (&ZI666, &ZI956, &ZI957, &ZI573, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = NULL_exp;
}
{
external_declaration ((ZI408), 1);
}
ZR813 ();
switch (CURRENT_TERMINAL) {
case lex_eof:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
return;
ZL1:;
{
{
/* Unrecoverable syntax errors */
ERROR err = ERR_lex_parse (crt_token);
err = concat_error (err, ERR_lex_abort ());
report (crt_loc, err);
have_syntax_error = 1;
}
}
ZL0:;
}
void
ZR931 (EXP ZI929, EXP *ZO930)
{
EXP ZI930;
ZL2_931:;
switch (CURRENT_TERMINAL) {
case lex_lshift:
{
EXP ZI452;
EXP ZI408;
ADVANCE_LEXER;
ZR483 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_shift_exp (lex_lshift, (ZI929), (ZI452));
}
ZI929 = ZI408;
goto ZL2_931;
}
/*UNREACHED*/
case lex_rshift:
{
EXP ZI452;
EXP ZI408;
ADVANCE_LEXER;
ZR483 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_shift_exp (lex_rshift, (ZI929), (ZI452));
}
ZI929 = ZI408;
goto ZL2_931;
}
/*UNREACHED*/
default:
{
ZI930 = ZI929;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO930 = ZI930;
}
void
parse_offset (OFFSET ZI452, TYPE ZI573, OFFSET *ZO420, TYPE *ZO399)
{
OFFSET ZI420;
TYPE ZI399;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
OFFSET ZI471;
TYPE ZI847;
ZR844 (ZI452, ZI573, &ZI471, &ZI847);
{
switch (CURRENT_TERMINAL) {
case lex_dot: case lex_open_Hsquare_H1:
{
ZR846 (ZI471, ZI847, &ZI420, &ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
ZI420 = ZI471;
ZI399 = ZI847;
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
}
}
}
goto ZL0;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
ZI420 = ZI452;
ZI399 = ZI573;
}
ZL0:;
*ZO420 = ZI420;
*ZO399 = ZI399;
}
void
parse_nat (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR522 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI408) = NULL_exp;
}
}
ZL0:;
*ZO408 = ZI408;
}
void
ZR520 (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR423 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
parse_param (TYPE ZI573, int ZI424, IDENTIFIER *ZO552)
{
IDENTIFIER ZI552;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR780 (&ZI552);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI552) = NULL_id;
}
}
ZL0:;
*ZO552 = ZI552;
}
void
ZR695 (BASE_TYPE *ZO666, TYPE *ZO399, CV_SPEC *ZO637)
{
BASE_TYPE ZI666;
TYPE ZI399;
CV_SPEC ZI637;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI696;
TYPE ZI697;
CV_SPEC ZI698;
ZR694 (&ZI696, &ZI697, &ZI698);
{
switch (CURRENT_TERMINAL) {
case lex_type_Hname: case lex_complex_Htype: case lex_char:
case lex_const: case lex_double: case lex_enum:
case lex_float: case lex_int: case lex_long:
case lex_short: case lex_signed: case lex_struct:
case lex_union: case lex_unsigned: case lex_void:
case lex_volatile: case lex_restrict: case lex_bool:
case lex_wchar_Ht: case lex_bottom: case lex_ptrdiff_Ht:
case lex_size_Ht:
{
BASE_TYPE ZI700;
TYPE ZI701;
CV_SPEC ZI702;
ZR695 (&ZI700, &ZI701, &ZI702);
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));
}
}
break;
default:
{
ZI666 = ZI696;
ZI399 = ZI697;
ZI637 = ZI698;
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
}
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO666 = ZI666;
*ZO399 = ZI399;
*ZO637 = ZI637;
}
void
ZR935 (EXP ZI933, EXP *ZO934)
{
EXP ZI934;
ZL2_935:;
switch (CURRENT_TERMINAL) {
case lex_minus:
{
EXP ZI452;
EXP ZI408;
ADVANCE_LEXER;
ZR480 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_minus_exp ((ZI933), (ZI452));
}
ZI933 = ZI408;
goto ZL2_935;
}
/*UNREACHED*/
case lex_plus:
{
EXP ZI452;
EXP ZI408;
ADVANCE_LEXER;
ZR480 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_plus_exp ((ZI933), (ZI452));
}
ZI933 = ZI408;
goto ZL2_935;
}
/*UNREACHED*/
default:
{
ZI934 = ZI933;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO934 = ZI934;
}
void
parse_func (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR557 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI408) = NULL_exp;
}
}
ZL0:;
*ZO408 = ZI408;
}
void
ZR763 (TYPE *ZO399)
{
TYPE ZI399;
switch (CURRENT_TERMINAL) {
case lex_open_Hround: case lex_open_Hsquare_H1: case lex_weak:
{
ZR769 (&ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_star:
{
TYPE ZI1067;
ZR741 (&ZI1067);
ZR1069 (&ZI1067, &ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
}
void
ZR1065 (IDENTIFIER *ZI403, TYPE *ZO399)
{
TYPE ZI399;
switch (CURRENT_TERMINAL) {
default:
{
BASE_TYPE ZI677;
{
(ZI677) = btype_enum;
}
{
MAKE_type_pre (cv_none, (ZI677), qual_none, (ZI399));
COPY_id (type_name ((ZI399)), (*ZI403));
if (have_type_declaration == TYPE_DECL_NONE) {
have_type_declaration = TYPE_DECL_ELABORATE;
}
have_type_specifier = 1;
}
}
break;
case lex_open_Hbrace_H1:
{
IDENTIFIER ZI424;
IDENTIFIER ZI680;
{
(ZI424) = begin_enum_defn ((*ZI403), NULL_type);
no_type_defns++;
}
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR691 (&ZI424);
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI680) = end_enum_defn ((ZI424));
}
{
MAKE_type_pre (cv_none, btype_alias, qual_none, (ZI399));
COPY_id (type_name ((ZI399)), (ZI680));
have_type_specifier = 1;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
}
void
ZR716 (DECL_SPEC *ZO611)
{
DECL_SPEC ZI611;
switch (CURRENT_TERMINAL) {
case lex_auto:
{
ADVANCE_LEXER;
{
(ZI611) = dspec_auto;
}
}
break;
case lex_extern:
{
ADVANCE_LEXER;
{
(ZI611) = dspec_extern;
}
}
break;
case lex_register:
{
ADVANCE_LEXER;
{
(ZI611) = dspec_register;
}
}
break;
case lex_static:
{
ADVANCE_LEXER;
{
(ZI611) = dspec_static;
}
}
break;
case lex_typedef:
{
ADVANCE_LEXER;
{
(ZI611) = dspec_typedef;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO611 = ZI611;
}
void
ZR754 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
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;
default:
goto ZL1;
}
}
{
IDENTIFIER pid = underlying_id ((ZI403));
DEREF_loc (id_loc (pid), decl_loc);
}
{
IGNORE weak_param_decl ((ZI403));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR788 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR939 (EXP ZI937, EXP *ZO938)
{
EXP ZI938;
ZL2_939:;
switch (CURRENT_TERMINAL) {
case lex_div:
{
EXP ZI452;
EXP ZI408;
ADVANCE_LEXER;
ZR463 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_mult_exp (lex_div, (ZI937), (ZI452));
}
ZI937 = ZI408;
goto ZL2_939;
}
/*UNREACHED*/
case lex_rem:
{
EXP ZI452;
EXP ZI408;
ADVANCE_LEXER;
ZR463 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_rem_exp ((ZI937), (ZI452));
}
ZI937 = ZI408;
goto ZL2_939;
}
/*UNREACHED*/
case lex_star:
{
EXP ZI452;
EXP ZI408;
ADVANCE_LEXER;
ZR463 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_mult_exp (lex_star, (ZI937), (ZI452));
}
ZI937 = ZI408;
goto ZL2_939;
}
/*UNREACHED*/
default:
{
ZI938 = ZI937;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO938 = ZI938;
}
void
parse_id (IDENTIFIER *ZO403)
{
IDENTIFIER ZI403;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
{
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;
}
}
}
goto ZL0;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI403) = NULL_id;
}
}
ZL0:;
*ZO403 = ZI403;
}
void
ZR463 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_alignof:
{
int ZI464;
ADVANCE_LEXER;
{
(ZI464) = lex_alignof;
}
ZR465 (ZI464, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_complex_Hexp:
{
EXP ZI972;
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI972 = parse_exp_token (id, args);
RESCAN_LEXER;
}
ADVANCE_LEXER;
ZR943 (ZI972, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_discard:
{
EXP ZI420;
ADVANCE_LEXER;
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_cast_exp (type_void, (ZI420), 0);
}
}
break;
case lex_ellipsis_Hexp:
{
EXP ZI972;
ADVANCE_LEXER;
{
(ZI972) = make_ellipsis_exp ();
}
ZR943 (ZI972, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_identifier:
{
IDENTIFIER ZI403;
EXP ZI972;
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
{
(ZI972) = make_id_exp ((ZI403));
}
ZR943 (ZI972, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_minus_Hminus:
{
EXP ZI420;
ADVANCE_LEXER;
ZR462 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_prefix_exp (lex_minus_Hminus, (ZI420));
}
}
break;
case lex_open_Hround:
{
ADVANCE_LEXER;
ZR973 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_plus_Hplus:
{
EXP ZI420;
ADVANCE_LEXER;
ZR462 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_prefix_exp (lex_plus_Hplus, (ZI420));
}
}
break;
case lex_sizeof:
{
int ZI464;
ADVANCE_LEXER;
{
(ZI464) = lex_sizeof;
}
ZR465 (ZI464, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_star:
{
EXP ZI420;
ADVANCE_LEXER;
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_indir_exp ((ZI420));
}
}
break;
case lex_and_H1:
{
EXP ZI420;
{
{
switch (CURRENT_TERMINAL) {
case lex_and_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_ref_exp ((ZI420), 0);
}
}
break;
case lex_char_Hexp: case lex_wchar_Hexp: case lex_string_Hexp:
case lex_wstring_Hexp: case lex_integer_Hexp: case lex_floating_Hexp:
{
EXP ZI972;
ZR413 (&ZI972);
ZR943 (ZI972, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_not_H1:
{
EXP ZI420;
{
{
switch (CURRENT_TERMINAL) {
case lex_not_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_not_exp ((ZI420));
}
}
break;
case lex_compl_H1: case lex_minus: case lex_plus:
case lex_abs:
{
int ZI464;
EXP ZI420;
{
(ZI464) = crt_lex_token;
}
ZR473 ();
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_uminus_exp ((ZI464), (ZI420));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR668 (BASE_TYPE *ZO666, TYPE *ZO399)
{
BASE_TYPE ZI666;
TYPE ZI399;
switch (CURRENT_TERMINAL) {
case lex_complex_Htype:
{
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI399 = parse_type_token (id, args);
have_type_declaration = TYPE_DECL_NONE;
have_type_specifier = 1;
RESCAN_LEXER;
}
ADVANCE_LEXER;
{
(ZI666) = btype_none;
}
}
break;
case lex_type_Hname:
{
IDENTIFIER ZI403;
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
{
MAKE_type_pre (cv_none, btype_alias, qual_none, (ZI399));
COPY_id (type_name ((ZI399)), (ZI403));
have_type_specifier = 1;
}
{
(ZI666) = btype_none;
}
}
break;
case lex_char: case lex_double: case lex_float:
case lex_int: case lex_long: case lex_short:
case lex_signed: case lex_unsigned: case lex_void:
case lex_bool: case lex_wchar_Ht: case lex_bottom:
case lex_ptrdiff_Ht: case lex_size_Ht:
{
ZR667 (&ZI666);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = NULL_type;
have_type_specifier = 1;
}
}
break;
case lex_struct: case lex_union:
{
ZR664 (&ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI666) = btype_none;
}
}
break;
case lex_enum:
{
ZR665 (&ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI666) = btype_none;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO666 = ZI666;
*ZO399 = ZI399;
}
void
ZR770 (TYPE ZI424, TYPE *ZO399)
{
TYPE ZI399;
switch (CURRENT_TERMINAL) {
case lex_open_Hround: case lex_open_Hsquare_H1: case lex_star:
case lex_weak:
{
TYPE ZI427;
ZR763 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (ZI424): inject_pre_type ((ZI427), (ZI424), 1));
}
}
break;
default:
{
ZI399 = ZI424;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
}
void
ZR1069 (TYPE *ZI1067, TYPE *ZO399)
{
TYPE ZI399;
switch (CURRENT_TERMINAL) {
case lex_open_Hround: case lex_open_Hsquare_H1: case lex_star:
case lex_weak:
{
TYPE ZI427;
ZR763 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (*ZI1067): inject_pre_type ((ZI427), (*ZI1067), 0));
}
}
break;
default:
{
ZI399 = *ZI1067;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
}
void
ZR398 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
return;
ZL1:;
{
int ZI399;
{
(ZI399) = lex_open_Hround;
}
{
/* Expected symbol */
int p = primary_form (crt_lex_token);
if (p != (ZI399)) report (crt_loc, ERR_lex_expect ((ZI399)));
}
}
}
void
ZR1070 (TYPE *ZO861)
{
TYPE ZI861;
switch (CURRENT_TERMINAL) {
case lex_open_Hround: case lex_open_Hsquare_H1: case lex_star:
case lex_weak:
{
TYPE ZI399;
ZR763 (&ZI399);
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;
ZR862 (ZI399, &ZI861);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_type_Hname: case lex_complex_Htype: case lex_close_Hround:
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:
{
IDENTIFIER ZI403;
TYPE ZI573;
TYPE ZI399;
{
(ZI403) = NULL_id;
}
{
func_type_defn (0);
begin_param ((ZI403));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR765 (&ZI573);
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZI399 = ZI573;
{
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 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO861 = ZI861;
}
void
ZR943 (EXP ZI941, EXP *ZO942)
{
EXP ZI942;
ZL2_943:;
switch (CURRENT_TERMINAL) {
case lex_minus_Hminus:
{
EXP ZI408;
ADVANCE_LEXER;
{
(ZI408) = make_postfix_exp (lex_minus_Hminus, (ZI941));
}
ZI941 = ZI408;
goto ZL2_943;
}
/*UNREACHED*/
case lex_open_Hround:
{
SID_LIST_EXP ZI424;
EXP ZI408;
ADVANCE_LEXER;
ZR428 (&ZI424);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_func_exp ((ZI941), (ZI424), 0);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZI941 = ZI408;
goto ZL2_943;
}
/*UNREACHED*/
case lex_plus_Hplus:
{
EXP ZI408;
ADVANCE_LEXER;
{
(ZI408) = make_postfix_exp (lex_plus_Hplus, (ZI941));
}
ZI941 = ZI408;
goto ZL2_943;
}
/*UNREACHED*/
case lex_open_Hsquare_H1:
{
EXP ZI452;
EXP ZI408;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR418 (&ZI452);
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI408) = make_index_exp ((ZI941), (ZI452));
}
ZI941 = ZI408;
goto ZL2_943;
}
/*UNREACHED*/
case lex_arrow:
{
EXP ZI452;
TYPE ZI399;
NAMESPACE ZI430;
IDENTIFIER ZI403;
EXP ZI408;
{
(ZI452) = begin_field_exp (lex_arrow, (ZI941), &(ZI399), &(ZI430));
}
ADVANCE_LEXER;
ZR431 (ZI430, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = end_field_exp (lex_arrow, (ZI452), (ZI399), (ZI430), (ZI403), 0);
}
{
RESCAN_LEXER;
}
ZI941 = ZI408;
goto ZL2_943;
}
/*UNREACHED*/
case lex_dot:
{
EXP ZI452;
TYPE ZI399;
NAMESPACE ZI430;
IDENTIFIER ZI403;
EXP ZI408;
{
(ZI452) = begin_field_exp (lex_dot, (ZI941), &(ZI399), &(ZI430));
}
ADVANCE_LEXER;
ZR431 (ZI430, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = end_field_exp (lex_dot, (ZI452), (ZI399), (ZI430), (ZI403), 0);
}
{
RESCAN_LEXER;
}
ZI941 = ZI408;
goto ZL2_943;
}
/*UNREACHED*/
default:
{
ZI942 = ZI941;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO942 = ZI942;
}
void
ZR688 (IDENTIFIER ZI408)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
ZL2_688:;
{
ZR686 (ZI408);
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
{
/* Extra comma at the end of a list */
report (crt_loc, ERR_lex_extra_comma ());
}
goto ZL2_688;
}
/*UNREACHED*/
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
{
goto ZL2_688;
}
/*UNREACHED*/
default:
{
{
/* Extra comma at the end of a list */
report (crt_loc, ERR_lex_extra_comma ());
}
}
break;
}
}
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
break;
}
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR691 (IDENTIFIER *ZI424)
{
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
{
ZR688 (*ZI424);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
break;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR604 (EXP *ZO408)
{
EXP ZI408;
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 ZL2;
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;
{
in_declaration--;
(ZI408) = NULL_exp;
}
{
report (crt_loc, ERR_stmt_for_decl ());
}
{
unreached_fall = 1;
}
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_semicolon: 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:
{
ZR540 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR845 (OFFSET ZI452, TYPE ZI573, OFFSET *ZO420, TYPE *ZO399)
{
OFFSET ZI420;
TYPE ZI399;
switch (CURRENT_TERMINAL) {
case lex_dot:
{
ADVANCE_LEXER;
ZR844 (ZI452, ZI573, &ZI420, &ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hsquare_H1:
{
EXP ZI408;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR522 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
OFFSET off = offset_index ((ZI573), (ZI408), &(ZI399));
(ZI420) = offset_add ((ZI452), off);
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO420 = ZI420;
*ZO399 = ZI399;
}
void
ZR462 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_alignof:
{
int ZI464;
ADVANCE_LEXER;
{
(ZI464) = lex_alignof;
}
ZR465 (ZI464, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_minus_Hminus:
{
EXP ZI420;
ADVANCE_LEXER;
ZR462 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_prefix_exp (lex_minus_Hminus, (ZI420));
}
}
break;
case lex_plus_Hplus:
{
EXP ZI420;
ADVANCE_LEXER;
ZR462 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_prefix_exp (lex_plus_Hplus, (ZI420));
}
}
break;
case lex_sizeof:
{
int ZI464;
ADVANCE_LEXER;
{
(ZI464) = lex_sizeof;
}
ZR465 (ZI464, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_star:
{
EXP ZI420;
ADVANCE_LEXER;
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_indir_exp ((ZI420));
}
}
break;
case lex_and_H1:
{
EXP ZI420;
{
{
switch (CURRENT_TERMINAL) {
case lex_and_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_ref_exp ((ZI420), 0);
}
}
break;
case lex_not_H1:
{
EXP ZI420;
{
{
switch (CURRENT_TERMINAL) {
case lex_not_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_not_exp ((ZI420));
}
}
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_open_Hround:
case lex_ellipsis_Hexp:
{
ZR451 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_compl_H1: case lex_minus: case lex_plus:
case lex_abs:
{
int ZI464;
EXP ZI420;
{
(ZI464) = crt_lex_token;
}
ZR473 ();
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_uminus_exp ((ZI464), (ZI420));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR489 (EXP *ZO926)
{
EXP ZI926;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR486 (&ZI408);
ZR927 (ZI408, &ZI926);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO926 = ZI926;
}
void
ZR607 (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: case lex_set: case lex_unused:
case lex_inset_Hstart:
{
EXP ZI420;
EXP ZI452;
ZR418 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI452) = make_exp_stmt ((ZI420));
}
{
(ZI408) = bind_temporary ((ZI452));
}
}
break;
default:
{
{
(ZI408) = NULL_exp;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR497 (EXP *ZO914)
{
EXP ZI914;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR495 (&ZI408);
ZR915 (ZI408, &ZI914);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO914 = ZI914;
}
void
parse_exp (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR423 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI408) = NULL_exp;
}
}
ZL0:;
*ZO408 = ZI408;
}
void
ZR694 (BASE_TYPE *ZO666, TYPE *ZO399, CV_SPEC *ZO637)
{
BASE_TYPE ZI666;
TYPE ZI399;
CV_SPEC ZI637;
switch (CURRENT_TERMINAL) {
case lex_const: case lex_volatile: case lex_restrict:
{
ZR638 (&ZI637);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI666) = btype_none;
}
{
(ZI399) = NULL_type;
}
}
break;
case lex_type_Hname: case lex_complex_Htype: case lex_char:
case lex_double: case lex_enum: case lex_float:
case lex_int: case lex_long: case lex_short:
case lex_signed: case lex_struct: case lex_union:
case lex_unsigned: case lex_void: case lex_bool:
case lex_wchar_Ht: case lex_bottom: case lex_ptrdiff_Ht:
case lex_size_Ht:
{
ZR668 (&ZI666, &ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI637) = cv_none;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO666 = ZI666;
*ZO399 = ZI399;
*ZO637 = ZI637;
}
void
ZR823 (BASE_TYPE *ZI666, TYPE *ZI697, CV_SPEC *ZI637, DECL_SPEC *ZI726)
{
switch (CURRENT_TERMINAL) {
default:
{
{
IGNORE empty_decl ((*ZI726), NULL_type, (*ZI666), (*ZI697), (*ZI637), last_lex_token, 0);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
have_type_specifier = 0;
}
}
break;
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
case lex_open_Hround: case lex_star:
{
TYPE ZI399;
DECL_SPEC ZI611;
{
/* Complete a declaration specifier and a type */
(ZI611) = complete_dspec ((*ZI726), (*ZI666), (*ZI697), (*ZI637));
(ZI399) = complete_pre_type ((*ZI666), (*ZI697), (*ZI637), 0);
have_type_specifier = 0;
}
ZR807 (ZI611, *ZI666, ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
parse_stmt (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR532 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI408) = NULL_exp;
}
}
ZL0:;
*ZO408 = ZI408;
}
void
ZR835 (TYPE ZI424, BASE_TYPE ZI427)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
ZL2_835:;
{
ZR834 (ZI424, ZI427);
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
goto ZL2_835;
}
/*UNREACHED*/
case 358:
RESTORE_LEXER;
goto ZL1;
default:
break;
}
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR1081 (int *ZI464, int *ZI466, int *ZI467, EXP *ZO471)
{
EXP ZI471;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
TYPE ZI399;
int ZI470;
EXP ZI420;
{
/* Resolve type-ids from expressions */
(ZI0) = predict_typeid (1);
}
if (!ZI0)
goto ZL2;
ZR448 (&ZI399, &ZI470);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI420) = NULL_exp;
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (*ZI464));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
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 ZI1080;
EXP ZI408;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
{
IGNORE incr_value (OPT_VAL_paren_depth);
}
ZR418 (&ZI1080);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_paren_exp ((ZI1080));
decr_value (OPT_VAL_paren_depth);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR943 (ZI408, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI469) = no_side_effects - (*ZI466);
}
{
(ZI470) = no_type_defns - (*ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (*ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (*ZI464));
}
}
break;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO471 = ZI471;
}
void
ZR448 (TYPE *ZO399, int *ZO476)
{
TYPE ZI399;
int ZI476;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
int ZI466;
BASE_TYPE ZI666;
TYPE ZI424;
CV_SPEC ZI637;
TYPE ZI427;
{
(ZI466) = no_type_defns;
}
ZR695 (&ZI666, &ZI424, &ZI637);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI427) = complete_pre_type ((ZI666), (ZI424), (ZI637), 1);
have_type_specifier = 0;
}
ZR770 (ZI427, &ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI476) = no_type_defns - (ZI466);
}
{
object_type ((ZI399), null_tag);
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
*ZO476 = ZI476;
}
void
ZR514 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_set:
{
EXP ZI420;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR418 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_set_exp ((ZI420));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_unused:
{
EXP ZI420;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR418 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_unused_exp ((ZI420));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR1082 (IDENTIFIER *ZI552, SID_LIST_EXP *ZO427)
{
SID_LIST_EXP ZI427;
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_Hbrace_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:
{
ZR799 (*ZI552, &ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI427) = NULL_list (EXP);
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO427 = ZI427;
}
void
ZR955 (BASE_TYPE *ZI951, TYPE *ZI952, CV_SPEC *ZI953, DECL_SPEC *ZI954, EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_semicolon:
{
{
IGNORE empty_decl ((*ZI954), NULL_type, (*ZI951), (*ZI952), (*ZI953), last_lex_token, 0);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
have_type_specifier = 0;
}
ADVANCE_LEXER;
{
(ZI408) = NULL_exp;
}
}
break;
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
case lex_open_Hround: case lex_star:
{
TYPE ZI399;
DECL_SPEC ZI611;
TYPE ZI573;
IDENTIFIER ZI403;
{
/* Complete a declaration specifier and a type */
(ZI611) = complete_dspec ((*ZI954), (*ZI951), (*ZI952), (*ZI953));
(ZI399) = complete_pre_type ((*ZI951), (*ZI952), (*ZI953), 0);
have_type_specifier = 0;
}
ZR762 (ZI399, &ZI573, &ZI403);
ZR829 (ZI951, &ZI399, &ZI611, &ZI573, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = NULL_exp;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR814 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
DECL_SPEC ZI611;
TYPE ZI399;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI611) = dspec_none;
}
{
(ZI399) = NULL_type;
}
ZR813 ();
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR829 (BASE_TYPE *ZI666, TYPE *ZI399, DECL_SPEC *ZI611, TYPE *ZI573, IDENTIFIER *ZI403)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
IDENTIFIER ZI552;
int ZI452;
EXP ZI420;
{
(ZI0) = function_params ((*ZI573));
}
if (!ZI0)
goto ZL2;
{
(ZI552) = make_func_decl ((*ZI611), (*ZI573), (*ZI403), 1);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
{
(ZI452) = in_class_defn;
in_class_defn = 0;
in_function_defn++;
really_in_function_defn++;
begin_function ((ZI552));
}
ZR557 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
IGNORE end_function ((ZI552), (ZI420));
in_class_defn = (ZI452);
in_function_defn--;
really_in_function_defn--;
}
{
RESCAN_LEXER;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_assign: case lex_comma: case lex_semicolon:
{
IDENTIFIER ZI552;
EXP ZI420;
{
if (in_weak_param) {
(ZI552) = make_param_decl ((*ZI611), (*ZI573), (*ZI403), CONTEXT_WEAK_PARAM);
} else if (type_tag ((*ZI573)) == type_func_tag) {
check_weak_func ((*ZI573), 0);
(ZI552) = make_func_decl ((*ZI611), (*ZI573), (*ZI403), 0);
} else {
int def = predict_obj_defn ();
(ZI552) = make_object_decl ((*ZI611), (*ZI573), (*ZI403), def);
}
if (IS_id_type_alias ((ZI552))) {
BASE_TYPE bs = DEREF_btype (id_type_alias_rep ((ZI552)));
bs |= (*ZI666);
COPY_btype (id_type_alias_rep ((ZI552)), bs);
}
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR802 (ZI552, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
int def = init_object ((ZI552), (ZI420));
if (do_dump) dump_declare ((ZI552), &decl_loc, def);
}
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
ZR807 (*ZI611, *ZI666, *ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
break;
}
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
}
void
ZR1085 (EXP *ZI1083, 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: case lex_set: case lex_unused:
case lex_inset_Hstart:
{
SID_LIST_EXP ZI427;
SID_LIST_EXP ZI424;
ZR519 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((*ZI1083), (ZI427), (ZI424));
}
{
(ZI408) = make_comma_exp ((ZI424));
}
}
break;
default:
{
ZI408 = *ZI1083;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR425 (SID_LIST_EXP *ZO424)
{
SID_LIST_EXP ZI424;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
SID_LIST_EXP ZI427;
ZR423 (&ZI408);
ZR630 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((ZI408), (ZI427), (ZI424));
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO424 = ZI424;
}
void
ZR960 (EXP *ZI958, EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_question:
{
EXP ZI420;
EXP ZI452;
ADVANCE_LEXER;
ZR418 (&ZI420);
switch (CURRENT_TERMINAL) {
case lex_colon:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR507 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_cond_exp ((*ZI958), (ZI420), (ZI452));
}
}
break;
default:
{
ZI408 = *ZI958;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR423 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_alignof:
{
int ZI1016;
EXP ZI1017;
ADVANCE_LEXER;
{
(ZI1016) = lex_alignof;
}
ZR465 (ZI1016, &ZI1017);
ZR1015 (&ZI1017, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_complex_Hexp:
{
EXP ZI1028;
EXP ZI1029;
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI1028 = parse_exp_token (id, args);
RESCAN_LEXER;
}
ADVANCE_LEXER;
ZR943 (ZI1028, &ZI1029);
ZR1015 (&ZI1029, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_discard:
{
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;
ADVANCE_LEXER;
ZR463 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI971) = make_cast_exp (type_void, (ZI420), 0);
}
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;
}
}
break;
case lex_ellipsis_Hexp:
{
EXP ZI1025;
EXP ZI1026;
ADVANCE_LEXER;
{
(ZI1025) = make_ellipsis_exp ();
}
ZR943 (ZI1025, &ZI1026);
ZR1015 (&ZI1026, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_identifier:
{
IDENTIFIER ZI403;
EXP ZI1022;
EXP ZI1023;
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
{
(ZI1022) = make_id_exp ((ZI403));
}
ZR943 (ZI1022, &ZI1023);
ZR1015 (&ZI1023, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_minus_Hminus:
{
EXP ZI997;
EXP ZI998;
ADVANCE_LEXER;
ZR462 (&ZI997);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI998) = make_prefix_exp (lex_minus_Hminus, (ZI997));
}
ZR1015 (&ZI998, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hround:
{
ADVANCE_LEXER;
ZR993 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_plus_Hplus:
{
EXP ZI994;
EXP ZI995;
ADVANCE_LEXER;
ZR462 (&ZI994);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI995) = make_prefix_exp (lex_plus_Hplus, (ZI994));
}
ZR1015 (&ZI995, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_sizeof:
{
int ZI1013;
EXP ZI1014;
ADVANCE_LEXER;
{
(ZI1013) = lex_sizeof;
}
ZR465 (ZI1013, &ZI1014);
ZR1015 (&ZI1014, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_star:
{
EXP ZI1000;
EXP ZI1001;
ADVANCE_LEXER;
ZR463 (&ZI1000);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1001) = make_indir_exp ((ZI1000));
}
ZR1015 (&ZI1001, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_and_H1:
{
EXP ZI1003;
EXP ZI1004;
{
{
switch (CURRENT_TERMINAL) {
case lex_and_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR463 (&ZI1003);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1004) = make_ref_exp ((ZI1003), 0);
}
ZR1015 (&ZI1004, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_char_Hexp: case lex_wchar_Hexp: case lex_string_Hexp:
case lex_wstring_Hexp: case lex_integer_Hexp: case lex_floating_Hexp:
{
EXP ZI1019;
EXP ZI1020;
ZR413 (&ZI1019);
ZR943 (ZI1019, &ZI1020);
ZR1015 (&ZI1020, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_not_H1:
{
EXP ZI1006;
EXP ZI1007;
{
{
switch (CURRENT_TERMINAL) {
case lex_not_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR463 (&ZI1006);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1007) = make_not_exp ((ZI1006));
}
ZR1015 (&ZI1007, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_compl_H1: case lex_minus: case lex_plus:
case lex_abs:
{
int ZI1009;
EXP ZI1010;
EXP ZI1011;
{
(ZI1009) = crt_lex_token;
}
ZR473 ();
ZR463 (&ZI1010);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1011) = make_uminus_exp ((ZI1009), (ZI1010));
}
ZR1015 (&ZI1011, &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
ZR1088 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_set:
{
EXP ZI1102;
EXP ZI1103;
ADVANCE_LEXER;
ZR418 (&ZI1102);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1103) = make_set_exp ((ZI1102));
}
ZR1104 (&ZI1103, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_unused:
{
EXP ZI1099;
EXP ZI1100;
ADVANCE_LEXER;
ZR418 (&ZI1099);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1100) = make_unused_exp ((ZI1099));
}
ZR1104 (&ZI1100, &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
ZR707 (BASE_TYPE *ZI696, TYPE *ZI697, CV_SPEC *ZI698, BASE_TYPE *ZO666, TYPE *ZO399, CV_SPEC *ZO637)
{
BASE_TYPE ZI666;
TYPE ZI399;
CV_SPEC ZI637;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI1042;
TYPE ZI1043;
CV_SPEC ZI1044;
BASE_TYPE ZI700;
TYPE ZI701;
CV_SPEC ZI702;
{
/* Resolve type-specifiers from other declarators */
(ZI0) = predict_tspec (0);
}
if (!ZI0)
goto ZL2;
ZR694 (&ZI1042, &ZI1043, &ZI1044);
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;
}
}
ZR707 (&ZI1042, &ZI1043, &ZI1044, &ZI700, &ZI701, &ZI702);
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));
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
default:
{
ZI666 = *ZI696;
ZI399 = *ZI697;
ZI637 = *ZI698;
}
break;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO666 = ZI666;
*ZO399 = ZI399;
*ZO637 = ZI637;
}
void
ZR428 (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:
{
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
ZR1089 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_case:
{
EXP ZI471;
EXP ZI420;
EXP ZI452;
ADVANCE_LEXER;
ZR522 (&ZI471);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI420) = begin_case_stmt ((ZI471), 0);
}
{
unreached_fall = 0;
}
switch (CURRENT_TERMINAL) {
case lex_colon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR532 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = end_case_stmt ((ZI420), (ZI452));
}
}
break;
case lex_default:
{
EXP ZI420;
EXP ZI452;
ADVANCE_LEXER;
{
(ZI420) = begin_default_stmt (0);
}
{
unreached_fall = 0;
}
switch (CURRENT_TERMINAL) {
case lex_colon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR532 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = end_default_stmt ((ZI420), (ZI452));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR503 (EXP *ZO902)
{
EXP ZI902;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR501 (&ZI408);
ZR903 (ZI408, &ZI902);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO902 = ZI902;
}
void
ZR620 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_break:
{
int ZI541;
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_break_stmt ();
}
{
unreached_fall = 1;
}
ZR400 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_continue:
{
int ZI541;
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_continue_stmt ();
}
{
unreached_fall = 1;
}
ZR400 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_goto:
{
int ZI541;
ADVANCE_LEXER;
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
ZR619 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_fall = 1;
}
ZR400 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_return:
{
int ZI541;
EXP ZI420;
ADVANCE_LEXER;
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
ZR621 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_return_stmt ((ZI420), lex_return);
}
{
unreached_fall = 1;
}
ZR400 ();
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;
}
/* END OF FILE */
syntax highlighted by Code2HTML, v. 0.9.1