/*
* Automatically generated from the files:
* /mnt/gmirror/ports/lang/TenDRA/work/tendra/src/producers/cpp/syntax/syntax.sid
* and
* /mnt/gmirror/ports/lang/TenDRA/work/tendra/src/producers/cpp/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 "ctype_ops.h"
#include "exp_ops.h"
#include "hashid_ops.h"
#include "id_ops.h"
#include "nspace_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;
typedef LIST (TYPE) SID_LIST_TYPE;
/*
* 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
ZR1233 (EXP ZI1231, EXP *ZO1232)
{
EXP ZI1232;
ZL2_1233:;
switch (CURRENT_TERMINAL) {
case lex_minus:
{
EXP ZI460;
EXP ZI435;
ADVANCE_LEXER;
ZR609 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_minus_exp ((ZI1231), (ZI460));
}
ZI1231 = ZI435;
goto ZL2_1233;
}
/*UNREACHED*/
case lex_plus:
{
EXP ZI460;
EXP ZI435;
ADVANCE_LEXER;
ZR609 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_plus_exp ((ZI1231), (ZI460));
}
ZI1231 = ZI435;
goto ZL2_1233;
}
/*UNREACHED*/
default:
{
ZI1232 = ZI1231;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1232 = ZI1232;
}
void
ZR904 (DECL_SPEC *ZO693)
{
DECL_SPEC ZI693;
switch (CURRENT_TERMINAL) {
case lex_explicit:
{
ADVANCE_LEXER;
{
(ZI693) = dspec_explicit;
}
}
break;
case lex_inline:
{
ADVANCE_LEXER;
{
(ZI693) = dspec_inline;
}
}
break;
case lex_overload:
{
ADVANCE_LEXER;
{
(ZI693) = dspec_none;
}
}
break;
case lex_virtual:
{
ADVANCE_LEXER;
{
(ZI693) = dspec_virtual;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO693 = ZI693;
}
void
ZR665 (EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
DECL_SPEC ZI693;
TYPE ZI418;
EXP ZI497;
{
/* Resolve declaration-statements from expression-statements */
int b = predict_decl ();
if (b) in_declaration++;
(ZI0) = b;
}
if (!ZI0)
goto ZL2;
{
(ZI693) = dspec_none;
}
{
(ZI418) = NULL_type;
}
ZR691 (ZI418, ZI693, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = (ZI497);
in_declaration--;
}
{
unreached_fall = 1;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_alignof:
{
int ZI454;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
{
(ZI454) = lex_alignof;
}
ZR597 (ZI454, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_colon_Hcolon:
{
ADVANCE_LEXER;
ZR1479 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_complex_Hexp:
{
EXP ZI1284;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI1284 = parse_exp_token (id, args);
RESCAN_LEXER;
}
ADVANCE_LEXER;
ZR1245 (ZI1284, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_complex_Hstmt:
{
EXP ZI497;
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI497 = parse_exp_token (id, args);
RESCAN_LEXER;
}
ADVANCE_LEXER;
{
(ZI435) = make_exp_stmt ((ZI497));
}
}
break;
case lex_complex_Htype:
{
TYPE ZI1270;
BASE_TYPE ZI515;
CV_SPEC ZI788;
TYPE ZI418;
SID_LIST_EXP ZI501;
EXP ZI1287;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI1270 = parse_type_token (id, args);
have_type_declaration = TYPE_DECL_NONE;
have_type_specifier = 1;
RESCAN_LEXER;
}
ADVANCE_LEXER;
{
(ZI515) = btype_none;
}
{
(ZI788) = cv_none;
}
{
(ZI418) = complete_pre_type ((ZI515), (ZI1270), (ZI788), 1);
have_type_specifier = 0;
}
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR504 (&ZI501);
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI1287) = make_func_cast_exp ((ZI418), (ZI501));
}
ZR1245 (ZI1287, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_const_Hcast:
{
TYPE ZI418;
EXP ZI1465;
int ZI555;
EXP ZI1276;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
ZR556 (&ZI418, &ZI1465, &ZI555);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* n is the number of type definitions in t */
(ZI1276) = make_const_cast_exp ((ZI418), (ZI1465), (ZI555));
}
ZR1245 (ZI1276, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_destructor_Hname:
{
IDENTIFIER ZI482;
IDENTIFIER ZI423;
EXP ZI1288;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
{
ZI482 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
{
(ZI423) = check_id (NULL_nspace, (ZI482), 0);
crt_id_qualifier = qual_none;
last_namespace = crt_namespace;
}
{
(ZI1288) = make_id_exp ((ZI423));
}
ZR1245 (ZI1288, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_discard:
{
EXP ZI1458;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
ZR585 (&ZI1458);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1457) = make_cast_exp (type_void, (ZI1458), 0);
}
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_dynamic_Hcast:
{
TYPE ZI418;
EXP ZI1468;
int ZI555;
EXP ZI1279;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
ZR556 (&ZI418, &ZI1468, &ZI555);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* n is the number of type definitions in t */
(ZI1279) = make_dynamic_cast_exp ((ZI418), (ZI1468), (ZI555));
}
ZR1245 (ZI1279, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_ellipsis_Hexp:
{
EXP ZI1282;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
{
(ZI1282) = make_ellipsis_exp ();
}
ZR1245 (ZI1282, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_full_Hname:
{
NAMESPACE ZI429;
{
ZI429 = crt_token->pp_data.ns;
}
ADVANCE_LEXER;
ZR1478 (&ZI429, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_identifier:
{
IDENTIFIER ZI1469;
{
ZI1469 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
ZR1474 (&ZI1469, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_inset_Hstart:
{
ADVANCE_LEXER;
ZR1444 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_minus_Hminus:
{
EXP ZI1460;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
ZR585 (&ZI1460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1457) = make_prefix_exp (lex_minus_Hminus, (ZI1460));
}
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_namespace_Hname:
{
IDENTIFIER ZI1473;
{
ZI1473 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
ZR1474 (&ZI1473, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_nested_Hname:
{
NAMESPACE ZI429;
{
ZI429 = crt_token->pp_data.ns;
}
ADVANCE_LEXER;
ZR1477 (&ZI429, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hround:
{
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
ZR1291 (&ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_plus_Hplus:
{
EXP ZI1459;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
ZR585 (&ZI1459);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1457) = make_prefix_exp (lex_plus_Hplus, (ZI1459));
}
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_reinterpret_Hcast:
{
TYPE ZI418;
EXP ZI1466;
int ZI555;
EXP ZI1277;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
ZR556 (&ZI418, &ZI1466, &ZI555);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* n is the number of type definitions in t */
(ZI1277) = make_reinterp_cast_exp ((ZI418), (ZI1466), (ZI555));
}
ZR1245 (ZI1277, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_semicolon:
{
ADVANCE_LEXER;
{
(ZI435) = NULL_exp;
}
}
break;
case lex_sizeof:
{
int ZI454;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
{
(ZI454) = lex_sizeof;
}
ZR597 (ZI454, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_star:
{
EXP ZI1461;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
ZR585 (&ZI1461);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1457) = make_indir_exp ((ZI1461));
}
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
IDENTIFIER ZI1475;
{
ZI1475 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
ZR1476 (&ZI1475, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_static_Hcast:
{
TYPE ZI418;
EXP ZI1467;
int ZI555;
EXP ZI1278;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
ZR556 (&ZI418, &ZI1467, &ZI555);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1278) = make_static_cast_exp ((ZI418), (ZI1467), (ZI555));
}
ZR1245 (ZI1278, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_template_Hid:
{
IDENTIFIER ZI482;
IDENTIFIER ZI423;
EXP ZI1288;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI482 = parse_id_template (id, args, 0);
crt_templ_qualifier = 1;
RESCAN_LEXER;
}
ADVANCE_LEXER;
{
(ZI423) = check_id (NULL_nspace, (ZI482), 0);
crt_id_qualifier = qual_none;
last_namespace = crt_namespace;
}
{
(ZI1288) = make_id_exp ((ZI423));
}
ZR1245 (ZI1288, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_template_Htype:
{
IDENTIFIER ZI464;
IDENTIFIER ZI423;
TYPE ZI1270;
BASE_TYPE ZI515;
CV_SPEC ZI788;
TYPE ZI418;
SID_LIST_EXP ZI501;
EXP ZI1286;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI464 = parse_type_template (id, args, 0);
crt_templ_qualifier = 1;
RESCAN_LEXER;
}
ADVANCE_LEXER;
{
(ZI423) = (ZI464);
crt_id_qualifier = qual_none;
last_namespace = crt_namespace;
}
{
MAKE_type_pre (cv_none, btype_alias, crt_id_qualifier, (ZI1270));
COPY_id (type_name ((ZI1270)), (ZI423));
have_type_specifier = 1;
}
{
(ZI515) = btype_none;
}
{
(ZI788) = cv_none;
}
{
(ZI418) = complete_pre_type ((ZI515), (ZI1270), (ZI788), 1);
have_type_specifier = 0;
}
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR504 (&ZI501);
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI1286) = make_func_cast_exp ((ZI418), (ZI501));
}
ZR1245 (ZI1286, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_this:
{
EXP ZI1281;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
{
(ZI1281) = make_this_exp ();
}
ZR1245 (ZI1281, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
IDENTIFIER ZI1471;
{
ZI1471 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
ZR1472 (&ZI1471, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_typeid:
{
int ZI454;
EXP ZI1275;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
{
(ZI454) = lex_typeid;
}
ZR557 (ZI454, &ZI1275);
ZR1245 (ZI1275, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_vtable:
{
int ZI454;
EXP ZI1274;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ADVANCE_LEXER;
{
(ZI454) = lex_vtable;
}
ZR557 (ZI454, &ZI1274);
ZR1245 (ZI1274, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_and_H1:
{
EXP ZI1462;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
{
{
switch (CURRENT_TERMINAL) {
case lex_and_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR585 (&ZI1462);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1457) = make_ref_exp ((ZI1462), 0);
}
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
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:
{
BASE_TYPE ZI515;
TYPE ZI1270;
CV_SPEC ZI788;
TYPE ZI418;
SID_LIST_EXP ZI501;
EXP ZI1285;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ZR513 (&ZI515);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1270) = NULL_type;
have_type_specifier = 1;
}
{
(ZI788) = cv_none;
}
{
(ZI418) = complete_pre_type ((ZI515), (ZI1270), (ZI788), 1);
have_type_specifier = 0;
}
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR504 (&ZI501);
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI1285) = make_func_cast_exp ((ZI418), (ZI501));
}
ZR1245 (ZI1285, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_open_Hbrace_H1:
{
ZR682 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_reachable: case lex_unreachable:
{
ZR780 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_case: case lex_default: case lex_fall:
{
ZR666 ();
ZR1445 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_set: case lex_unused:
{
EXP ZI1439;
EXP ZI497;
int ZI674;
ZR647 (&ZI1439);
ZR1441 (&ZI1439, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_do: case lex_for: case lex_while:
{
ZR742 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_break: case lex_continue: case lex_goto:
case lex_return:
{
ZR756 (&ZI435);
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:
case lex_false: case lex_true:
{
EXP ZI1280;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
ZR441 (&ZI1280);
ZR1245 (ZI1280, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_not_H1:
{
EXP ZI1463;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
{
{
switch (CURRENT_TERMINAL) {
case lex_not_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR585 (&ZI1463);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1457) = make_not_exp ((ZI1463));
}
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_operator:
{
IDENTIFIER ZI482;
IDENTIFIER ZI423;
EXP ZI1288;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
parse_operator (&ZI482);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI423) = check_id (NULL_nspace, (ZI482), 0);
crt_id_qualifier = qual_none;
last_namespace = crt_namespace;
}
{
(ZI1288) = make_id_exp ((ZI423));
}
ZR1245 (ZI1288, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_hash_Hif: case lex_if: case lex_switch:
{
ZR717 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_throw:
{
EXP ZI1292;
EXP ZI497;
int ZI674;
ZR639 (&ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_try:
{
ZR775 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_delete: case lex_new:
{
int ZI460;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
{
(ZI460) = 0;
}
ZR1435 (&ZI460, &ZI1457);
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_compl_H1: case lex_minus: case lex_plus:
case lex_abs:
{
int ZI454;
EXP ZI1464;
EXP ZI1457;
EXP ZI1456;
EXP ZI1455;
EXP ZI1454;
EXP ZI1453;
EXP ZI1452;
EXP ZI1451;
EXP ZI1450;
EXP ZI1449;
EXP ZI1448;
EXP ZI1447;
EXP ZI1446;
EXP ZI1268;
EXP ZI1292;
EXP ZI497;
int ZI674;
{
(ZI454) = crt_lex_token;
}
ZR600 ();
ZR585 (&ZI1464);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1457) = make_uminus_exp ((ZI454), (ZI1464));
}
ZR1241 (ZI1457, &ZI1456);
ZR1237 (ZI1456, &ZI1455);
ZR1233 (ZI1455, &ZI1454);
ZR1229 (ZI1454, &ZI1453);
ZR1225 (ZI1453, &ZI1452);
ZR1221 (ZI1452, &ZI1451);
ZR1217 (ZI1451, &ZI1450);
ZR1213 (ZI1450, &ZI1449);
ZR1209 (ZI1449, &ZI1448);
ZR1205 (ZI1448, &ZI1447);
ZR1201 (ZI1447, &ZI1446);
ZR1197 (ZI1446, &ZI1268);
ZR1269 (&ZI1268, &ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1237 (EXP ZI1235, EXP *ZO1236)
{
EXP ZI1236;
ZL2_1237:;
switch (CURRENT_TERMINAL) {
case lex_div:
{
EXP ZI460;
EXP ZI435;
ADVANCE_LEXER;
ZR605 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_mult_exp (lex_div, (ZI1235), (ZI460));
}
ZI1235 = ZI435;
goto ZL2_1237;
}
/*UNREACHED*/
case lex_rem:
{
EXP ZI460;
EXP ZI435;
ADVANCE_LEXER;
ZR605 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_rem_exp ((ZI1235), (ZI460));
}
ZI1235 = ZI435;
goto ZL2_1237;
}
/*UNREACHED*/
case lex_star:
{
EXP ZI460;
EXP ZI435;
ADVANCE_LEXER;
ZR605 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_mult_exp (lex_star, (ZI1235), (ZI460));
}
ZI1235 = ZI435;
goto ZL2_1237;
}
/*UNREACHED*/
default:
{
ZI1236 = ZI1235;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1236 = ZI1236;
}
void
ZR959 (TYPE *ZO1143)
{
TYPE ZI1143;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
{
ADVANCE_LEXER;
ZR1388 (&ZI1143);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_weak:
{
IDENTIFIER ZI423;
int ZI948;
TYPE ZI418;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI423) = NULL_id;
crt_id_qualifier = qual_none;
qual_namespace = NULL_nspace;
}
{
(ZI948) = 1;
}
{
func_type_defn (0);
begin_param ((ZI423));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR949 (ZI948, &ZI418);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
ZR1144 (ZI418, &ZI1143);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hsquare_H1:
{
EXP ZI435;
TYPE ZI418;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR958 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
NAT n = make_array_dim ((ZI435));
MAKE_type_array (cv_none, NULL_type, n, (ZI418));
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR1144 (ZI418, &ZI1143);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1143 = ZI1143;
}
void
ZR774 (EXP ZI497)
{
ZL2_774:;
switch (CURRENT_TERMINAL) {
case lex_catch:
{
ZR766 (ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
} else {
goto ZL2_774;
}
}
/*UNREACHED*/
case 358:
return;
default:
break;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR742 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_do:
{
unsigned ZI718;
int ZI674;
EXP ZI497;
EXP ZI719;
EXP ZI460;
EXP ZI743;
EXP ZI562;
ADVANCE_LEXER;
{
(ZI718) = crt_condition;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI497) = begin_do_stmt ();
}
{
(ZI719) = begin_compound_stmt (1);
}
ZR685 (ZI719, &ZI460);
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;
ZR495 (&ZI743);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI562) = bind_temporary ((ZI743));
}
{
unreached_prev = (ZI674);
}
{
(ZI435) = end_do_stmt ((ZI497), (ZI460), (ZI562));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
crt_condition = (ZI718);
}
{
unreached_fall = 1;
}
ZR422 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_for:
{
unsigned ZI718;
int ZI674;
EXP ZI724;
EXP ZI497;
EXP ZI744;
EXP ZI562;
EXP ZI745;
EXP ZI693;
EXP ZI460;
EXP ZI746;
EXP ZI747;
EXP ZI748;
EXP ZI463;
ADVANCE_LEXER;
{
(ZI718) = crt_condition;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
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;
{
(ZI724) = begin_for_stmt ();
}
ZR739 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI744) = init_for_stmt ((ZI724), &(ZI497));
}
ZR740 (&ZI562, &ZI745);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI693) = begin_compound_stmt (1);
}
ZR741 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI746) = cond_for_stmt ((ZI744), (ZI745), (ZI460));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI747) = inject_cond ((ZI693), (ZI497));
}
{
(ZI748) = inject_cond ((ZI747), (ZI562));
}
{
mark_compound_stmt ((ZI748));
}
ZR685 (ZI748, &ZI463);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_prev = (ZI674);
}
{
(ZI435) = end_for_stmt ((ZI746), (ZI463));
}
{
crt_condition = (ZI718);
}
{
unreached_fall = 1;
}
{
RESCAN_LEXER;
}
}
break;
case lex_while:
{
unsigned ZI718;
int ZI674;
EXP ZI743;
EXP ZI562;
EXP ZI497;
EXP ZI719;
EXP ZI720;
EXP ZI460;
ADVANCE_LEXER;
{
(ZI718) = crt_condition;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
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;
ZR716 (&ZI743);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI562) = bind_temporary ((ZI743));
}
{
(ZI497) = begin_while_stmt ((ZI562));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI719) = begin_compound_stmt (1);
}
{
(ZI720) = inject_cond ((ZI719), (ZI562));
}
ZR685 (ZI720, &ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_prev = (ZI674);
}
{
(ZI435) = end_while_stmt ((ZI497), (ZI460));
}
{
crt_condition = (ZI718);
}
{
unreached_fall = 1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR643 (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
ZR1241 (EXP ZI1239, EXP *ZO1240)
{
EXP ZI1240;
ZL2_1241:;
switch (CURRENT_TERMINAL) {
case lex_arrow_Hstar:
{
EXP ZI460;
EXP ZI435;
ADVANCE_LEXER;
{
in_ptr_mem_selector++;
}
ZR585 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_member_exp (lex_arrow_Hstar, (ZI1239), (ZI460));
in_ptr_mem_selector--;
}
ZI1239 = ZI435;
goto ZL2_1241;
}
/*UNREACHED*/
case lex_dot_Hstar:
{
EXP ZI460;
EXP ZI435;
ADVANCE_LEXER;
{
in_ptr_mem_selector++;
}
ZR585 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_member_exp (lex_dot_Hstar, (ZI1239), (ZI460));
in_ptr_mem_selector--;
}
ZI1239 = ZI435;
goto ZL2_1241;
}
/*UNREACHED*/
default:
{
ZI1240 = ZI1239;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1240 = ZI1240;
}
void
ZR673 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_inset_Hstart:
{
ADVANCE_LEXER;
ZR1444 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_semicolon:
{
ADVANCE_LEXER;
{
(ZI435) = NULL_exp;
}
}
break;
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_destructor_Hname: case lex_template_Hid: case lex_template_Htype:
case lex_nested_Hname: case lex_full_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_Htype: 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_colon_Hcolon: case lex_abs:
case lex_char: case lex_double: case lex_float:
case lex_int: case lex_long: case lex_short:
case lex_signed: case lex_sizeof: case lex_unsigned:
case lex_void: case lex_bool: case lex_const_Hcast:
case lex_delete: case lex_dynamic_Hcast: case lex_false:
case lex_new: case lex_operator: case lex_reinterpret_Hcast:
case lex_static_Hcast: case lex_this: case lex_throw:
case lex_true: case lex_typeid: case lex_wchar_Ht:
case lex_alignof: case lex_bottom: case lex_discard:
case lex_ellipsis_Hexp: case lex_ptrdiff_Ht: case lex_size_Ht:
case lex_vtable:
{
EXP ZI1292;
EXP ZI497;
int ZI674;
ZR500 (&ZI1292);
ZR1294 (&ZI1292, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_set: case lex_unused:
{
EXP ZI1439;
EXP ZI497;
int ZI674;
ZR647 (&ZI1439);
ZR1441 (&ZI1439, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_exp_stmt ((ZI497));
}
{
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:;
*ZO435 = ZI435;
}
void
ZR1082 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_namespace:
{
ADVANCE_LEXER;
ZR1263 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_using:
{
ADVANCE_LEXER;
ZR1264 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_asm:
{
ZR1061 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1130 (OFFSET ZI460, TYPE ZI578, OFFSET *ZO497, TYPE *ZO418)
{
OFFSET ZI497;
TYPE ZI418;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
NAMESPACE ZI429;
IDENTIFIER ZI423;
{
(ZI429) = offset_nspace ((ZI578));
}
{
RESCAN_LEXER;
}
ZR521 (ZI429, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
OFFSET off = offset_member ((ZI578), (ZI423), &(ZI418), (ZI429), 1);
(ZI497) = offset_add ((ZI460), off);
}
{
RESCAN_LEXER;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO497 = ZI497;
*ZO418 = ZI418;
}
void
ZR512 (IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
switch (CURRENT_TERMINAL) {
case lex_template_Htype:
{
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI423 = parse_type_template (id, args, 0);
crt_templ_qualifier = 1;
RESCAN_LEXER;
}
ADVANCE_LEXER;
}
break;
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname:
{
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI423 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_namespace_Hname:
{
{
ZI423 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI423 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI423 = 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:;
*ZO423 = ZI423;
}
void
ZR766 (EXP ZI497)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI562;
int ZI555;
IDENTIFIER ZI463;
EXP ZI460;
EXP ZI767;
EXP ZI768;
EXP ZI769;
EXP ZI770;
EXP ZI771;
EXP ZI772;
EXP ZI773;
switch (CURRENT_TERMINAL) {
case lex_catch:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI562) = begin_compound_stmt (1);
}
{
inject_try_stmt ((ZI497));
}
{
(ZI555) = no_type_defns;
}
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR765 (ZI555, &ZI463);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI460) = begin_catch_stmt ((ZI497), (ZI463));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
COPY_int (exp_sequence_block ((ZI562)), 2);
}
{
(ZI767) = NULL_exp;
}
{
(ZI768) = (ZI767);
in_declaration--;
}
{
(ZI769) = add_compound_stmt ((ZI562), (ZI768));
}
{
MAKE_exp_thrown (type_void, 1, (ZI770));
}
{
(ZI771) = add_compound_stmt ((ZI769), (ZI770));
}
ZR680 (ZI771, &ZI772);
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI773) = end_compound_stmt ((ZI772));
}
{
IGNORE end_catch_stmt ((ZI460), (ZI773));
}
{
RESCAN_LEXER;
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR1035 (void)
{
switch (CURRENT_TERMINAL) {
case lex_hash_Hpragma:
{
ADVANCE_LEXER;
}
break;
case lex_hash_Hif:
{
EXP ZI501;
ZR1034 (&ZI501);
{
switch (CURRENT_TERMINAL) {
case lex_hash_Helse:
{
ADVANCE_LEXER;
{
crt_hash_cond = make_else_cond (crt_hash_cond);
}
{
target_decl (lex_else, NULL_exp);
}
ZR1033 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
break;
}
}
{
crt_hash_cond = (ZI501);
}
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
ZR1370 (DECL_SPEC *ZI693, TYPE *ZI501, BASE_TYPE *ZI484, ACCESS_LIST *ZI674, int *ZI724, IDENTIFIER *ZI1369, IDENTIFIER *ZO463)
{
IDENTIFIER ZI463;
switch (CURRENT_TERMINAL) {
case lex_colon:
{
QUALIFIER ZI459;
int ZI460;
EXP ZI562;
TYPE ZI418;
{
if (!IS_NULL_type ((*ZI501))) template_decl ((*ZI501));
}
{
begin_declarator ((*ZI1369), crt_id_qualifier, qual_namespace, 1);
}
{
(ZI459) = crt_id_qualifier;
(ZI460) = crt_templ_qualifier;
}
ADVANCE_LEXER;
ZR655 (&ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
crt_id_qualifier = (ZI459);
crt_templ_qualifier = (ZI460);
}
{
/* Check for anonymous bitfields */
HASHID nm = DEREF_hashid (id_name ((*ZI1369)));
int z = IS_hashid_anon (nm);
(ZI418) = make_bitfield_type ((*ZI501), (*ZI484), (ZI562), z);
}
{
IDENTIFIER id = make_member_decl ((*ZI693), (ZI418), (*ZI1369), 0);
int def = init_member (id, NULL_exp);
if (do_dump) dump_declare (id, &decl_loc, def);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
is_function_next = 0;
(ZI463) = id;
}
{
IGNORE clear_access ((ZI463), &(*ZI674));
}
{
if (crt_access_list.pending) {
IGNORE report_access ((ZI463));
}
}
}
break;
default:
{
TYPE ZI1359;
int ZI1360;
TYPE ZI1352;
IDENTIFIER ZI423;
int ZI562;
TYPE ZI418;
int ZI1090;
EXP ZI435;
{
(ZI1359) = NULL_type;
}
{
(ZI1360) = 0;
}
{
begin_declarator ((*ZI1369), crt_id_qualifier, qual_namespace, 1);
}
ZR1182 (ZI1359, *ZI1369, ZI1360, &ZI1352, &ZI423, &ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (!IS_NULL_type ((*ZI501))) template_decl ((*ZI501));
}
{
(ZI418) = (IS_NULL_type ((ZI1352)) ? (*ZI501): inject_pre_type ((ZI1352), (*ZI501), 1));
}
{
if ((ZI562)) report (crt_loc, ERR_dcl_init_bad ());
}
{
DECL_SPEC ds = (*ZI693);
if (type_tag ((ZI418)) == type_func_tag) {
/* Look ahead for function definitions */
int def = predict_func_defn ();
if (def & !have_func_declarator) adjust_param ((ZI418));
if (ds & dspec_friend) {
(ZI463) = make_friend_decl (ds, (ZI418), (ZI423), def, 1);
(ZI1090) = 1;
} else {
(ZI463) = make_func_mem_decl (ds, (ZI418), (ZI423), def);
(ZI1090) = 0;
}
is_function_next = def;
} else {
int f = ((*ZI724) && (crt_lex_token == lex_semicolon));
(ZI463) = make_member_decl (ds, (ZI418), (ZI423), f);
(ZI1090) = 0;
is_function_next = 0;
}
if (IS_id_type_alias ((ZI463))) {
BASE_TYPE bs = DEREF_btype (id_type_alias_rep ((ZI463)));
bs |= (*ZI484);
COPY_btype (id_type_alias_rep ((ZI463)), bs);
}
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
{
IGNORE clear_access ((ZI463), &(*ZI674));
}
{
if (crt_access_list.pending) {
IGNORE report_access ((ZI463));
}
}
ZR1088 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
int def = ((ZI1090) ? init_object ((ZI463), (ZI435)) : init_member ((ZI463), (ZI435)));
if (do_dump) dump_declare ((ZI463), &decl_loc, def);
}
{
if (crt_access_list.pending) {
IGNORE report_access ((ZI463));
}
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO463 = ZI463;
}
void
ZR605 (EXP *ZO1240)
{
EXP ZI1240;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI435;
ZR585 (&ZI435);
ZR1241 (ZI435, &ZI1240);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1240 = ZI1240;
}
void
ZR479 (NAMESPACE ZI429, int *ZO418)
{
int ZI418;
switch (CURRENT_TERMINAL) {
default:
{
{
(ZI418) = 0;
}
}
break;
case lex_template:
{
{
rescan_template ((ZI429));
}
ADVANCE_LEXER;
{
(ZI418) = 1;
}
}
break;
case 358:
return;
}
*ZO418 = ZI418;
}
void
ZR832 (DECL_SPEC *ZO497)
{
DECL_SPEC ZI497;
switch (CURRENT_TERMINAL) {
case lex_private:
{
ADVANCE_LEXER;
{
(ZI497) = dspec_private;
}
}
break;
case lex_protected:
{
ADVANCE_LEXER;
{
(ZI497) = dspec_protected;
}
}
break;
case lex_public:
{
ADVANCE_LEXER;
{
(ZI497) = dspec_public;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO497 = ZI497;
}
void
ZR1245 (EXP ZI1243, EXP *ZO1244)
{
EXP ZI1244;
ZL2_1245:;
switch (CURRENT_TERMINAL) {
case lex_minus_Hminus:
{
EXP ZI435;
ADVANCE_LEXER;
{
(ZI435) = make_postfix_exp (lex_minus_Hminus, (ZI1243));
}
ZI1243 = ZI435;
goto ZL2_1245;
}
/*UNREACHED*/
case lex_open_Hround:
{
SID_LIST_EXP ZI501;
EXP ZI435;
ADVANCE_LEXER;
ZR504 (&ZI501);
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI435) = make_func_exp ((ZI1243), (ZI501), 0);
}
ZI1243 = ZI435;
goto ZL2_1245;
}
/*UNREACHED*/
case lex_plus_Hplus:
{
EXP ZI435;
ADVANCE_LEXER;
{
(ZI435) = make_postfix_exp (lex_plus_Hplus, (ZI1243));
}
ZI1243 = ZI435;
goto ZL2_1245;
}
/*UNREACHED*/
case lex_open_Hsquare_H1:
{
EXP ZI460;
EXP ZI435;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR495 (&ZI460);
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI435) = make_index_exp ((ZI1243), (ZI460));
}
ZI1243 = ZI435;
goto ZL2_1245;
}
/*UNREACHED*/
case lex_arrow:
{
EXP ZI460;
TYPE ZI418;
NAMESPACE ZI429;
int ZI484;
IDENTIFIER ZI423;
EXP ZI435;
{
(ZI460) = begin_field_exp (lex_arrow, (ZI1243), &(ZI418), &(ZI429));
}
ADVANCE_LEXER;
ZR479 (ZI429, &ZI484);
ZR521 (ZI429, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = end_field_exp (lex_arrow, (ZI460), (ZI418), (ZI429), (ZI423), (ZI484));
}
{
RESCAN_LEXER;
}
ZI1243 = ZI435;
goto ZL2_1245;
}
/*UNREACHED*/
case lex_dot:
{
EXP ZI460;
TYPE ZI418;
NAMESPACE ZI429;
int ZI484;
IDENTIFIER ZI423;
EXP ZI435;
{
(ZI460) = begin_field_exp (lex_dot, (ZI1243), &(ZI418), &(ZI429));
}
ADVANCE_LEXER;
ZR479 (ZI429, &ZI484);
ZR521 (ZI429, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = end_field_exp (lex_dot, (ZI460), (ZI418), (ZI429), (ZI423), (ZI484));
}
{
RESCAN_LEXER;
}
ZI1243 = ZI435;
goto ZL2_1245;
}
/*UNREACHED*/
default:
{
ZI1244 = ZI1243;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1244 = ZI1244;
}
void
ZR1057 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
switch (CURRENT_TERMINAL) {
case lex_using:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR1262 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR1373 (DECL_SPEC *ZI693, TYPE *ZI501, BASE_TYPE *ZI484, ACCESS_LIST *ZI674, int *ZI724, IDENTIFIER *ZI1372, IDENTIFIER *ZO463)
{
IDENTIFIER ZI463;
switch (CURRENT_TERMINAL) {
default:
{
IDENTIFIER ZI1358;
TYPE ZI1359;
int ZI1360;
TYPE ZI1352;
IDENTIFIER ZI423;
int ZI562;
TYPE ZI418;
int ZI1090;
EXP ZI435;
{
(ZI1358) = constr_name (last_namespace, (*ZI1372));
}
{
(ZI1359) = NULL_type;
}
{
(ZI1360) = 0;
}
{
begin_declarator ((ZI1358), crt_id_qualifier, qual_namespace, 1);
}
ZR1182 (ZI1359, ZI1358, ZI1360, &ZI1352, &ZI423, &ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (!IS_NULL_type ((*ZI501))) template_decl ((*ZI501));
}
{
(ZI418) = (IS_NULL_type ((ZI1352)) ? (*ZI501): inject_pre_type ((ZI1352), (*ZI501), 1));
}
{
if ((ZI562)) report (crt_loc, ERR_dcl_init_bad ());
}
{
DECL_SPEC ds = (*ZI693);
if (type_tag ((ZI418)) == type_func_tag) {
/* Look ahead for function definitions */
int def = predict_func_defn ();
if (def & !have_func_declarator) adjust_param ((ZI418));
if (ds & dspec_friend) {
(ZI463) = make_friend_decl (ds, (ZI418), (ZI423), def, 1);
(ZI1090) = 1;
} else {
(ZI463) = make_func_mem_decl (ds, (ZI418), (ZI423), def);
(ZI1090) = 0;
}
is_function_next = def;
} else {
int f = ((*ZI724) && (crt_lex_token == lex_semicolon));
(ZI463) = make_member_decl (ds, (ZI418), (ZI423), f);
(ZI1090) = 0;
is_function_next = 0;
}
if (IS_id_type_alias ((ZI463))) {
BASE_TYPE bs = DEREF_btype (id_type_alias_rep ((ZI463)));
bs |= (*ZI484);
COPY_btype (id_type_alias_rep ((ZI463)), bs);
}
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
{
IGNORE clear_access ((ZI463), &(*ZI674));
}
{
if (crt_access_list.pending) {
IGNORE report_access ((ZI463));
}
}
ZR1088 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
int def = ((ZI1090) ? init_object ((ZI463), (ZI435)) : init_member ((ZI463), (ZI435)));
if (do_dump) dump_declare ((ZI463), &decl_loc, def);
}
{
if (crt_access_list.pending) {
IGNORE report_access ((ZI463));
}
}
}
break;
case lex_colon:
{
QUALIFIER ZI459;
int ZI460;
EXP ZI562;
TYPE ZI418;
{
if (!IS_NULL_type ((*ZI501))) template_decl ((*ZI501));
}
{
begin_declarator ((*ZI1372), crt_id_qualifier, qual_namespace, 1);
}
{
(ZI459) = crt_id_qualifier;
(ZI460) = crt_templ_qualifier;
}
ADVANCE_LEXER;
ZR655 (&ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
crt_id_qualifier = (ZI459);
crt_templ_qualifier = (ZI460);
}
{
/* Check for anonymous bitfields */
HASHID nm = DEREF_hashid (id_name ((*ZI1372)));
int z = IS_hashid_anon (nm);
(ZI418) = make_bitfield_type ((*ZI501), (*ZI484), (ZI562), z);
}
{
IDENTIFIER id = make_member_decl ((*ZI693), (ZI418), (*ZI1372), 0);
int def = init_member (id, NULL_exp);
if (do_dump) dump_declare (id, &decl_loc, def);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
is_function_next = 0;
(ZI463) = id;
}
{
IGNORE clear_access ((ZI463), &(*ZI674));
}
{
if (crt_access_list.pending) {
IGNORE report_access ((ZI463));
}
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO463 = ZI463;
}
void
ZR1376 (TYPE *ZO1164, IDENTIFIER *ZO1165)
{
TYPE ZI1164;
IDENTIFIER ZI1165;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
IDENTIFIER ZI1377;
TYPE ZI1378;
TYPE ZI418;
IDENTIFIER ZI423;
{
/* Resolve parameter declarators from type names */
(ZI0) = predict_param ();
}
if (!ZI0)
goto ZL2;
ZR947 (&ZI1377);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1378) = NULL_type;
}
{
IDENTIFIER pid = underlying_id ((ZI1377));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR1166 (ZI1378, ZI1377, &ZI418, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (IS_NULL_type ((ZI418))) {
report (crt_loc, ERR_dcl_meaning_paren ());
}
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR1166 (ZI418, ZI423, &ZI1164, &ZI1165);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
{
TYPE ZI418;
IDENTIFIER ZI423;
ADVANCE_LEXER;
ZR1376 (&ZI418, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (IS_NULL_type ((ZI418))) {
report (crt_loc, ERR_dcl_meaning_paren ());
}
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR1166 (ZI418, ZI423, &ZI1164, &ZI1165);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_weak:
{
IDENTIFIER ZI1375;
int ZI948;
TYPE ZI1381;
IDENTIFIER ZI1382;
TYPE ZI418;
IDENTIFIER ZI423;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI1375) = NULL_id;
crt_id_qualifier = qual_none;
qual_namespace = NULL_nspace;
}
{
(ZI948) = 1;
}
{
func_type_defn (0);
begin_param ((ZI1375));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR949 (ZI948, &ZI1381);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
{
HASHID nm = lookup_anon ();
(ZI1382) = DEREF_id (hashid_id (nm));
crt_id_qualifier = qual_none;
qual_namespace = NULL_nspace;
}
{
IDENTIFIER pid = underlying_id ((ZI1382));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR1166 (ZI1381, ZI1382, &ZI418, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (IS_NULL_type ((ZI418))) {
report (crt_loc, ERR_dcl_meaning_paren ());
}
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR1166 (ZI418, ZI423, &ZI1164, &ZI1165);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hsquare_H1:
{
EXP ZI435;
TYPE ZI1379;
IDENTIFIER ZI1380;
TYPE ZI418;
IDENTIFIER ZI423;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR958 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
NAT n = make_array_dim ((ZI435));
MAKE_type_array (cv_none, NULL_type, n, (ZI1379));
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
HASHID nm = lookup_anon ();
(ZI1380) = DEREF_id (hashid_id (nm));
crt_id_qualifier = qual_none;
qual_namespace = NULL_nspace;
}
{
IDENTIFIER pid = underlying_id ((ZI1380));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR1166 (ZI1379, ZI1380, &ZI418, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (IS_NULL_type ((ZI418))) {
report (crt_loc, ERR_dcl_meaning_paren ());
}
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR1166 (ZI418, ZI423, &ZI1164, &ZI1165);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_nested_Hname_Hstar: case lex_full_Hname_Hstar: case lex_and_H1:
case lex_star:
{
TYPE ZI501;
TYPE ZI484;
IDENTIFIER ZI423;
TYPE ZI418;
ZR931 (&ZI501);
ZR964 (&ZI484, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 0));
}
{
if (IS_NULL_type ((ZI418))) {
report (crt_loc, ERR_dcl_meaning_paren ());
}
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR1166 (ZI418, ZI423, &ZI1164, &ZI1165);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_type_Hname: case lex_template_Htype: case lex_nested_Hname:
case lex_full_Hname: case lex_complex_Htype: case lex_close_Hround:
case lex_ellipsis: case lex_colon_Hcolon: 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_class:
case lex_explicit: case lex_friend: case lex_inline:
case lex_mutable: case lex_typename: case lex_virtual:
case lex_wchar_Ht: case lex_bottom: case lex_overload:
case lex_ptrdiff_Ht: case lex_size_Ht:
{
IDENTIFIER ZI1374;
int ZI948;
TYPE ZI418;
IDENTIFIER ZI423;
{
(ZI1374) = NULL_id;
crt_id_qualifier = qual_none;
qual_namespace = NULL_nspace;
}
{
(ZI948) = 0;
}
{
func_type_defn (0);
begin_param ((ZI1374));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR949 (ZI948, &ZI418);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
{
HASHID nm = lookup_anon ();
(ZI423) = DEREF_id (hashid_id (nm));
crt_id_qualifier = qual_none;
qual_namespace = NULL_nspace;
}
{
IDENTIFIER pid = underlying_id ((ZI423));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR1166 (ZI418, ZI423, &ZI1164, &ZI1165);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1164 = ZI1164;
*ZO1165 = ZI1165;
}
/* END OF FILE */
syntax highlighted by Code2HTML, v. 0.9.1