/*
* 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
parse_mem_type (TYPE *ZO418)
{
TYPE ZI418;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI515;
TYPE ZI501;
CV_SPEC ZI788;
TYPE ZI484;
ZR878 (&ZI515, &ZI501, &ZI788);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI484) = complete_pre_type ((ZI515), (ZI501), (ZI788), 1);
have_type_specifier = 0;
}
{
switch (CURRENT_TERMINAL) {
case lex_rem:
{
QUALIFIER ZI459;
int ZI460;
EXP ZI562;
ADVANCE_LEXER;
{
(ZI459) = crt_id_qualifier;
(ZI460) = crt_templ_qualifier;
}
ZR655 (&ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI418) = make_bitfield_type ((ZI484), (ZI515), (ZI562), 0);
}
{
crt_id_qualifier = (ZI459);
crt_templ_qualifier = (ZI460);
}
}
break;
default:
{
ZR960 (ZI484, &ZI418);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
}
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO418 = ZI418;
}
void
parse_operator (IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
QUALIFIER ZI459;
int ZI460;
int ZI461;
IDENTIFIER ZI464;
switch (CURRENT_TERMINAL) {
case lex_operator:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI459) = crt_id_qualifier;
(ZI460) = crt_templ_qualifier;
}
{
(ZI461) = have_type_declaration;
have_type_declaration = TYPE_DECL_NONE;
}
{
{
TYPE ZI1323;
BASE_TYPE ZI879;
TYPE ZI880;
CV_SPEC ZI881;
BASE_TYPE ZI515;
TYPE ZI501;
CV_SPEC ZI788;
TYPE ZI578;
TYPE ZI484;
TYPE ZI418;
int ZI463;
{
/* Resolve type-specifiers from other declarators */
(ZI0) = predict_tspec (0);
}
if (!ZI0)
goto ZL3;
{
(ZI1323) = NULL_type;
}
ZR877 (ZI1323, &ZI879, &ZI880, &ZI881);
ZR890 (&ZI879, &ZI880, &ZI881, &ZI515, &ZI501, &ZI788);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI578) = complete_pre_type ((ZI515), (ZI501), (ZI788), 1);
have_type_specifier = 0;
}
ZR992 (&ZI484);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI418) = (IS_NULL_type ((ZI484)) ? (ZI578): inject_pre_type ((ZI484), (ZI578), 1));
}
{
int td = have_type_declaration;
(ZI463) = 0;
if (td != TYPE_DECL_NONE) {
if (td == TYPE_DECL_ELABORATE && found_elaborate_type) {
/* This is allowed */
/* EMPTY */
} else {
(ZI463) = 1;
}
}
have_type_declaration = (ZI461);
}
{
HASHID nm = lookup_conv ((ZI418));
if ((ZI463)) report (crt_loc, ERR_class_conv_fct_typedef (nm));
(ZI464) = DEREF_id (hashid_id (nm));
set_hashid_loc ((ZI464), underlying_op);
}
goto ZL2;
}
/*UNREACHED*/
ZL3:;
switch (CURRENT_TERMINAL) {
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_open_Hround: case lex_open_Hsquare_H1: case lex_or_H1:
case lex_or_Heq_H1: case lex_plus: case lex_plus_Heq:
case lex_plus_Hplus: case lex_question: case lex_rem:
case lex_rem_Heq: case lex_rshift: case lex_rshift_Heq:
case lex_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_delete:
case lex_new: case lex_typeid: case lex_alignof:
case lex_vtable:
{
int ZI454;
ZR455 (&ZI454);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
have_type_declaration = (ZI461);
}
{
/* op will be in its primary form */
HASHID nm = lookup_op ((ZI454));
(ZI464) = DEREF_id (hashid_id (nm));
set_hashid_loc ((ZI464), underlying_op);
}
}
break;
default:
goto ZL1;
}
ZL2:;
}
{
crt_id_qualifier = (ZI459);
crt_templ_qualifier = (ZI460);
}
ZI423 = ZI464;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO423 = ZI423;
}
void
ZR1088 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_assign:
{
ADVANCE_LEXER;
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
ZR630 (EXP *ZO1204)
{
EXP ZI1204;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI435;
ZR628 (&ZI435);
ZR1205 (ZI435, &ZI1204);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1204 = ZI1204;
}
void
ZR874 (IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
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;
ZR432 (&ZI429);
ZR512 (&ZI825);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI423) = check_id ((ZI429), (ZI825), 0);
last_namespace = (ZI429);
}
}
break;
default:
{
{
HASHID nm = lookup_anon ();
(ZI423) = DEREF_id (hashid_id (nm));
crt_id_qualifier = qual_none;
qual_namespace = NULL_nspace;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO423 = ZI423;
}
void
ZR755 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_case:
{
EXP ZI562;
ADVANCE_LEXER;
ZR655 (&ZI562);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
report (crt_loc, ERR_stmt_goto_case (lex_case));
(ZI435) = begin_case_stmt ((ZI562), 1);
}
}
break;
case lex_default:
{
ADVANCE_LEXER;
{
report (crt_loc, ERR_stmt_goto_case (lex_default));
(ZI435) = begin_default_stmt (1);
}
}
break;
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname:
{
IDENTIFIER ZI423;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI423 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_namespace_Hname:
{
{
ZI423 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI423 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI423 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
crt_id_qualifier = qual_none;
crt_templ_qualifier = 0;
qual_namespace = NULL_nspace;
}
{
(ZI435) = make_goto_stmt ((ZI423));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR813 (BASE_TYPE *ZO515, TYPE *ZO418)
{
BASE_TYPE ZI515;
TYPE ZI418;
switch (CURRENT_TERMINAL) {
case lex_complex_Htype:
{
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI418 = parse_type_token (id, args);
have_type_declaration = TYPE_DECL_NONE;
have_type_specifier = 1;
RESCAN_LEXER;
}
ADVANCE_LEXER;
{
(ZI515) = btype_none;
}
}
break;
case lex_nested_Hname: case lex_full_Hname: case lex_colon_Hcolon:
{
IDENTIFIER ZI423;
ZR477 (&ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
MAKE_type_pre (cv_none, btype_alias, crt_id_qualifier, (ZI418));
COPY_id (type_name ((ZI418)), (ZI423));
have_type_specifier = 1;
}
{
(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;
}
{
(ZI418) = NULL_type;
have_type_specifier = 1;
}
}
break;
case lex_type_Hname: case lex_template_Htype:
{
IDENTIFIER ZI423;
ZR476 (&ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
MAKE_type_pre (cv_none, btype_alias, crt_id_qualifier, (ZI418));
COPY_id (type_name ((ZI418)), (ZI423));
have_type_specifier = 1;
}
{
(ZI515) = btype_none;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO515 = ZI515;
*ZO418 = ZI418;
}
void
ZR652 (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:
{
EXP ZI497;
ZR500 (&ZI497);
ZR1295 (&ZI497, &ZI501);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_set: case lex_unused:
{
EXP ZI497;
SID_LIST_EXP ZI484;
ZR647 (&ZI497);
ZR652 (&ZI484);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((ZI497), (ZI484), (ZI501));
}
}
break;
case lex_inset_Hstart:
{
EXP ZI497;
SID_LIST_EXP ZI484;
ZR648 (&ZI497);
ZR652 (&ZI484);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((ZI497), (ZI484), (ZI501));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO501 = ZI501;
}
void
ZR980 (int *ZO950)
{
int ZI950;
ZL2_980:;
switch (CURRENT_TERMINAL) {
case lex_ellipsis:
{
ADVANCE_LEXER;
{
(ZI950) = 1;
}
}
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_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:
{
TYPE ZI578;
int ZI501;
IDENTIFIER ZI463;
{
(ZI578) = NULL_type;
}
{
(ZI501) = CONTEXT_PARAMETER;
}
ZR976 (ZI578, ZI501, &ZI463);
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
goto ZL2_980;
}
/*UNREACHED*/
case lex_ellipsis:
{
ADVANCE_LEXER;
{
(ZI950) = 1;
}
}
break;
default:
{
{
(ZI950) = 0;
}
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
}
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO950 = ZI950;
}
void
ZR1257 (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, 0);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
have_type_specifier = 0;
}
{
if (crt_access_list.pending) {
IGNORE report_access (crt_func_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_open_Hround: case lex_star: case lex_colon_Hcolon:
case lex_operator:
{
TYPE ZI884;
DECL_SPEC ZI1078;
TYPE ZI1079;
ACCESS_LIST ZI674;
TYPE ZI578;
IDENTIFIER ZI423;
int ZI562;
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));
}
{
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;
case 358:
return;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR441 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_false: case lex_true:
{
ZR440 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_char_Hexp: case lex_wchar_Hexp:
{
{
switch (CURRENT_TERMINAL) {
case lex_char_Hexp:
{
{
ZI435 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
case lex_wchar_Hexp:
{
{
ZI435 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
}
break;
case lex_floating_Hexp:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_floating_Hexp:
{
ZI435 = crt_token->pp_data.exp;
}
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_integer_Hexp:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_integer_Hexp:
{
ZI435 = crt_token->pp_data.exp;
}
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case lex_string_Hexp: case lex_wstring_Hexp:
{
{
switch (CURRENT_TERMINAL) {
case lex_string_Hexp:
{
{
ZI435 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
case lex_wstring_Hexp:
{
{
ZI435 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR944 (SID_LIST_TYPE *ZO501)
{
SID_LIST_TYPE ZI501;
switch (CURRENT_TERMINAL) {
case lex_throw:
{
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
switch (CURRENT_TERMINAL) {
case lex_ellipsis:
{
ADVANCE_LEXER;
{
report (crt_loc, ERR_except_spec_ellipsis ());
(ZI501) = univ_type_set;
}
}
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_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:
{
ZR1109 (&ZI501);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI501) = NULL_list (TYPE);
}
}
break;
}
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
default:
{
{
(ZI501) = empty_type_set;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO501 = ZI501;
}
void
parse_decl (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:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
}
ZL0:;
}
void
ZR1259 (TYPE *ZI418, DECL_SPEC *ZI693, BASE_TYPE *ZI515, TYPE *ZI880, CV_SPEC *ZI1258, EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_semicolon:
{
{
IGNORE empty_decl ((*ZI693), (*ZI418), (*ZI515), (*ZI880), (*ZI1258), last_lex_token, 0);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
have_type_specifier = 0;
}
ADVANCE_LEXER;
{
(ZI435) = NULL_exp;
}
}
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:
{
DECL_SPEC ZI914;
DECL_SPEC ZI916;
TYPE ZI884;
DECL_SPEC ZI1078;
TYPE ZI1079;
ACCESS_LIST ZI674;
TYPE ZI578;
IDENTIFIER ZI423;
int ZI562;
IDENTIFIER ZI463;
{
(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), (*ZI1258));
(ZI884) = complete_pre_type ((*ZI515), (*ZI880), (*ZI1258), 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 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1387 (TYPE *ZI1385, 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)) ? (*ZI1385): inject_pre_type ((ZI484), (*ZI1385), 0));
}
}
break;
default:
{
ZI418 = *ZI1385;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO418 = ZI418;
}
void
ZR1260 (void)
{
switch (CURRENT_TERMINAL) {
case lex_hash_Hif: case lex_hash_Hpragma:
{
ZR1035 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (crt_access_list.pending) {
IGNORE report_access (crt_func_id);
}
}
}
break;
case lex_asm: case lex_namespace: case lex_using:
{
EXP ZI435;
ZR1082 (&ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
external_declaration ((ZI435), 1);
}
}
break;
case 358:
return;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR1006 (IDENTIFIER *ZI463, 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_Hbrace_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:
{
ZR1004 (*ZI463, &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
ZR628 (EXP *ZO1208)
{
EXP ZI1208;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI435;
ZR626 (&ZI435);
ZR1209 (ZI435, &ZI1208);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1208 = ZI1208;
}
void
ZR682 (EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI562;
EXP ZI497;
{
(ZI562) = begin_compound_stmt (1);
}
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
COPY_int (exp_sequence_block ((ZI562)), 2);
}
ZR680 (ZI562, &ZI497);
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI435) = end_compound_stmt ((ZI497));
}
{
RESCAN_LEXER;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1388 (TYPE *ZO1143)
{
TYPE ZI1143;
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 ZI418;
ZR956 (&ZI418);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (IS_NULL_type ((ZI418))) {
report (crt_loc, ERR_dcl_meaning_paren ());
}
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR1144 (ZI418, &ZI1143);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_type_Hname: case lex_template_Htype: case lex_nested_Hname:
case lex_full_Hname: case lex_complex_Htype: case lex_close_Hround:
case lex_ellipsis: case lex_colon_Hcolon: case lex_auto:
case lex_char: case lex_const: case lex_double:
case lex_enum: case lex_extern: case lex_float:
case lex_int: case lex_long: case lex_register:
case lex_short: case lex_signed: case lex_static:
case lex_struct: case lex_typedef: case lex_union:
case lex_unsigned: case lex_void: case lex_volatile:
case lex_restrict: case lex_bool: case lex_class:
case lex_explicit: case lex_friend: case lex_inline:
case lex_mutable: case lex_typename: case lex_virtual:
case lex_wchar_Ht: case lex_bottom: case lex_overload:
case lex_ptrdiff_Ht: case lex_size_Ht:
{
IDENTIFIER ZI423;
int ZI948;
TYPE ZI418;
{
(ZI423) = NULL_id;
crt_id_qualifier = qual_none;
qual_namespace = NULL_nspace;
}
{
(ZI948) = 0;
}
{
func_type_defn (0);
begin_param ((ZI423));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR949 (ZI948, &ZI418);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
ZR1144 (ZI418, &ZI1143);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1143 = ZI1143;
}
void
ZR422 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
return;
ZL1:;
{
int ZI418;
{
(ZI418) = lex_semicolon;
}
{
/* Expected symbol */
int p = primary_form (crt_lex_token);
if (p != (ZI418)) report (crt_loc, ERR_lex_expect ((ZI418)));
}
}
}
void
ZR634 (EXP *ZO1196)
{
EXP ZI1196;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI435;
ZR632 (&ZI435);
ZR1197 (ZI435, &ZI1196);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1196 = ZI1196;
}
void
ZR655 (EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI497;
ZR636 (&ZI497);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = convert_reference ((ZI497), REF_NORMAL);
(ZI435) = convert_lvalue ((ZI435));
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR1120 (IDENTIFIER *ZO423)
{
IDENTIFIER ZI423;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname:
{
IDENTIFIER ZI464;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI464 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_namespace_Hname:
{
{
ZI464 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI464 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI464 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
(ZI423) = (ZI464);
crt_id_qualifier = qual_none;
last_namespace = crt_namespace;
}
}
break;
default:
{
{
HASHID nm = lookup_anon ();
(ZI423) = DEREF_id (hashid_id (nm));
crt_id_qualifier = qual_none;
qual_namespace = NULL_nspace;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO423 = ZI423;
}
void
ZR1389 (SID_LIST_TYPE *ZO484)
{
SID_LIST_TYPE ZI484;
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:
{
ZR1109 (&ZI484);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
/* Extra comma at the end of a list */
report (crt_loc, ERR_lex_extra_comma ());
}
{
(ZI484) = NULL_list (TYPE);
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO484 = ZI484;
}
void
ZR1262 (void)
{
switch (CURRENT_TERMINAL) {
case lex_typename:
{
NAMESPACE ZI429;
IDENTIFIER ZI423;
TYPE ZI418;
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;
}
{
using_typename ((ZI418));
}
ZR422 ();
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_colon_Hcolon: case lex_operator:
{
IDENTIFIER ZI423;
ZR947 (&ZI423);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
IGNORE using_identifier ((ZI423));
}
ZR422 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR1263 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_type_Hname: case lex_namespace_Hname:
case lex_statement_Hname:
{
IDENTIFIER ZI1045;
IDENTIFIER ZI423;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI1045 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_namespace_Hname:
{
{
ZI1045 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI1045 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI1045 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
(ZI423) = (ZI1045);
crt_id_qualifier = qual_none;
last_namespace = crt_namespace;
}
{
IDENTIFIER pid = underlying_id ((ZI423));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR1438 (&ZI423, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hbrace_H1:
{
DECL_SPEC ZI693;
TYPE ZI418;
{
decl_loc = crt_loc;
begin_namespace (NULL_id, 1);
}
{
(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 (1);
}
{
{
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
ZR931 (TYPE *ZO501)
{
TYPE ZI501;
switch (CURRENT_TERMINAL) {
case lex_full_Hname_Hstar:
{
IDENTIFIER ZI423;
CV_SPEC ZI788;
{
ZI423 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
ZR793 (&ZI788);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CLASS_TYPE ct = find_class ((ZI423));
if (IS_NULL_ctype (ct)) {
report (crt_loc, ERR_dcl_mptr_type ((ZI423)));
MAKE_type_ptr ((ZI788), NULL_type, (ZI501));
} else {
MAKE_type_ptr_mem ((ZI788), ct, NULL_type, (ZI501));
}
}
}
break;
case lex_nested_Hname_Hstar:
{
IDENTIFIER ZI423;
CV_SPEC ZI788;
{
ZI423 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
ZR793 (&ZI788);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CLASS_TYPE ct = find_class ((ZI423));
if (IS_NULL_ctype (ct)) {
report (crt_loc, ERR_dcl_mptr_type ((ZI423)));
MAKE_type_ptr ((ZI788), NULL_type, (ZI501));
} else {
MAKE_type_ptr_mem ((ZI788), ct, NULL_type, (ZI501));
}
}
}
break;
case lex_star:
{
CV_SPEC ZI788;
ADVANCE_LEXER;
ZR793 (&ZI788);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
MAKE_type_ptr ((ZI788), NULL_type, (ZI501));
}
}
break;
case lex_and_H1:
{
CV_SPEC ZI788;
{
{
switch (CURRENT_TERMINAL) {
case lex_and_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR793 (&ZI788);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* Can't have const-volatile qualified references */
if ((ZI788)) report (crt_loc, ERR_dcl_ref_cv ((ZI788)));
MAKE_type_ref (cv_none, NULL_type, (ZI501));
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO501 = ZI501;
}
void
ZR1264 (EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_namespace:
{
NAMESPACE ZI1052;
IDENTIFIER ZI1053;
IDENTIFIER ZI423;
NAMESPACE ZI429;
ADVANCE_LEXER;
ZR432 (&ZI1052);
ZR512 (&ZI1053);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI423) = check_id ((ZI1052), (ZI1053), 0);
last_namespace = (ZI1052);
}
{
(ZI429) = find_nspace_id ((ZI423));
}
{
using_namespace ((ZI429));
}
ZR422 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = NULL_exp;
}
}
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_colon_Hcolon: case lex_operator: case lex_typename:
{
ZR1262 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = NULL_exp;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR850 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
ZL2_850:;
{
ZR847 ();
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
goto ZL2_850;
}
/*UNREACHED*/
case 358:
RESTORE_LEXER;
goto ZL1;
default:
break;
}
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR1067 (TYPE ZI418, DECL_SPEC ZI693, EXP *ZO435)
{
EXP ZI435;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI562;
DECL_SPEC ZI497;
DECL_SPEC ZI460;
DECL_SPEC ZI1068;
DECL_SPEC ZI914;
EXP ZI768;
switch (CURRENT_TERMINAL) {
case lex_extern:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
switch (CURRENT_TERMINAL) {
case lex_string_Hexp:
{
{
ZI562 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
case lex_wstring_Hexp:
{
{
ZI562 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
(ZI497) = find_linkage ((ZI562));
}
{
(ZI460) = crt_linkage;
crt_linkage = (ZI497);
IGNORE incr_value (OPT_VAL_external_specs);
}
{
(ZI1068) = (dspec_extern | dspec_c);
}
{
/* Combine two declaration specifiers */
DECL_SPEC d = (((ZI693) & (ZI1068)) & dspec_duplicate);
if (d) report (crt_loc, ERR_dcl_spec_dup (d));
(ZI914) = ((ZI693) | (ZI1068));
}
{
{
BASE_TYPE ZI1253;
TYPE ZI1254;
CV_SPEC ZI1255;
DECL_SPEC ZI1256;
BASE_TYPE ZI515;
TYPE ZI880;
CV_SPEC ZI881;
DECL_SPEC ZI1605;
DECL_SPEC ZI916;
{
/* Resolve declaration-specifiers from other declarators */
(ZI0) = predict_dspec (0);
}
if (!ZI0)
goto ZL4;
ZR911 (ZI418, &ZI1253, &ZI1254, &ZI1255, &ZI1256);
ZR922 (&ZI418, &ZI1253, &ZI1254, &ZI1255, &ZI1256, &ZI515, &ZI880, &ZI881, &ZI1605);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* Combine two declaration specifiers */
DECL_SPEC d = (((ZI914) & (ZI1605)) & dspec_duplicate);
if (d) report (crt_loc, ERR_dcl_spec_dup (d));
(ZI916) = ((ZI914) | (ZI1605));
}
ZR1257 (&ZI418, &ZI515, &ZI880, &ZI881, &ZI916);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI768) = NULL_exp;
}
{
decr_value (OPT_VAL_external_specs);
crt_linkage = (ZI460);
}
goto ZL3;
}
/*UNREACHED*/
ZL4:;
switch (CURRENT_TERMINAL) {
case lex_extern:
{
ZR1067 (ZI418, ZI914, &ZI768);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
decr_value (OPT_VAL_external_specs);
crt_linkage = (ZI460);
}
}
break;
case lex_open_Hbrace_H1:
{
TYPE ZI884;
DECL_SPEC ZI916;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
if (!IS_NULL_type ((ZI418))) report (crt_loc, ERR_temp_decl_bad ());
UNUSED ((ZI914));
}
{
(ZI884) = NULL_type;
}
{
(ZI916) = dspec_none;
}
ZR1032 (ZI884, ZI916);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
decr_value (OPT_VAL_external_specs);
crt_linkage = (ZI460);
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI768) = NULL_exp;
}
}
break;
case lex_export: case lex_template:
{
ZR1077 (ZI418, ZI914, &ZI768);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
decr_value (OPT_VAL_external_specs);
crt_linkage = (ZI460);
}
}
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;
{
(ZI515) = btype_none;
}
{
(ZI880) = NULL_type;
}
{
(ZI1258) = cv_none;
}
ZR1259 (&ZI418, &ZI914, &ZI515, &ZI880, &ZI1258, &ZI768);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
decr_value (OPT_VAL_external_specs);
crt_linkage = (ZI460);
}
}
break;
case lex_asm: case lex_namespace: case lex_using:
{
{
if (!IS_NULL_type ((ZI418))) report (crt_loc, ERR_temp_decl_bad ());
UNUSED ((ZI914));
}
ZR1082 (&ZI768);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
decr_value (OPT_VAL_external_specs);
crt_linkage = (ZI460);
}
}
break;
default:
goto ZL1;
}
ZL3:;
}
ZI435 = ZI768;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR503 (SID_LIST_EXP *ZO484)
{
SID_LIST_EXP ZI484;
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
ZR502 (&ZI484);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI484) = NULL_list (EXP);
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO484 = ZI484;
}
void
ZR621 (EXP *ZO1220)
{
EXP ZI1220;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI435;
ZR618 (&ZI435);
ZR1221 (ZI435, &ZI1220);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1220 = ZI1220;
}
void
ZR1014 (DECL_SPEC ZI693, BASE_TYPE ZI515, TYPE ZI418, ACCESS_LIST ZI674)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
ZL2_1014:;
{
ZR1013 (ZI693, ZI515, ZI418, ZI674);
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
{
crt_templ_qualifier = 0;
}
goto ZL2_1014;
}
/*UNREACHED*/
case 358:
RESTORE_LEXER;
goto ZL1;
default:
break;
}
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR1267 (EXP *ZI1265, EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_question:
{
EXP ZI497;
EXP ZI460;
ADVANCE_LEXER;
ZR495 (&ZI497);
switch (CURRENT_TERMINAL) {
case lex_colon:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR500 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_cond_exp ((*ZI1265), (ZI497), (ZI460));
}
}
break;
default:
{
ZI435 = *ZI1265;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
void
ZR609 (EXP *ZO1236)
{
EXP ZI1236;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI435;
ZR605 (&ZI435);
ZR1237 (ZI435, &ZI1236);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO1236 = ZI1236;
}
void
ZR1269 (EXP *ZI1268, EXP *ZO435)
{
EXP ZI435;
switch (CURRENT_TERMINAL) {
case lex_assign:
{
EXP ZI460;
ADVANCE_LEXER;
ZR500 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI435) = make_assign_exp ((*ZI1268), (ZI460), 0);
}
}
break;
default:
{
ZR1267 (ZI1268, &ZI435);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_and_Heq_H1: case lex_div_Heq: case lex_lshift_Heq:
case lex_minus_Heq: case lex_or_Heq_H1: case lex_plus_Heq:
case lex_rem_Heq: case lex_rshift_Heq: case lex_star_Heq:
case lex_xor_Heq_H1:
{
int ZI454;
EXP ZI460;
{
(ZI454) = crt_lex_token;
}
ZR643 ();
ZR500 (&ZI460);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* op will be in its primary form */
(ZI435) = make_become_exp ((ZI454), (*ZI1268), (ZI460));
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO435 = ZI435;
}
/* BEGINNING OF TRAILER */
/* END OF FILE */
syntax highlighted by Code2HTML, v. 0.9.1