/*
* 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
ZR572 (TYPE *ZO418, int *ZO555)
{
TYPE ZI418;
int ZI555;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
int ZI558;
BASE_TYPE ZI515;
TYPE ZI501;
CV_SPEC ZI788;
TYPE ZI578;
TYPE ZI484;
{
(ZI558) = no_type_defns;
}
ZR878 (&ZI515, &ZI501, &ZI788);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI578) = complete_pre_type ((ZI515), (ZI501), (ZI788), 1);
have_type_specifier = 0;
}
ZR996 (&ZI484);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI418) = (IS_NULL_type ((ZI484)) ? (ZI578): inject_pre_type ((ZI484), (ZI578), 1));
}
{
(ZI555) = no_type_defns - (ZI558);
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO418 = ZI418;
*ZO555 = ZI555;
}
void
ZR626 (EXP *ZO1212)
{
EXP ZI1212;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI435;
ZR624 (&ZI435);
ZR1213 (ZI435, &ZI1212);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1212 = ZI1212;
}
void
ZR1330 (TYPE *ZI578, BASE_TYPE *ZO515, TYPE *ZO418, CV_SPEC *ZO788)
{
BASE_TYPE ZI515;
TYPE ZI418;
CV_SPEC ZI788;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
IDENTIFIER ZI423;
QUALIFIER ZI861;
int ZI459;
IDENTIFIER ZI501;
IDENTIFIER ZI435;
{
/* Resolve enum-specifiers from elaborated-type-specifiers */
(ZI0) = predict_class (0);
}
if (!ZI0)
goto ZL2;
{
crt_templ_qualifier = 0;
}
ZR874 (&ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI861) = crt_id_qualifier;
(ZI459) = crt_templ_qualifier;
}
{
IDENTIFIER id = constr_name (last_namespace, (ZI423));
(ZI501) = begin_enum_defn (id, (*ZI578));
no_type_defns++;
}
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname:
{
ZR871 (ZI501);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
break;
}
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
if (crt_access_list.pending) {
IGNORE report_access (crt_func_id);
}
}
{
(ZI435) = end_enum_defn ((ZI501));
}
{
crt_id_qualifier = (ZI861);
crt_templ_qualifier = (ZI459);
}
{
MAKE_type_pre (cv_none, btype_alias, crt_id_qualifier, (ZI418));
COPY_id (type_name ((ZI418)), (ZI435));
have_type_specifier = 1;
}
{
(ZI515) = btype_none;
}
{
(ZI788) = cv_none;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname: case lex_template_Htype: case lex_nested_Hname:
case lex_full_Hname: case lex_colon_Hcolon:
{
BASE_TYPE ZI821;
NAMESPACE ZI429;
IDENTIFIER ZI825;
IDENTIFIER ZI423;
{
(ZI821) = btype_enum;
}
{
crt_templ_qualifier = 0;
}
ZR432 (&ZI429);
ZR512 (&ZI825);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI423) = check_id ((ZI429), (ZI825), 0);
last_namespace = (ZI429);
}
{
MAKE_type_pre (cv_none, (ZI821), crt_id_qualifier, (ZI418));
COPY_id (type_name ((ZI418)), (ZI423));
if (have_type_declaration == TYPE_DECL_NONE) {
have_type_declaration = TYPE_DECL_ELABORATE;
}
have_type_specifier = 1;
}
{
(ZI515) = btype_none;
}
{
(ZI788) = cv_none;
}
}
break;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO515 = ZI515;
*ZO418 = ZI418;
*ZO788 = ZI788;
}
void
parse_exp (EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR500 (&ZI435);
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;
}
{
(ZI435) = NULL_exp;
}
}
ZL0:;
*ZO435 = ZI435;
}
void
ZR1331 (int *ZO418)
{
int ZI418;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname: case lex_template_Htype: case lex_nested_Hname:
case lex_full_Hname: case lex_colon_Hcolon: case lex_private:
case lex_protected: case lex_public: case lex_virtual:
{
ZR850 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI418) = 1;
}
}
break;
default:
{
{
(ZI418) = 0;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO418 = ZI418;
}
void
ZR691 (TYPE ZI418, DECL_SPEC ZI693, EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI1253;
TYPE ZI1254;
CV_SPEC ZI1255;
DECL_SPEC ZI1256;
BASE_TYPE ZI515;
TYPE ZI880;
CV_SPEC ZI881;
DECL_SPEC ZI914;
DECL_SPEC ZI916;
{
/* Resolve declaration-specifiers from other declarators */
(ZI0) = predict_dspec (0);
}
if (!ZI0)
goto ZL2;
ZR911 (ZI418, &ZI1253, &ZI1254, &ZI1255, &ZI1256);
ZR922 (&ZI418, &ZI1253, &ZI1254, &ZI1255, &ZI1256, &ZI515, &ZI880, &ZI881, &ZI914);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* Combine two declaration specifiers */
DECL_SPEC d = (((ZI693) & (ZI914)) & dspec_duplicate);
if (d) report (crt_loc, ERR_dcl_spec_dup (d));
(ZI916) = ((ZI693) | (ZI914));
}
ZR1257 (&ZI418, &ZI515, &ZI880, &ZI881, &ZI916);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = NULL_exp;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_extern:
{
ZR1067 (ZI418, ZI693, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_export: case lex_template:
{
ZR1077 (ZI418, ZI693, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname: case lex_destructor_Hname: case lex_template_Hid:
case lex_template_Htype: case lex_nested_Hname: case lex_full_Hname:
case lex_nested_Hname_Hstar: case lex_full_Hname_Hstar: case lex_and_H1:
case lex_open_Hround: case lex_star: case lex_colon_Hcolon:
case lex_operator:
{
BASE_TYPE ZI515;
TYPE ZI880;
CV_SPEC ZI881;
DECL_SPEC ZI914;
DECL_SPEC ZI916;
TYPE ZI884;
DECL_SPEC ZI1078;
TYPE ZI1079;
ACCESS_LIST ZI674;
TYPE ZI578;
IDENTIFIER ZI423;
int ZI562;
IDENTIFIER ZI463;
{
(ZI515) = btype_none;
}
{
(ZI880) = NULL_type;
}
{
(ZI881) = cv_none;
}
{
(ZI914) = dspec_none;
}
{
/* Combine two declaration specifiers */
DECL_SPEC d = (((ZI693) & (ZI914)) & dspec_duplicate);
if (d) report (crt_loc, ERR_dcl_spec_dup (d));
(ZI916) = ((ZI693) | (ZI914));
}
{
/* Complete a declaration specifier and a type */
(ZI1078) = complete_dspec ((ZI916), (ZI515), (ZI880), (ZI881));
(ZI884) = complete_pre_type ((ZI515), (ZI880), (ZI881), 0);
have_type_specifier = 0;
}
{
(ZI1079) = (IS_NULL_type ((ZI418)) ? (ZI884): inject_pre_type ((ZI418), (ZI884), 1));
}
{
save_access (&(ZI674));
}
{
crt_templ_qualifier = 0;
}
ZR955 (ZI1079, &ZI578, &ZI423, &ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (type_tag ((ZI578)) == type_func_tag) {
/* Look ahead for function definitions */
int def = predict_func_defn ();
if (def & !have_func_declarator) adjust_param ((ZI578));
(ZI463) = make_func_decl ((ZI1078), (ZI578), (ZI423), def);
is_function_next = def;
} else {
int def = predict_obj_defn ();
(ZI463) = make_object_decl ((ZI1078), (ZI578), (ZI423), def);
is_function_next = 0;
}
if (IS_id_type_alias ((ZI463))) {
BASE_TYPE bs = DEREF_btype (id_type_alias_rep ((ZI463)));
bs |= (ZI515);
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));
}
}
ZR1080 (&ZI515, &ZI1078, &ZI1079, &ZI674, &ZI562, &ZI463);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = NULL_exp;
}
}
break;
case lex_asm: case lex_namespace: case lex_using:
{
{
if (!IS_NULL_type ((ZI418))) report (crt_loc, ERR_temp_decl_bad ());
UNUSED ((ZI693));
}
ZR1082 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1332 (int *ZO849)
{
int ZI849;
switch (CURRENT_TERMINAL) {
case lex_virtual:
{
ADVANCE_LEXER;
{
(ZI849) = 1;
}
}
break;
default:
{
{
(ZI849) = 0;
}
}
break;
case 358:
return;
}
*ZO849 = ZI849;
}
void
ZR1205 (EXP ZI1203, EXP *ZO1204)
{
EXP ZI1204;
ZL2_1205:;
switch (CURRENT_TERMINAL) {
case lex_or_H1:
{
EXP ZI460;
EXP ZI435;
{
{
switch (CURRENT_TERMINAL) {
case lex_or_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR628 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_or_exp ((ZI1203), (ZI460));
}
ZI1203 = ZI435;
goto ZL2_1205;
}
/*UNREACHED*/
default:
{
ZI1204 = ZI1203;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1204 = ZI1204;
}
void
ZR639 (EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI497;
switch (CURRENT_TERMINAL) {
case lex_throw:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
{
TYPE ZI418;
int ZI555;
{
/* Resolve type-ids from expressions */
(ZI0) = predict_typeid (0);
}
if (!ZI0)
goto ZL3;
ZR552 (&ZI418, &ZI555);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI497) = make_throw_arg ((ZI418), (ZI555));
}
goto ZL2;
}
/*UNREACHED*/
ZL3:;
switch (CURRENT_TERMINAL) {
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:
{
ZR500 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI497) = NULL_exp;
}
}
break;
}
ZL2:;
}
{
(ZI435) = make_throw_exp ((ZI497), 1);
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1333 (DECL_SPEC *ZO497)
{
DECL_SPEC ZI497;
switch (CURRENT_TERMINAL) {
case lex_private: case lex_protected: case lex_public:
{
ZR832 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI497) = dspec_none;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO497 = ZI497;
}
void
ZR1080 (BASE_TYPE *ZI515, DECL_SPEC *ZI1078, TYPE *ZI1079, ACCESS_LIST *ZI674, int *ZI562, IDENTIFIER *ZI463)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
int ZI460;
EXP ZI435;
{
/* Resolve function definitions from other declarations */
(ZI0) = is_function_next;
}
if (!ZI0)
goto ZL2;
{
if ((*ZI562)) report (crt_loc, ERR_dcl_init_bad ());
}
{
free_access (&(*ZI674));
}
{
(ZI460) = in_class_defn;
in_class_defn = 0;
in_function_defn++;
really_in_function_defn++;
begin_function ((*ZI463));
}
ZR1029 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
IGNORE end_function ((*ZI463), (ZI435));
in_class_defn = (ZI460);
in_function_defn--;
really_in_function_defn--;
}
{
end_declarator ((*ZI463), 1);
}
{
RESCAN_LEXER;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
{
SID_LIST_EXP ZI501;
EXP ZI435;
{
(ZI0) = (*ZI562);
}
if (!ZI0)
goto ZL3;
{
if (crt_lex_token == lex_open_Hinit) {
crt_lex_token = lex_open_Hround;
} else {
RESCAN_LEXER;
}
}
ZR1007 (*ZI463, &ZI501);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
MAKE_exp_initialiser (type_void, (ZI501), NULL_list (OFFSET), 0, 0, 0, (ZI435));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
int def = init_object ((*ZI463), (ZI435));
if (do_dump) dump_declare ((*ZI463), &decl_loc, def);
}
{
if (crt_access_list.pending) {
IGNORE report_access ((*ZI463));
}
}
{
end_declarator ((*ZI463), 1);
}
ZR1081 (ZI515, ZI1078, ZI1079, ZI674);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
free_access (&(*ZI674));
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
goto ZL0;
}
/*UNREACHED*/
ZL3:;
switch (CURRENT_TERMINAL) {
case lex_assign:
{
EXP ZI435;
ADVANCE_LEXER;
ZR1003 (*ZI463, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
int def = init_object ((*ZI463), (ZI435));
if (do_dump) dump_declare ((*ZI463), &decl_loc, def);
}
{
if (crt_access_list.pending) {
IGNORE report_access ((*ZI463));
}
}
{
end_declarator ((*ZI463), 1);
}
ZR1081 (ZI515, ZI1078, ZI1079, ZI674);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
free_access (&(*ZI674));
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_comma: case lex_semicolon:
{
EXP ZI435;
{
(ZI435) = NULL_exp;
}
{
int def = init_object ((*ZI463), (ZI435));
if (do_dump) dump_declare ((*ZI463), &decl_loc, def);
}
{
if (crt_access_list.pending) {
IGNORE report_access ((*ZI463));
}
}
{
end_declarator ((*ZI463), 1);
}
ZR1081 (ZI515, ZI1078, ZI1079, ZI674);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
free_access (&(*ZI674));
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
}
void
parse_stmt (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:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI435) = NULL_exp;
}
}
ZL0:;
*ZO435 = ZI435;
}
void
ZR1092 (DECL_SPEC ZI693, TYPE ZI501, BASE_TYPE ZI484, ACCESS_LIST ZI674, int ZI724)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
ZL2_1092:;
{
IDENTIFIER ZI463;
ZR1089 (ZI693, ZI501, ZI484, ZI674, ZI724, &ZI463);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
end_declarator ((ZI463), 1);
}
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
int ZI555;
ADVANCE_LEXER;
{
(ZI555) = 0;
}
{
crt_templ_qualifier = 0;
}
ZI724 = ZI555;
goto ZL2_1092;
}
/*UNREACHED*/
default:
break;
}
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR1081 (BASE_TYPE *ZI515, DECL_SPEC *ZI1078, TYPE *ZI1079, ACCESS_LIST *ZI674)
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
{
crt_templ_qualifier = 0;
}
ZR1014 (*ZI1078, *ZI515, *ZI1079, *ZI674);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
break;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR552 (TYPE *ZO418, int *ZO555)
{
TYPE ZI418;
int ZI555;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
int ZI558;
BASE_TYPE ZI515;
TYPE ZI501;
CV_SPEC ZI788;
TYPE ZI484;
{
(ZI558) = no_type_defns;
}
ZR878 (&ZI515, &ZI501, &ZI788);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI484) = complete_pre_type ((ZI515), (ZI501), (ZI788), 1);
have_type_specifier = 0;
}
ZR960 (ZI484, &ZI418);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI555) = no_type_defns - (ZI558);
}
{
object_type ((ZI418), null_tag);
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO418 = ZI418;
*ZO555 = ZI555;
}
void
ZR647 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_set:
{
EXP ZI497;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR495 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_set_exp ((ZI497));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_unused:
{
EXP ZI497;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR495 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_unused_exp ((ZI497));
}
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:;
*ZO435 = ZI435;
}
void
ZR1209 (EXP ZI1207, EXP *ZO1208)
{
EXP ZI1208;
ZL2_1209:;
switch (CURRENT_TERMINAL) {
case lex_xor_H1:
{
EXP ZI460;
EXP ZI435;
{
{
switch (CURRENT_TERMINAL) {
case lex_xor_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR626 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_xor_exp ((ZI1207), (ZI460));
}
ZI1207 = ZI435;
goto ZL2_1209;
}
/*UNREACHED*/
default:
{
ZI1208 = ZI1207;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1208 = ZI1208;
}
void
ZR690 (TYPE ZI418, DECL_SPEC ZI693)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI1253;
TYPE ZI1254;
CV_SPEC ZI1255;
DECL_SPEC ZI1256;
BASE_TYPE ZI515;
TYPE ZI880;
CV_SPEC ZI881;
DECL_SPEC ZI914;
DECL_SPEC ZI916;
{
/* Resolve declaration-specifiers from other declarators */
(ZI0) = predict_dspec (0);
}
if (!ZI0)
goto ZL2;
ZR911 (ZI418, &ZI1253, &ZI1254, &ZI1255, &ZI1256);
ZR922 (&ZI418, &ZI1253, &ZI1254, &ZI1255, &ZI1256, &ZI515, &ZI880, &ZI881, &ZI914);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* Combine two declaration specifiers */
DECL_SPEC d = (((ZI693) & (ZI914)) & dspec_duplicate);
if (d) report (crt_loc, ERR_dcl_spec_dup (d));
(ZI916) = ((ZI693) | (ZI914));
}
ZR1257 (&ZI418, &ZI515, &ZI880, &ZI881, &ZI916);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname: case lex_destructor_Hname: case lex_template_Hid:
case lex_template_Htype: case lex_nested_Hname: case lex_full_Hname:
case lex_nested_Hname_Hstar: case lex_full_Hname_Hstar: case lex_and_H1:
case lex_open_Hround: case lex_star: case lex_colon_Hcolon:
case lex_operator:
{
BASE_TYPE ZI515;
TYPE ZI880;
CV_SPEC ZI881;
DECL_SPEC ZI914;
DECL_SPEC ZI916;
TYPE ZI884;
DECL_SPEC ZI1078;
TYPE ZI1079;
ACCESS_LIST ZI674;
TYPE ZI578;
IDENTIFIER ZI423;
int ZI562;
IDENTIFIER ZI463;
{
(ZI515) = btype_none;
}
{
(ZI880) = NULL_type;
}
{
(ZI881) = cv_none;
}
{
(ZI914) = dspec_none;
}
{
/* Combine two declaration specifiers */
DECL_SPEC d = (((ZI693) & (ZI914)) & dspec_duplicate);
if (d) report (crt_loc, ERR_dcl_spec_dup (d));
(ZI916) = ((ZI693) | (ZI914));
}
{
/* Complete a declaration specifier and a type */
(ZI1078) = complete_dspec ((ZI916), (ZI515), (ZI880), (ZI881));
(ZI884) = complete_pre_type ((ZI515), (ZI880), (ZI881), 0);
have_type_specifier = 0;
}
{
(ZI1079) = (IS_NULL_type ((ZI418)) ? (ZI884): inject_pre_type ((ZI418), (ZI884), 1));
}
{
save_access (&(ZI674));
}
{
crt_templ_qualifier = 0;
}
ZR955 (ZI1079, &ZI578, &ZI423, &ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (type_tag ((ZI578)) == type_func_tag) {
/* Look ahead for function definitions */
int def = predict_func_defn ();
if (def & !have_func_declarator) adjust_param ((ZI578));
(ZI463) = make_func_decl ((ZI1078), (ZI578), (ZI423), def);
is_function_next = def;
} else {
int def = predict_obj_defn ();
(ZI463) = make_object_decl ((ZI1078), (ZI578), (ZI423), def);
is_function_next = 0;
}
if (IS_id_type_alias ((ZI463))) {
BASE_TYPE bs = DEREF_btype (id_type_alias_rep ((ZI463)));
bs |= (ZI515);
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));
}
}
ZR1080 (&ZI515, &ZI1078, &ZI1079, &ZI674, &ZI562, &ZI463);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
}
void
ZR1033 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
DECL_SPEC ZI693;
TYPE ZI418;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI693) = dspec_none;
}
{
(ZI418) = NULL_type;
}
ZR1032 (ZI418, ZI693);
{
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
ZR455 (int *ZO454)
{
int ZI454;
switch (CURRENT_TERMINAL) {
case lex_delete:
{
ADVANCE_LEXER;
ZR1326 (&ZI454);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_new:
{
ADVANCE_LEXER;
ZR1325 (&ZI454);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hround:
{
ADVANCE_LEXER;
ZR417 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI454) = lex_func_Hop;
}
}
break;
case lex_question:
{
ADVANCE_LEXER;
ZR420 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI454) = lex_cond_Hop;
}
{
/* Illegal overloaded operator */
report (crt_loc, ERR_over_oper_bad ((ZI454)));
}
}
break;
case lex_open_Hsquare_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR419 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI454) = lex_array_Hop;
}
}
break;
case lex_and_H1: case lex_and_Heq_H1: case lex_arrow:
case lex_assign: case lex_colon: case lex_comma:
case lex_compl_H1: case lex_div: case lex_div_Heq:
case lex_dot: case lex_eq: case lex_greater:
case lex_greater_Heq: case lex_less: case lex_less_Heq:
case lex_logical_Hand_H1: case lex_logical_Hor_H1: case lex_lshift:
case lex_lshift_Heq: case lex_minus: case lex_minus_Heq:
case lex_minus_Hminus: case lex_not_H1: case lex_not_Heq_H1:
case lex_or_H1: case lex_or_Heq_H1: case lex_plus:
case lex_plus_Heq: case lex_plus_Hplus: case lex_rem:
case lex_rem_Heq: case lex_rshift: case lex_rshift_Heq:
case lex_star: case lex_star_Heq: case lex_xor_H1:
case lex_xor_Heq_H1: case lex_arrow_Hstar: case lex_colon_Hcolon:
case lex_dot_Hstar: case lex_abs: case lex_max:
case lex_min: case lex_sizeof: case lex_typeid:
case lex_alignof: case lex_vtable:
{
{
(ZI454) = crt_lex_token;
}
ZR1324 (&ZI454);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO454 = ZI454;
}
void
ZR958 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
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_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:
{
ZR655 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI435) = NULL_exp;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR420 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
switch (CURRENT_TERMINAL) {
case lex_colon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
return;
ZL1:;
{
int ZI418;
{
(ZI418) = lex_colon;
}
{
/* Expected symbol */
int p = primary_form (crt_lex_token);
if (p != (ZI418)) report (crt_loc, ERR_lex_expect ((ZI418)));
}
}
}
void
ZR502 (SID_LIST_EXP *ZO501)
{
SID_LIST_EXP ZI501;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI435;
SID_LIST_EXP ZI484;
ZR500 (&ZI435);
ZR503 (&ZI484);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((ZI435), (ZI484), (ZI501));
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO501 = ZI501;
}
void
ZR1213 (EXP ZI1211, EXP *ZO1212)
{
EXP ZI1212;
ZL2_1213:;
switch (CURRENT_TERMINAL) {
case lex_and_H1:
{
EXP ZI460;
EXP ZI435;
{
{
switch (CURRENT_TERMINAL) {
case lex_and_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR624 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_and_exp ((ZI1211), (ZI460));
}
ZI1211 = ZI435;
goto ZL2_1213;
}
/*UNREACHED*/
default:
{
ZI1212 = ZI1211;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1212 = ZI1212;
}
void
ZR500 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
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_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 ZI1268;
ZR634 (&ZI1268);
ZR1269 (&ZI1268, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_throw:
{
ZR639 (&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
ZR504 (SID_LIST_EXP *ZO501)
{
SID_LIST_EXP ZI501;
switch (CURRENT_TERMINAL) {
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:
{
ZR502 (&ZI501);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI501) = NULL_list (EXP);
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO501 = ZI501;
}
void
ZR632 (EXP *ZO1200)
{
EXP ZI1200;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI435;
ZR630 (&ZI435);
ZR1201 (ZI435, &ZI1200);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1200 = ZI1200;
}
void
ZR756 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_break:
{
int ZI674;
ADVANCE_LEXER;
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_break_stmt ();
}
{
unreached_fall = 1;
}
ZR422 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_continue:
{
int ZI674;
ADVANCE_LEXER;
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI435) = make_continue_stmt ();
}
{
unreached_fall = 1;
}
ZR422 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_goto:
{
int ZI674;
ADVANCE_LEXER;
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
ZR755 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_fall = 1;
}
ZR422 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_return:
{
int ZI674;
EXP ZI497;
ADVANCE_LEXER;
{
(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_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_set:
case lex_size_Ht: case lex_unused: case lex_vtable:
case lex_inset_Hstart:
{
ZR495 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI497) = NULL_exp;
}
}
break;
}
}
{
(ZI435) = make_return_stmt ((ZI497), lex_return);
}
{
unreached_fall = 1;
}
ZR422 ();
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
ZR1344 (TYPE *ZI418, BASE_TYPE *ZI515, TYPE *ZI880, CV_SPEC *ZI881, DECL_SPEC *ZI916)
{
switch (CURRENT_TERMINAL) {
case lex_semicolon:
{
{
IGNORE empty_decl ((*ZI916), (*ZI418), (*ZI515), (*ZI880), (*ZI881), last_lex_token, 1);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
have_type_specifier = 0;
}
{
if (crt_access_list.pending) {
IDENTIFIER id = DEREF_id (ctype_name (crt_class));
IGNORE report_access (id);
}
}
ADVANCE_LEXER;
}
break;
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname: case lex_destructor_Hname: case lex_template_Hid:
case lex_template_Htype: case lex_nested_Hname: case lex_full_Hname:
case lex_nested_Hname_Hstar: case lex_full_Hname_Hstar: case lex_and_H1:
case lex_colon: case lex_open_Hround: case lex_star:
case lex_colon_Hcolon: case lex_operator:
{
TYPE ZI884;
DECL_SPEC ZI1078;
TYPE ZI1079;
ACCESS_LIST ZI674;
int ZI724;
IDENTIFIER ZI463;
{
/* Complete a declaration specifier and a type */
(ZI1078) = complete_dspec ((*ZI916), (*ZI515), (*ZI880), (*ZI881));
(ZI884) = complete_pre_type ((*ZI515), (*ZI880), (*ZI881), 0);
have_type_specifier = 0;
}
{
(ZI1079) = (IS_NULL_type ((*ZI418)) ? (ZI884): inject_pre_type ((*ZI418), (ZI884), 1));
}
{
save_access (&(ZI674));
}
{
(ZI724) = 1;
}
{
crt_templ_qualifier = 0;
}
ZR1089 (ZI1078, ZI1079, *ZI515, ZI674, ZI724, &ZI463);
ZR1097 (ZI515, &ZI1078, &ZI1079, &ZI674, &ZI463);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR1217 (EXP ZI1215, EXP *ZO1216)
{
EXP ZI1216;
ZL2_1217:;
switch (CURRENT_TERMINAL) {
case lex_max: case lex_min:
{
int ZI454;
EXP ZI460;
EXP ZI435;
{
(ZI454) = crt_lex_token;
}
{
switch (CURRENT_TERMINAL) {
case lex_max:
{
ADVANCE_LEXER;
}
break;
case lex_min:
{
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
ZR621 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_mult_exp ((ZI454), (ZI1215), (ZI460));
}
ZI1215 = ZI435;
goto ZL2_1217;
}
/*UNREACHED*/
default:
{
ZI1216 = ZI1215;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1216 = ZI1216;
}
void
ZR556 (TYPE *ZO418, EXP *ZO435, int *ZO555)
{
TYPE ZI418;
EXP ZI435;
int ZI555;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
switch (CURRENT_TERMINAL) {
case lex_less:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR552 (&ZI418, &ZI555);
switch (CURRENT_TERMINAL) {
case lex_greater:
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 (&ZI435);
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO418 = ZI418;
*ZO435 = ZI435;
*ZO555 = ZI555;
}
void
ZR702 (EXP *ZO1190, EXP *ZO1191, int *ZO1192)
{
EXP ZI1190;
EXP ZI1191;
int ZI1192;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI562;
EXP ZI501;
int ZI674;
EXP ZI497;
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_hash_Hif:
{
ZI562 = crt_token->pp_data.exp;
}
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
EXP c = crt_hash_cond;
crt_hash_cond = make_if_cond ((ZI562), c);
(ZI501) = c;
}
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
ZR682 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_prev = (ZI674);
}
{
(ZI435) = begin_hash_if_stmt ((ZI562), (ZI497));
}
ZR1193 (ZI435, ZI501, ZI674, &ZI1190, &ZI1191, &ZI1192);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1190 = ZI1190;
*ZO1191 = ZI1191;
*ZO1192 = ZI1192;
}
/* END OF FILE */
syntax highlighted by Code2HTML, v. 0.9.1