/*
* 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
ZR1034 (EXP *ZO1149)
{
EXP ZI1149;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI562;
EXP ZI501;
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;
}
{
target_decl (lex_if, (ZI562));
}
ZR1033 ();
ZR1150 (ZI501, &ZI1149);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1149 = ZI1149;
}
void
ZR1436 (int *ZO454)
{
int ZI454;
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR1437 (&ZI454);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI454) = lex_delete;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO454 = ZI454;
}
void
ZR1182 (TYPE ZI1176, IDENTIFIER ZI1177, int ZI1178, TYPE *ZO1179, IDENTIFIER *ZO1180, int *ZO1181)
{
TYPE ZI1179;
IDENTIFIER ZI1180;
int ZI1181;
ZL2_1182:;
switch (CURRENT_TERMINAL) {
case lex_open_Hround: case lex_open_Hsquare_H1: case lex_weak:
{
IDENTIFIER ZI423;
QUALIFIER ZI459;
int ZI497;
TYPE ZI484;
int ZI562;
TYPE ZI418;
ZI423 = ZI1177;
{
(ZI459) = crt_id_qualifier;
(ZI497) = crt_templ_qualifier;
}
ZR951 (ZI423, &ZI484, &ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if ((ZI1178)) report (crt_loc, ERR_dcl_init_bad ());
}
{
(ZI418) = (IS_NULL_type ((ZI1176)) ? (ZI484): inject_pre_type ((ZI1176), (ZI484), 0));
}
{
crt_id_qualifier = (ZI459);
crt_templ_qualifier = (ZI497);
}
ZI1176 = ZI418;
ZI1177 = ZI423;
ZI1178 = ZI562;
goto ZL2_1182;
}
/*UNREACHED*/
default:
{
ZI1179 = ZI1176;
ZI1180 = ZI1177;
ZI1181 = ZI1178;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1179 = ZI1179;
*ZO1180 = ZI1180;
*ZO1181 = ZI1181;
}
void
ZR945 (TYPE *ZO418, IDENTIFIER *ZO423, int *ZO562)
{
TYPE ZI418;
IDENTIFIER ZI423;
int ZI562;
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_open_Hround: case lex_colon_Hcolon: case lex_operator:
{
ZR954 (&ZI418, &ZI423, &ZI562);
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;
ZR931 (&ZI501);
ZR945 (&ZI484, &ZI423, &ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 0));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO418 = ZI418;
*ZO423 = ZI423;
*ZO562 = ZI562;
}
void
ZR1437 (int *ZO454)
{
int ZI454;
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI454) = lex_delete_Harray;
}
}
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_set:
case lex_size_Ht: case lex_unused: case lex_vtable:
case lex_inset_Hstart:
{
EXP ZI435;
ZR495 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* Array size in 'delete []' */
old_delete_array ((ZI435));
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI454) = lex_delete_Harray;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO454 = ZI454;
}
void
ZR615 (EXP *ZO1228)
{
EXP ZI1228;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI435;
ZR612 (&ZI435);
ZR1229 (ZI435, &ZI1228);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1228 = ZI1228;
}
void
ZR740 (EXP *ZO497, EXP *ZO435)
{
EXP ZI497;
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
IDENTIFIER ZI463;
EXP ZI1601;
EXP ZI562;
{
/* Resolve declaration-statements from expression-statements */
int b = predict_decl ();
if (b) in_declaration++;
(ZI0) = b;
}
if (!ZI0)
goto ZL2;
{
begin_cond ();
}
ZR1101 (&ZI463);
switch (CURRENT_TERMINAL) {
case lex_assign:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR653 (&ZI1601);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (crt_access_list.pending) {
IGNORE report_access ((ZI463));
}
}
{
int def = init_object ((ZI463), (ZI1601));
if (do_dump) dump_declare ((ZI463), &decl_loc, def);
}
{
if (crt_access_list.pending) {
IGNORE report_access ((ZI463));
}
}
{
end_declarator ((ZI463), 1);
}
{
(ZI562) = end_cond ();
in_declaration--;
}
{
(ZI497) = bind_temporary ((ZI562));
}
{
MAKE_exp_location (type_void, crt_loc, (ZI497), (ZI435));
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_semicolon:
{
ADVANCE_LEXER;
{
(ZI497) = NULL_exp;
}
{
MAKE_exp_location (type_void, crt_loc, (ZI497), (ZI435));
}
}
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_set:
case lex_size_Ht: case lex_unused: case lex_vtable:
case lex_inset_Hstart:
{
EXP ZI562;
ZR495 (&ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI497) = bind_temporary ((ZI562));
}
{
MAKE_exp_location (type_void, crt_loc, (ZI497), (ZI435));
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO497 = ZI497;
*ZO435 = ZI435;
}
void
ZR992 (TYPE *ZO418)
{
TYPE ZI418;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
TYPE ZI501;
TYPE ZI484;
{
/* Resolve pointer or reference declarators from expressions */
(ZI0) = predict_ptr (1);
}
if (!ZI0)
goto ZL2;
ZR931 (&ZI501);
ZR992 (&ZI484);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 0));
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
default:
{
{
(ZI418) = NULL_type;
}
}
break;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO418 = ZI418;
}
void
ZR1438 (IDENTIFIER *ZI423, EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_assign:
{
NAMESPACE ZI1052;
IDENTIFIER ZI1053;
IDENTIFIER ZI1054;
NAMESPACE ZI429;
ADVANCE_LEXER;
ZR432 (&ZI1052);
ZR512 (&ZI1053);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1054) = check_id ((ZI1052), (ZI1053), 0);
last_namespace = (ZI1052);
}
{
(ZI429) = find_nspace_id ((ZI1054));
}
{
crt_id_qualifier = qual_none;
crt_templ_qualifier = 0;
qual_namespace = NULL_nspace;
}
{
alias_namespace ((*ZI423), (ZI429));
}
ZR422 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = NULL_exp;
}
}
break;
case lex_open_Hbrace_H1:
{
DECL_SPEC ZI693;
TYPE ZI418;
{
begin_namespace ((*ZI423), 0);
}
{
(ZI693) = dspec_none;
}
{
(ZI418) = NULL_type;
}
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR1032 (ZI418, ZI693);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
end_namespace (0);
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
RESCAN_LEXER;
}
{
(ZI435) = NULL_exp;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR868 (IDENTIFIER ZI435)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
IDENTIFIER ZI869;
IDENTIFIER ZI423;
EXP ZI562;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI869 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_namespace_Hname:
{
{
ZI869 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI869 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI869 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
(ZI423) = (ZI869);
crt_id_qualifier = qual_none;
last_namespace = crt_namespace;
}
{
IDENTIFIER pid = underlying_id ((ZI423));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR1088 (&ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
IDENTIFIER id = constr_name (last_namespace, (ZI423));
IGNORE make_enumerator ((ZI435), id, (ZI562));
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR955 (TYPE ZI501, TYPE *ZO418, IDENTIFIER *ZO423, int *ZO562)
{
TYPE ZI418;
IDENTIFIER ZI423;
int ZI562;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
TYPE ZI484;
ZR945 (&ZI484, &ZI423, &ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (!IS_NULL_type ((ZI501))) template_decl ((ZI501));
}
{
(ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 1));
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO418 = ZI418;
*ZO423 = ZI423;
*ZO562 = ZI562;
}
void
ZR1009 (int ZI562, IDENTIFIER ZI463, EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
SID_LIST_EXP ZI501;
{
(ZI0) = (ZI562);
}
if (!ZI0)
goto ZL2;
{
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;
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_assign:
{
ADVANCE_LEXER;
ZR1003 (ZI463, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI435) = NULL_exp;
}
}
break;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
parse_file (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;
EXP ZI435;
{
/* 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;
}
{
external_declaration ((ZI435), 1);
}
ZR1032 (ZI418, ZI693);
switch (CURRENT_TERMINAL) {
case lex_eof:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_eof:
{
ADVANCE_LEXER;
}
break;
case lex_extern:
{
EXP ZI435;
ZR1067 (ZI418, ZI693, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
external_declaration ((ZI435), 1);
}
ZR1032 (ZI418, ZI693);
switch (CURRENT_TERMINAL) {
case lex_eof:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_export: case lex_template:
{
EXP ZI435;
ZR1077 (ZI418, ZI693, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
external_declaration ((ZI435), 1);
}
ZR1032 (ZI418, ZI693);
switch (CURRENT_TERMINAL) {
case lex_eof:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_identifier: case lex_type_Hname: case lex_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_semicolon: case lex_star:
case lex_colon_Hcolon: case lex_operator:
{
BASE_TYPE ZI515;
TYPE ZI880;
CV_SPEC ZI1258;
EXP ZI435;
{
(ZI515) = btype_none;
}
{
(ZI880) = NULL_type;
}
{
(ZI1258) = cv_none;
}
ZR1259 (&ZI418, &ZI693, &ZI515, &ZI880, &ZI1258, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
external_declaration ((ZI435), 1);
}
ZR1032 (ZI418, ZI693);
switch (CURRENT_TERMINAL) {
case lex_eof:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_hash_Hif: case lex_hash_Hpragma: case lex_asm:
case lex_namespace: case lex_using:
{
{
if (!IS_NULL_type ((ZI418))) report (crt_loc, ERR_temp_decl_bad ());
UNUSED ((ZI693));
}
ZR1260 ();
ZR1032 (ZI418, ZI693);
switch (CURRENT_TERMINAL) {
case lex_eof:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
return;
ZL1:;
{
{
/* Unrecoverable syntax errors */
ERROR err = ERR_lex_parse (crt_token);
err = concat_error (err, ERR_lex_abort ());
report (crt_loc, err);
have_syntax_error = 1;
}
}
ZL0:;
}
void
ZR1029 (EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI562;
EXP ZI497;
{
(ZI562) = begin_compound_stmt (1);
}
{
switch (CURRENT_TERMINAL) {
case lex_colon: case lex_open_Hbrace_H1:
{
ZR1027 (ZI562, &ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_try:
{
EXP ZI460;
ZR1028 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI497) = add_compound_stmt ((ZI562), (ZI460));
}
}
break;
default:
goto ZL1;
}
}
{
(ZI435) = end_compound_stmt ((ZI497));
}
{
if (crt_access_list.pending) {
IGNORE report_access (crt_func_id);
}
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1115 (int *ZO718)
{
int ZI718;
switch (CURRENT_TERMINAL) {
case lex_export:
{
ADVANCE_LEXER;
{
(ZI718) = 1;
}
}
break;
default:
{
{
(ZI718) = 0;
}
}
break;
case 358:
return;
}
*ZO718 = ZI718;
}
void
parse_offset (OFFSET ZI460, TYPE ZI578, OFFSET *ZO497, TYPE *ZO418)
{
OFFSET ZI497;
TYPE ZI418;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
OFFSET ZI562;
TYPE ZI1133;
ZR1130 (ZI460, ZI578, &ZI562, &ZI1133);
{
switch (CURRENT_TERMINAL) {
case lex_dot: case lex_open_Hsquare_H1:
{
ZR1132 (ZI562, ZI1133, &ZI497, &ZI418);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
ZI497 = ZI562;
ZI418 = ZI1133;
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
}
}
}
goto ZL0;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
ZI497 = ZI460;
ZI418 = ZI578;
}
ZL0:;
*ZO497 = ZI497;
*ZO418 = ZI418;
}
void
parse_nat (EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR655 (&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
ZR1441 (EXP *ZI1439, 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_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:
{
SID_LIST_EXP ZI484;
SID_LIST_EXP ZI501;
ZR652 (&ZI484);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((*ZI1439), (ZI484), (ZI501));
}
{
(ZI435) = make_comma_exp ((ZI501));
}
}
break;
default:
{
ZI435 = *ZI1439;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR653 (EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR500 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
parse_param (TYPE ZI578, int ZI501, IDENTIFIER *ZO463)
{
IDENTIFIER ZI463;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR976 (ZI578, ZI501, &ZI463);
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;
}
{
(ZI463) = NULL_id;
}
}
ZL0:;
*ZO463 = ZI463;
}
void
ZR878 (BASE_TYPE *ZO515, TYPE *ZO418, CV_SPEC *ZO788)
{
BASE_TYPE ZI515;
TYPE ZI418;
CV_SPEC ZI788;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
TYPE ZI578;
BASE_TYPE ZI879;
TYPE ZI880;
CV_SPEC ZI881;
{
(ZI578) = NULL_type;
}
ZR877 (ZI578, &ZI879, &ZI880, &ZI881);
{
switch (CURRENT_TERMINAL) {
case lex_type_Hname: case lex_template_Htype: case lex_nested_Hname:
case lex_full_Hname: case lex_complex_Htype: case lex_colon_Hcolon:
case lex_char: case lex_const: case lex_double:
case lex_enum: case lex_float: case lex_int:
case lex_long: case lex_short: case lex_signed:
case lex_struct: case lex_union: case lex_unsigned:
case lex_void: case lex_volatile: case lex_restrict:
case lex_bool: case lex_class: case lex_typename:
case lex_wchar_Ht: case lex_bottom: case lex_ptrdiff_Ht:
case lex_size_Ht:
{
BASE_TYPE ZI883;
TYPE ZI884;
CV_SPEC ZI885;
ZR878 (&ZI883, &ZI884, &ZI885);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if ((ZI879) & (ZI883)) {
(ZI515) = join_pre_types ((ZI879), (ZI883));
} else {
(ZI515) = ((ZI879) | (ZI883));
}
}
{
/* Join two partial types */
if (IS_NULL_type ((ZI880))) {
(ZI418) = (ZI884);
} else if (IS_NULL_type ((ZI884))) {
(ZI418) = (ZI880);
} else {
report (crt_loc, ERR_dcl_type_simple_many ((ZI880), (ZI884)));
(ZI418) = (ZI884);
}
}
{
CV_SPEC c = ((ZI881) & (ZI885));
if (c) report (crt_loc, ERR_dcl_type_cv_dup (c));
(ZI788) = ((ZI881) | (ZI885));
}
}
break;
default:
{
ZI515 = ZI879;
ZI418 = ZI880;
ZI788 = ZI881;
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
}
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO515 = ZI515;
*ZO418 = ZI418;
*ZO788 = ZI788;
}
void
ZR506 (IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
NAMESPACE ZI429;
IDENTIFIER ZI464;
switch (CURRENT_TERMINAL) {
case lex_nested_Hname:
{
ZI429 = crt_token->pp_data.ns;
}
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
switch (CURRENT_TERMINAL) {
case lex_template_Htype:
{
{
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;
}
break;
case lex_type_Hname:
{
{
ZI464 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
crt_id_qualifier = qual_nested;
qual_namespace = (ZI429);
}
{
(ZI423) = check_id ((ZI429), (ZI464), 0);
last_namespace = (ZI429);
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO423 = ZI423;
}
void
ZR1109 (SID_LIST_TYPE *ZO501)
{
SID_LIST_TYPE ZI501;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
TYPE ZI578;
int ZI555;
TYPE ZI418;
SID_LIST_TYPE ZI484;
ZR552 (&ZI578, &ZI555);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI418) = check_except_type ((ZI578), (ZI555));
}
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
ZR1389 (&ZI484);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI484) = NULL_list (TYPE);
}
}
break;
}
}
{
(ZI501) = cons_type_set ((ZI484), (ZI418));
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO501 = ZI501;
}
void
ZR1444 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_set:
{
EXP ZI1598;
EXP ZI1599;
ADVANCE_LEXER;
ZR495 (&ZI1598);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1599) = make_set_exp ((ZI1598));
}
ZR1600 (&ZI1599, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_unused:
{
EXP ZI1595;
EXP ZI1596;
ADVANCE_LEXER;
ZR495 (&ZI1595);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1596) = make_unused_exp ((ZI1595));
}
ZR1600 (&ZI1596, &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
ZR1317 (NAMESPACE *ZI429, IDENTIFIER *ZI1315, IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
switch (CURRENT_TERMINAL) {
case lex_colon_Hcolon:
{
BASE_TYPE ZI524;
NAMESPACE ZI525;
QUALIFIER ZI459;
int ZI460;
IDENTIFIER ZI526;
BASE_TYPE ZI527;
IDENTIFIER ZI482;
ADVANCE_LEXER;
{
(ZI524) = btype_none;
}
ZI525 = *ZI429;
{
(ZI459) = crt_id_qualifier;
(ZI460) = crt_templ_qualifier;
}
{
{
switch (CURRENT_TERMINAL) {
case lex_compl_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR520 (&ZI526, &ZI527);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
crt_id_qualifier = (ZI459);
crt_templ_qualifier = (ZI460);
}
{
(ZI482) = make_pseudo_destr ((*ZI1315), (ZI524), (ZI526), (ZI527));
}
{
(ZI423) = check_id ((ZI525), (ZI482), 0);
last_namespace = (ZI525);
}
}
break;
default:
{
ZI423 = *ZI1315;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO423 = ZI423;
}
void
ZR488 (IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
switch (CURRENT_TERMINAL) {
case lex_colon_Hcolon:
{
ADVANCE_LEXER;
ZR1609 (&ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_full_Hname:
{
NAMESPACE ZI429;
{
ZI429 = crt_token->pp_data.ns;
}
ADVANCE_LEXER;
ZR1608 (&ZI429, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_nested_Hname:
{
NAMESPACE ZI429;
{
ZI429 = crt_token->pp_data.ns;
}
ADVANCE_LEXER;
ZR1607 (&ZI429, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_statement_Hname:
{
IDENTIFIER ZI482;
{
ZI482 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
{
(ZI423) = (ZI482);
crt_id_qualifier = qual_none;
last_namespace = crt_namespace;
}
}
break;
case lex_identifier: case lex_namespace_Hname: case lex_destructor_Hname:
case lex_template_Hid: case lex_operator:
{
ZR481 (&ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_type_Hname: case lex_template_Htype:
{
ZR476 (&ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO423 = ZI423;
}
void
ZR956 (TYPE *ZO418)
{
TYPE ZI418;
switch (CURRENT_TERMINAL) {
case lex_open_Hround: case lex_open_Hsquare_H1: case lex_weak:
{
ZR959 (&ZI418);
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 ZI1385;
ZR931 (&ZI1385);
ZR1387 (&ZI1385, &ZI418);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO418 = ZI418;
}
void
parse_func (EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR1029 (&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
ZR1445 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_case:
{
EXP ZI562;
EXP ZI497;
EXP ZI460;
ADVANCE_LEXER;
ZR655 (&ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI497) = begin_case_stmt ((ZI562), 0);
}
{
unreached_fall = 0;
}
switch (CURRENT_TERMINAL) {
case lex_colon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR665 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = end_case_stmt ((ZI497), (ZI460));
}
}
break;
case lex_default:
{
EXP ZI497;
EXP ZI460;
ADVANCE_LEXER;
{
(ZI497) = begin_default_stmt (0);
}
{
unreached_fall = 0;
}
switch (CURRENT_TERMINAL) {
case lex_colon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR665 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = end_default_stmt ((ZI497), (ZI460));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1318 (NAMESPACE *ZI429, IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
switch (CURRENT_TERMINAL) {
case lex_type_Hname: case lex_template_Htype:
{
IDENTIFIER ZI464;
NAMESPACE ZI1400;
IDENTIFIER ZI1401;
{
switch (CURRENT_TERMINAL) {
case lex_template_Htype:
{
{
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;
}
break;
case lex_type_Hname:
{
{
ZI464 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
(ZI1400) = global_namespace;
crt_id_qualifier = qual_top;
qual_namespace = (ZI1400);
}
{
(ZI1401) = check_id ((ZI1400), (ZI464), 0);
last_namespace = (ZI1400);
}
ZR1403 (ZI429, &ZI1401, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_identifier: case lex_namespace_Hname: case lex_destructor_Hname:
case lex_template_Hid: case lex_compl_H1: case lex_operator:
case lex_template:
{
NAMESPACE ZI1398;
{
(ZI1398) = global_namespace;
crt_id_qualifier = qual_top;
qual_namespace = (ZI1398);
}
ZR1399 (&ZI1398, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO423 = ZI423;
}
void
ZR520 (IDENTIFIER *ZO423, BASE_TYPE *ZO515)
{
IDENTIFIER ZI423;
BASE_TYPE ZI515;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname: case lex_template_Htype:
{
ZR512 (&ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI515) = btype_none;
}
}
break;
case lex_char: case lex_double: case lex_float:
case lex_int: case lex_long: case lex_short:
case lex_signed: case lex_unsigned: case lex_void:
case lex_bool: case lex_wchar_Ht: case lex_bottom:
case lex_ptrdiff_Ht: case lex_size_Ht:
{
ZR513 (&ZI515);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI423) = NULL_id;
crt_id_qualifier = qual_none;
qual_namespace = NULL_nspace;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO423 = ZI423;
*ZO515 = ZI515;
}
void
ZR838 (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;
}
ZR837 (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
ZR508 (IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
IDENTIFIER ZI464;
NAMESPACE ZI429;
switch (CURRENT_TERMINAL) {
case lex_colon_Hcolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
switch (CURRENT_TERMINAL) {
case lex_template_Htype:
{
{
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;
}
break;
case lex_type_Hname:
{
{
ZI464 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
(ZI429) = global_namespace;
crt_id_qualifier = qual_top;
qual_namespace = (ZI429);
}
{
(ZI423) = check_id ((ZI429), (ZI464), 0);
last_namespace = (ZI429);
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO423 = ZI423;
}
void
ZR899 (DECL_SPEC *ZO693)
{
DECL_SPEC ZI693;
switch (CURRENT_TERMINAL) {
case lex_auto:
{
ADVANCE_LEXER;
{
(ZI693) = dspec_auto;
}
}
break;
case lex_extern:
{
ADVANCE_LEXER;
{
(ZI693) = dspec_extern;
}
}
break;
case lex_mutable:
{
ADVANCE_LEXER;
{
(ZI693) = dspec_mutable;
}
}
break;
case lex_register:
{
ADVANCE_LEXER;
{
(ZI693) = dspec_register;
}
}
break;
case lex_static:
{
ADVANCE_LEXER;
{
(ZI693) = dspec_static;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO693 = ZI693;
}
void
ZR1320 (NAMESPACE *ZI429, NAMESPACE *ZI1319, IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
switch (CURRENT_TERMINAL) {
case lex_type_Hname: case lex_template_Htype:
{
IDENTIFIER ZI1404;
IDENTIFIER ZI464;
IDENTIFIER ZI1405;
{
switch (CURRENT_TERMINAL) {
case lex_template_Htype:
{
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI1404 = parse_type_template (id, args, 0);
crt_templ_qualifier = 1;
RESCAN_LEXER;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI1404 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
crt_id_qualifier = qual_nested;
qual_namespace = (*ZI1319);
}
{
(ZI464) = check_id ((*ZI1319), (ZI1404), 0);
last_namespace = (*ZI1319);
}
{
(ZI1405) = check_id ((*ZI429), (ZI464), 0);
last_namespace = (*ZI429);
}
ZR1407 (ZI429, &ZI1405, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_identifier: case lex_namespace_Hname: case lex_destructor_Hname:
case lex_template_Hid: case lex_operator: case lex_template:
{
int ZI484;
IDENTIFIER ZI482;
IDENTIFIER ZI522;
ZR479 (*ZI1319, &ZI484);
ZR480 (*ZI1319, &ZI482);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
crt_id_qualifier = qual_nested;
qual_namespace = (*ZI1319);
}
{
(ZI522) = check_id ((*ZI1319), (ZI482), (ZI484));
last_namespace = (*ZI1319);
}
{
(ZI423) = check_id ((*ZI429), (ZI522), 0);
last_namespace = (*ZI429);
}
}
break;
case lex_compl_H1:
{
IDENTIFIER ZI523;
BASE_TYPE ZI524;
NAMESPACE ZI525;
QUALIFIER ZI459;
int ZI460;
IDENTIFIER ZI526;
BASE_TYPE ZI527;
IDENTIFIER ZI482;
{
crt_id_qualifier = qual_nested;
qual_namespace = (*ZI1319);
}
{
(ZI523) = DEREF_id (nspace_name ((*ZI1319)));
}
{
(ZI524) = btype_none;
}
ZI525 = *ZI1319;
{
(ZI459) = crt_id_qualifier;
(ZI460) = crt_templ_qualifier;
}
{
{
switch (CURRENT_TERMINAL) {
case lex_compl_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR520 (&ZI526, &ZI527);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
crt_id_qualifier = (ZI459);
crt_templ_qualifier = (ZI460);
}
{
(ZI482) = make_pseudo_destr ((ZI523), (ZI524), (ZI526), (ZI527));
}
{
(ZI423) = check_id ((ZI525), (ZI482), 0);
last_namespace = (ZI525);
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO423 = ZI423;
}
void
ZR1193 (EXP ZI1187, EXP ZI1188, int ZI1189, EXP *ZO1190, EXP *ZO1191, int *ZO1192)
{
EXP ZI1190;
EXP ZI1191;
int ZI1192;
ZL2_1193:;
switch (CURRENT_TERMINAL) {
case lex_hash_Helif:
{
EXP ZI501;
int ZI674;
EXP ZI562;
int ZI578;
EXP ZI460;
EXP ZI435;
ZI501 = ZI1188;
ZI674 = ZI1189;
{
ZI562 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
{
EXP c = make_else_cond (crt_hash_cond);
crt_hash_cond = make_if_cond ((ZI562), c);
}
{
(ZI578) = unreached_code;
if ((ZI578)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
ZR682 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_prev = (ZI674);
}
{
(ZI435) = cont_hash_if_stmt ((ZI1187), (ZI562), (ZI460));
}
ZI1187 = ZI435;
ZI1188 = ZI501;
ZI1189 = ZI674;
goto ZL2_1193;
}
/*UNREACHED*/
default:
{
ZI1190 = ZI1187;
ZI1191 = ZI1188;
ZI1192 = ZI1189;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1190 = ZI1190;
*ZO1191 = ZI1191;
*ZO1192 = ZI1192;
}
void
parse_id (IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR488 (&ZI423);
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;
}
{
(ZI423) = NULL_id;
crt_id_qualifier = qual_none;
qual_namespace = NULL_nspace;
}
}
ZL0:;
*ZO423 = ZI423;
}
void
ZR1322 (NAMESPACE *ZI429, NAMESPACE *ZI1321, IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
switch (CURRENT_TERMINAL) {
case lex_type_Hname: case lex_template_Htype:
{
IDENTIFIER ZI464;
IDENTIFIER ZI1408;
{
switch (CURRENT_TERMINAL) {
case lex_template_Htype:
{
{
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;
}
break;
case lex_type_Hname:
{
{
ZI464 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
crt_id_qualifier = qual_full;
qual_namespace = (*ZI1321);
}
{
(ZI1408) = check_id ((*ZI1321), (ZI464), 0);
last_namespace = (*ZI1321);
}
ZR1410 (ZI429, &ZI1408, &ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_identifier: case lex_namespace_Hname: case lex_destructor_Hname:
case lex_template_Hid: case lex_operator: case lex_template:
{
int ZI484;
IDENTIFIER ZI482;
ZR479 (*ZI1321, &ZI484);
ZR480 (*ZI1321, &ZI482);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
crt_id_qualifier = qual_full;
qual_namespace = (*ZI1321);
}
{
(ZI423) = check_id ((*ZI1321), (ZI482), (ZI484));
last_namespace = (*ZI1321);
}
}
break;
case lex_compl_H1:
{
IDENTIFIER ZI523;
BASE_TYPE ZI524;
NAMESPACE ZI525;
QUALIFIER ZI459;
int ZI460;
IDENTIFIER ZI526;
BASE_TYPE ZI527;
IDENTIFIER ZI482;
{
crt_id_qualifier = qual_full;
qual_namespace = (*ZI1321);
}
{
(ZI523) = DEREF_id (nspace_name ((*ZI1321)));
}
{
(ZI524) = btype_none;
}
ZI525 = *ZI1321;
{
(ZI459) = crt_id_qualifier;
(ZI460) = crt_templ_qualifier;
}
{
{
switch (CURRENT_TERMINAL) {
case lex_compl_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR520 (&ZI526, &ZI527);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
crt_id_qualifier = (ZI459);
crt_templ_qualifier = (ZI460);
}
{
(ZI482) = make_pseudo_destr ((ZI523), (ZI524), (ZI526), (ZI527));
}
{
(ZI423) = check_id ((ZI525), (ZI482), 0);
last_namespace = (ZI525);
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO423 = ZI423;
}
void
ZR585 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_alignof:
{
int ZI454;
ADVANCE_LEXER;
{
(ZI454) = lex_alignof;
}
ZR597 (ZI454, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_colon_Hcolon:
{
ADVANCE_LEXER;
ZR1289 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_complex_Hexp:
{
EXP ZI1284;
{
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, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_complex_Htype:
{
TYPE ZI1270;
BASE_TYPE ZI515;
CV_SPEC ZI788;
TYPE ZI418;
SID_LIST_EXP ZI501;
EXP ZI1287;
{
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, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_const_Hcast:
{
TYPE ZI418;
EXP ZI497;
int ZI555;
EXP ZI1276;
ADVANCE_LEXER;
ZR556 (&ZI418, &ZI497, &ZI555);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* n is the number of type definitions in t */
(ZI1276) = make_const_cast_exp ((ZI418), (ZI497), (ZI555));
}
ZR1245 (ZI1276, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_discard:
{
EXP ZI497;
ADVANCE_LEXER;
ZR585 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_cast_exp (type_void, (ZI497), 0);
}
}
break;
case lex_dynamic_Hcast:
{
TYPE ZI418;
EXP ZI497;
int ZI555;
EXP ZI1279;
ADVANCE_LEXER;
ZR556 (&ZI418, &ZI497, &ZI555);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* n is the number of type definitions in t */
(ZI1279) = make_dynamic_cast_exp ((ZI418), (ZI497), (ZI555));
}
ZR1245 (ZI1279, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_ellipsis_Hexp:
{
EXP ZI1282;
ADVANCE_LEXER;
{
(ZI1282) = make_ellipsis_exp ();
}
ZR1245 (ZI1282, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_full_Hname:
{
NAMESPACE ZI429;
{
ZI429 = crt_token->pp_data.ns;
}
ADVANCE_LEXER;
ZR1272 (&ZI429, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_minus_Hminus:
{
EXP ZI497;
ADVANCE_LEXER;
ZR585 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_prefix_exp (lex_minus_Hminus, (ZI497));
}
}
break;
case lex_nested_Hname:
{
NAMESPACE ZI429;
{
ZI429 = crt_token->pp_data.ns;
}
ADVANCE_LEXER;
ZR1271 (&ZI429, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hround:
{
ADVANCE_LEXER;
ZR1291 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_plus_Hplus:
{
EXP ZI497;
ADVANCE_LEXER;
ZR585 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_prefix_exp (lex_plus_Hplus, (ZI497));
}
}
break;
case lex_reinterpret_Hcast:
{
TYPE ZI418;
EXP ZI497;
int ZI555;
EXP ZI1277;
ADVANCE_LEXER;
ZR556 (&ZI418, &ZI497, &ZI555);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* n is the number of type definitions in t */
(ZI1277) = make_reinterp_cast_exp ((ZI418), (ZI497), (ZI555));
}
ZR1245 (ZI1277, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_sizeof:
{
int ZI454;
ADVANCE_LEXER;
{
(ZI454) = lex_sizeof;
}
ZR597 (ZI454, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_star:
{
EXP ZI497;
ADVANCE_LEXER;
ZR585 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_indir_exp ((ZI497));
}
}
break;
case lex_static_Hcast:
{
TYPE ZI418;
EXP ZI497;
int ZI555;
EXP ZI1278;
ADVANCE_LEXER;
ZR556 (&ZI418, &ZI497, &ZI555);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1278) = make_static_cast_exp ((ZI418), (ZI497), (ZI555));
}
ZR1245 (ZI1278, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_this:
{
EXP ZI1281;
ADVANCE_LEXER;
{
(ZI1281) = make_this_exp ();
}
ZR1245 (ZI1281, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_typeid:
{
int ZI454;
EXP ZI1275;
ADVANCE_LEXER;
{
(ZI454) = lex_typeid;
}
ZR557 (ZI454, &ZI1275);
ZR1245 (ZI1275, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_vtable:
{
int ZI454;
EXP ZI1274;
ADVANCE_LEXER;
{
(ZI454) = lex_vtable;
}
ZR557 (ZI454, &ZI1274);
ZR1245 (ZI1274, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_and_H1:
{
EXP ZI497;
{
{
switch (CURRENT_TERMINAL) {
case lex_and_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR585 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_ref_exp ((ZI497), 0);
}
}
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;
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, &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;
ZR441 (&ZI1280);
ZR1245 (ZI1280, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_not_H1:
{
EXP ZI497;
{
{
switch (CURRENT_TERMINAL) {
case lex_not_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR585 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_not_exp ((ZI497));
}
}
break;
case lex_identifier: case lex_namespace_Hname: case lex_destructor_Hname:
case lex_template_Hid: case lex_operator:
{
IDENTIFIER ZI423;
EXP ZI1288;
ZR481 (&ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1288) = make_id_exp ((ZI423));
}
ZR1245 (ZI1288, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_type_Hname: case lex_template_Htype:
{
IDENTIFIER ZI423;
TYPE ZI1270;
BASE_TYPE ZI515;
CV_SPEC ZI788;
TYPE ZI418;
SID_LIST_EXP ZI501;
EXP ZI1286;
ZR476 (&ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
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, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_delete: case lex_new:
{
int ZI460;
{
(ZI460) = 0;
}
ZR1435 (&ZI460, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_compl_H1: case lex_minus: case lex_plus:
case lex_abs:
{
int ZI454;
EXP ZI497;
{
(ZI454) = crt_lex_token;
}
ZR600 ();
ZR585 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_uminus_exp ((ZI454), (ZI497));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR877 (TYPE ZI578, BASE_TYPE *ZO515, TYPE *ZO418, CV_SPEC *ZO788)
{
BASE_TYPE ZI515;
TYPE ZI418;
CV_SPEC ZI788;
switch (CURRENT_TERMINAL) {
case lex_enum:
{
ADVANCE_LEXER;
ZR1330 (&ZI578, &ZI515, &ZI418, &ZI788);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_typename:
{
NAMESPACE ZI429;
IDENTIFIER ZI423;
ADVANCE_LEXER;
{
crt_templ_qualifier = 0;
}
ZR432 (&ZI429);
ZR512 (&ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI418) = make_typename ((ZI429), (ZI423));
if (have_type_declaration == TYPE_DECL_NONE) {
have_type_declaration = TYPE_DECL_ELABORATE;
found_elaborate_type = 1;
}
have_type_specifier = 1;
}
{
(ZI515) = btype_none;
}
{
(ZI788) = cv_none;
}
}
break;
case lex_struct: case lex_union: case lex_class:
{
BASE_TYPE ZI821;
ZR822 (&ZI821);
ZR1329 (&ZI578, &ZI821, &ZI515, &ZI418, &ZI788);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_const: case lex_volatile: case lex_restrict:
{
ZR789 (&ZI788);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI515) = btype_none;
}
{
(ZI418) = NULL_type;
}
}
break;
case lex_type_Hname: case lex_template_Htype: case lex_nested_Hname:
case lex_full_Hname: case lex_complex_Htype: case lex_colon_Hcolon:
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:
{
ZR813 (&ZI515, &ZI418);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI788) = cv_none;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO515 = ZI515;
*ZO418 = ZI418;
*ZO788 = ZI788;
}
void
ZR946 (int *ZO950)
{
int ZI950;
switch (CURRENT_TERMINAL) {
case lex_type_Hname: case lex_template_Htype: case lex_nested_Hname:
case lex_full_Hname: case lex_complex_Htype: 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:
{
ZR980 (&ZI950);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI950) = 0;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO950 = ZI950;
}
void
ZR960 (TYPE ZI501, TYPE *ZO418)
{
TYPE ZI418;
switch (CURRENT_TERMINAL) {
case lex_nested_Hname_Hstar: case lex_full_Hname_Hstar: case lex_and_H1:
case lex_open_Hround: case lex_open_Hsquare_H1: case lex_star:
case lex_weak:
{
TYPE ZI484;
ZR956 (&ZI484);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI418) = (IS_NULL_type ((ZI484)) ? (ZI501): inject_pre_type ((ZI484), (ZI501), 1));
}
}
break;
default:
{
ZI418 = ZI501;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO418 = ZI418;
}
void
ZR421 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
return;
ZL1:;
{
int ZI418;
{
(ZI418) = lex_open_Hround;
}
{
/* Expected symbol */
int p = primary_form (crt_lex_token);
if (p != (ZI418)) report (crt_loc, ERR_lex_expect ((ZI418)));
}
}
}
void
ZR1324 (int *ZI454)
{
switch (CURRENT_TERMINAL) {
case lex_and_H1: case lex_and_Heq_H1: case lex_arrow:
case lex_assign: case lex_comma: case lex_compl_H1:
case lex_div: case lex_div_Heq: 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_abs: case lex_max: case lex_min:
{
{
switch (CURRENT_TERMINAL) {
case lex_abs:
{
ADVANCE_LEXER;
}
break;
case lex_arrow:
{
ADVANCE_LEXER;
}
break;
case lex_arrow_Hstar:
{
ADVANCE_LEXER;
}
break;
case lex_assign:
{
ADVANCE_LEXER;
}
break;
case lex_comma:
{
ADVANCE_LEXER;
}
break;
case lex_div:
{
ADVANCE_LEXER;
}
break;
case lex_div_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_eq:
{
ADVANCE_LEXER;
}
break;
case lex_greater:
{
ADVANCE_LEXER;
}
break;
case lex_greater_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_less:
{
ADVANCE_LEXER;
}
break;
case lex_less_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_lshift:
{
ADVANCE_LEXER;
}
break;
case lex_lshift_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_max:
{
ADVANCE_LEXER;
}
break;
case lex_min:
{
ADVANCE_LEXER;
}
break;
case lex_minus:
{
ADVANCE_LEXER;
}
break;
case lex_minus_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_minus_Hminus:
{
ADVANCE_LEXER;
}
break;
case lex_plus:
{
ADVANCE_LEXER;
}
break;
case lex_plus_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_plus_Hplus:
{
ADVANCE_LEXER;
}
break;
case lex_rem:
{
ADVANCE_LEXER;
}
break;
case lex_rem_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_rshift:
{
ADVANCE_LEXER;
}
break;
case lex_rshift_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_star:
{
ADVANCE_LEXER;
}
break;
case lex_star_Heq:
{
ADVANCE_LEXER;
}
break;
case lex_and_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_and_H1:
break;
default:
goto ZL1;
}
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_compl_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_compl_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_logical_Hand_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_logical_Hand_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_logical_Hor_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_logical_Hor_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_not_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_not_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_not_Heq_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_not_Heq_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_or_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_or_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_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_xor_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;
default:
goto ZL1;
}
}
}
break;
case lex_colon: case lex_dot: case lex_colon_Hcolon:
case lex_dot_Hstar: case lex_sizeof: case lex_typeid:
case lex_alignof: case lex_vtable:
{
{
switch (CURRENT_TERMINAL) {
case lex_alignof:
{
ADVANCE_LEXER;
}
break;
case lex_colon:
{
ADVANCE_LEXER;
}
break;
case lex_colon_Hcolon:
{
ADVANCE_LEXER;
}
break;
case lex_dot:
{
ADVANCE_LEXER;
}
break;
case lex_dot_Hstar:
{
ADVANCE_LEXER;
}
break;
case lex_sizeof:
{
ADVANCE_LEXER;
}
break;
case lex_typeid:
{
ADVANCE_LEXER;
}
break;
case lex_vtable:
{
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
/* Illegal overloaded operator */
report (crt_loc, ERR_over_oper_bad ((*ZI454)));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR1197 (EXP ZI1195, EXP *ZO1196)
{
EXP ZI1196;
ZL2_1197:;
switch (CURRENT_TERMINAL) {
case lex_logical_Hor_H1:
{
EXP ZI460;
EXP ZI435;
{
{
switch (CURRENT_TERMINAL) {
case lex_logical_Hor_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR632 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_log_or_exp ((ZI1195), (ZI460));
}
ZI1195 = ZI435;
goto ZL2_1197;
}
/*UNREACHED*/
default:
{
ZI1196 = ZI1195;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1196 = ZI1196;
}
void
ZR1325 (int *ZO454)
{
int ZI454;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
{
/* Resolve 'operator new []' from 'operator new [3]' */
(ZI0) = predict_array ();
}
if (!ZI0)
goto ZL2;
{
{
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_new_Harray;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
default:
{
{
(ZI454) = lex_new;
}
}
break;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO454 = ZI454;
}
void
ZR871 (IDENTIFIER ZI435)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
ZL2_871:;
{
ZR868 (ZI435);
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
{
/* Extra comma at the end of a list */
report (crt_loc, ERR_lex_extra_comma ());
}
goto ZL2_871;
}
/*UNREACHED*/
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname:
{
goto ZL2_871;
}
/*UNREACHED*/
default:
{
{
/* Extra comma at the end of a list */
report (crt_loc, ERR_lex_extra_comma ());
}
}
break;
}
}
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
break;
}
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR1326 (int *ZO454)
{
int ZI454;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
{
/* Resolve 'operator new []' from 'operator new [3]' */
(ZI0) = predict_array ();
}
if (!ZI0)
goto ZL2;
{
{
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_delete_Harray;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
default:
{
{
(ZI454) = lex_delete;
}
}
break;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO454 = ZI454;
}
void
ZR739 (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;
}
ZR690 (ZI418, ZI693);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI497) = NULL_exp;
}
{
(ZI435) = (ZI497);
in_declaration--;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
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_semicolon: 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:
{
ZR673 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1028 (EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
int ZI674;
EXP ZI497;
EXP ZI460;
EXP ZI724;
EXP ZI562;
EXP ZI463;
switch (CURRENT_TERMINAL) {
case lex_try:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI674) = unreached_code;
if ((ZI674)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI497) = begin_try_stmt (1);
}
{
(ZI460) = begin_compound_stmt (1);
}
{
inject_try_stmt ((ZI497));
}
ZR1027 (ZI460, &ZI724);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI562) = end_compound_stmt ((ZI724));
}
{
(ZI463) = cont_try_stmt ((ZI497), (ZI562));
}
ZR774 (ZI463);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_prev = (ZI674);
}
{
(ZI435) = end_try_stmt ((ZI463), 0);
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1131 (OFFSET ZI460, TYPE ZI578, OFFSET *ZO497, TYPE *ZO418)
{
OFFSET ZI497;
TYPE ZI418;
switch (CURRENT_TERMINAL) {
case lex_dot:
{
ADVANCE_LEXER;
ZR1130 (ZI460, ZI578, &ZI497, &ZI418);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hsquare_H1:
{
EXP ZI435;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR655 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
OFFSET off = offset_index ((ZI578), (ZI435), &(ZI418));
(ZI497) = offset_add ((ZI460), off);
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO497 = ZI497;
*ZO418 = ZI418;
}
void
ZR618 (EXP *ZO1224)
{
EXP ZI1224;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI435;
ZR615 (&ZI435);
ZR1225 (ZI435, &ZI1224);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1224 = ZI1224;
}
void
ZR843 (TYPE ZI418, DECL_SPEC ZI693)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI1340;
TYPE ZI1341;
CV_SPEC ZI1342;
DECL_SPEC ZI1343;
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, &ZI1340, &ZI1341, &ZI1342, &ZI1343);
ZR922 (&ZI418, &ZI1340, &ZI1341, &ZI1342, &ZI1343, &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));
}
ZR1344 (&ZI418, &ZI515, &ZI880, &ZI881, &ZI916);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_export: case lex_template:
{
ZR1094 (ZI418, ZI693);
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_colon: 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;
int ZI724;
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));
}
{
(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 lex_using:
{
{
if (!IS_NULL_type ((ZI418))) report (crt_loc, ERR_temp_decl_bad ());
UNUSED ((ZI693));
}
ZR1057 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_semicolon:
{
TYPE ZI880;
BASE_TYPE ZI515;
CV_SPEC ZI881;
{
(ZI880) = NULL_type;
}
{
(ZI515) = btype_none;
}
{
(ZI881) = cv_none;
}
{
IGNORE empty_decl ((ZI693), (ZI418), (ZI515), (ZI880), (ZI881), last_lex_token, 1);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
have_type_specifier = 0;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
}
void
ZR1201 (EXP ZI1199, EXP *ZO1200)
{
EXP ZI1200;
ZL2_1201:;
switch (CURRENT_TERMINAL) {
case lex_logical_Hand_H1:
{
EXP ZI460;
EXP ZI435;
{
{
switch (CURRENT_TERMINAL) {
case lex_logical_Hand_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR630 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_log_and_exp ((ZI1199), (ZI460));
}
ZI1199 = ZI435;
goto ZL2_1201;
}
/*UNREACHED*/
default:
{
ZI1200 = ZI1199;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1200 = ZI1200;
}
void
ZR741 (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_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:
{
EXP ZI497;
EXP ZI460;
ZR495 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI460) = make_exp_stmt ((ZI497));
}
{
(ZI435) = bind_temporary ((ZI460));
}
}
break;
default:
{
{
(ZI435) = NULL_exp;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1329 (TYPE *ZI578, BASE_TYPE *ZI821, 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;
DECL_SPEC ZI460;
IDENTIFIER ZI501;
int ZI724;
int ZI1327;
DECL_SPEC ZI693;
TYPE ZI1328;
IDENTIFIER ZI562;
{
/* Resolve class-specifiers from elaborated-type-specifiers */
(ZI0) = predict_class (1);
}
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;
}
{
if (!IS_NULL_type ((*ZI578))) template_decl ((*ZI578));
}
{
(ZI460) = crt_access;
}
{
IDENTIFIER id = constr_name (last_namespace, (ZI423));
(ZI501) = begin_class_defn (id, (*ZI821), cinfo_none, (*ZI578));
(ZI724) = in_function_defn;
in_function_defn = 0;
in_class_defn++;
really_in_class_defn++;
no_type_defns++;
}
ZR852 (&ZI1327);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
end_base_class (crt_class, (ZI1327));
}
{
(ZI693) = dspec_none;
}
{
(ZI1328) = NULL_type;
}
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR837 (ZI1328, ZI693);
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
if (crt_access_list.pending) {
IDENTIFIER id = DEREF_id (ctype_name (crt_class));
IGNORE report_access (id);
}
}
{
(ZI562) = end_class_defn ((ZI501));
in_function_defn = (ZI724);
in_class_defn--;
really_in_class_defn--;
}
{
crt_access = (ZI460);
}
{
crt_id_qualifier = (ZI861);
crt_templ_qualifier = (ZI459);
}
{
RESCAN_LEXER;
}
{
MAKE_type_pre (cv_none, btype_alias, crt_id_qualifier, (ZI418));
COPY_id (type_name ((ZI418)), (ZI562));
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:
{
NAMESPACE ZI429;
IDENTIFIER ZI825;
IDENTIFIER ZI423;
{
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;
}
/* END OF FILE */
syntax highlighted by Code2HTML, v. 0.9.1