/*
* Automatically generated from the files:
* /mnt/gmirror/ports/lang/TenDRA/work/tendra/src/producers/c/syntax/syntax.sid
* and
* /mnt/gmirror/ports/lang/TenDRA/work/tendra/src/producers/c/syntax/syntax.act
* by:
* /mnt/gmirror/ports/lang/TenDRA/work/tendra/obj/utilities/sid/sid
*/
/* BEGINNING OF HEADER */
#define __SID_SPLIT
/*
* Crown Copyright (c) 1997, 1998
*
* This TenDRA(r) Computer Program is subject to Copyright
* owned by the United Kingdom Secretary of State for Defence
* acting through the Defence Evaluation and Research Agency
* (DERA). It is made available to Recipients with a
* royalty-free licence for its use, reproduction, transfer
* to other parties and amendment for any purpose not excluding
* product development provided that any such use et cetera
* shall be deemed to be acceptance of the following conditions:-
*
* (1) Its Recipients shall ensure that this Notice is
* reproduced upon any copies or amended versions of it;
*
* (2) Any amended version of it shall be clearly marked to
* show both the nature of and the organisation responsible
* for the relevant amendment or amendments;
*
* (3) Its onward transfer from a recipient to another
* party shall be deemed to be that party's acceptance of
* these conditions;
*
* (4) DERA gives no warranty or assurance as to its
* quality or suitability for any purpose and DERA accepts
* no liability whatsoever in relation to any use to which
* it may be put.
*/
#include "config.h"
#include "producer.h"
#include "c_types.h"
#include "exp_ops.h"
#include "hashid_ops.h"
#include "id_ops.h"
#include "type_ops.h"
#include "error.h"
#include "catalog.h"
#include "option.h"
#include "access.h"
#include "allocate.h"
#include "assign.h"
#include "basetype.h"
#include "cast.h"
#include "chktype.h"
#include "class.h"
#include "constant.h"
#include "construct.h"
#include "convert.h"
#include "declare.h"
#include "derive.h"
#include "dump.h"
#include "exception.h"
#include "expression.h"
#include "function.h"
#include "hash.h"
#include "identifier.h"
#include "initialise.h"
#include "inttype.h"
#include "label.h"
#include "lex.h"
#include "literal.h"
#include "member.h"
#include "namespace.h"
#include "parse.h"
#include "pragma.h"
#include "predict.h"
#include "preproc.h"
#include "redeclare.h"
#include "rewrite.h"
#include "statement.h"
#include "symbols.h"
#include "template.h"
#include "tokdef.h"
#include "token.h"
#include "typeid.h"
#include "variable.h"
/*
* COMPOUND TYPE ALIASES
*
* These are the aliases for the compound types used in the parser.
*/
typedef LIST (EXP) SID_LIST_EXP;
/*
* FUNCTION DECLARATIONS
*
* The function declarations are included at this point so that the
* type definitions are in scope.
*/
#include "syntax.h"
/*
* COMPILATION MODE
*
* The output of sid is automatically generated. Hence it is not
* necessarily appropriate to apply the same level of checking to this
* as to the rest of the program. These pragmas describe the relaxations
* allowed for the sid output.
*/
#if FS_TENDRA
#pragma TenDRA begin
#pragma TenDRA const conditional allow
#pragma TenDRA unreachable code allow
#pragma TenDRA variable analysis off
#endif
/* BEGINNING OF STATIC VARIABLES */
int ZI0;
/* BEGINNING OF FUNCTION DEFINITIONS */
void
ZR667 (BASE_TYPE *ZO666)
{
BASE_TYPE ZI666;
switch (CURRENT_TERMINAL) {
case lex_bool:
{
ADVANCE_LEXER;
{
(ZI666) = btype_bool;
}
}
break;
case lex_bottom:
{
ADVANCE_LEXER;
{
(ZI666) = btype_bottom;
}
}
break;
case lex_char:
{
ADVANCE_LEXER;
{
(ZI666) = btype_char;
}
}
break;
case lex_double:
{
ADVANCE_LEXER;
{
(ZI666) = btype_double;
}
}
break;
case lex_float:
{
ADVANCE_LEXER;
{
(ZI666) = btype_float;
}
}
break;
case lex_int:
{
ADVANCE_LEXER;
{
(ZI666) = btype_int;
}
}
break;
case lex_long:
{
ADVANCE_LEXER;
{
(ZI666) = btype_long;
}
}
break;
case lex_ptrdiff_Ht:
{
ADVANCE_LEXER;
{
(ZI666) = btype_ptrdiff_t;
}
}
break;
case lex_short:
{
ADVANCE_LEXER;
{
(ZI666) = btype_short;
}
}
break;
case lex_signed:
{
ADVANCE_LEXER;
{
(ZI666) = btype_signed;
}
}
break;
case lex_size_Ht:
{
ADVANCE_LEXER;
{
(ZI666) = btype_size_t;
}
}
break;
case lex_unsigned:
{
ADVANCE_LEXER;
{
(ZI666) = btype_unsigned;
}
}
break;
case lex_void:
{
ADVANCE_LEXER;
{
(ZI666) = btype_void;
}
}
break;
case lex_wchar_Ht:
{
ADVANCE_LEXER;
{
(ZI666) = btype_wchar_t;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO666 = ZI666;
}
void
ZR765 (TYPE *ZO573)
{
TYPE ZI573;
switch (CURRENT_TERMINAL) {
case lex_type_Hname: case lex_complex_Htype: case lex_ellipsis:
case lex_auto: case lex_char: case lex_const:
case lex_double: case lex_enum: case lex_extern:
case lex_float: case lex_int: case lex_long:
case lex_register: case lex_short: case lex_signed:
case lex_static: case lex_struct: case lex_typedef:
case lex_union: case lex_unsigned: case lex_void:
case lex_volatile: case lex_restrict: case lex_bool:
case lex_inline: case lex_wchar_Ht: case lex_bottom:
case lex_ptrdiff_Ht: case lex_size_Ht:
{
int ZI757;
ZR753 (&ZI757);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI573) = make_func_type (NULL_type, (ZI757), cv_c, empty_type_set);
}
}
break;
default:
{
{
(ZI573) = make_func_type (NULL_type, FUNC_NO_PARAMS, cv_c, empty_type_set);
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO573 = ZI573;
}
void
ZR725 (BASE_TYPE *ZO666, TYPE *ZO399, CV_SPEC *ZO637, DECL_SPEC *ZO611)
{
BASE_TYPE ZI666;
TYPE ZI399;
CV_SPEC ZI637;
DECL_SPEC ZI611;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI696;
TYPE ZI697;
CV_SPEC ZI698;
DECL_SPEC ZI726;
ZR723 (&ZI696, &ZI697, &ZI698, &ZI726);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* A type-name can be a declarator-id */
if (have_type_specifier && crt_lex_token == lex_type_Hname) {
crt_lex_token = lex_identifier;
}
}
{
switch (CURRENT_TERMINAL) {
case lex_type_Hname: case lex_complex_Htype: case lex_auto:
case lex_char: case lex_const: case lex_double:
case lex_enum: case lex_extern: case lex_float:
case lex_int: case lex_long: case lex_register:
case lex_short: case lex_signed: case lex_static:
case lex_struct: case lex_typedef: case lex_union:
case lex_unsigned: case lex_void: case lex_volatile:
case lex_restrict: case lex_bool: case lex_inline:
case lex_wchar_Ht: case lex_bottom: case lex_ptrdiff_Ht:
case lex_size_Ht:
{
BASE_TYPE ZI700;
TYPE ZI701;
CV_SPEC ZI702;
DECL_SPEC ZI728;
ZR725 (&ZI700, &ZI701, &ZI702, &ZI728);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if ((ZI696) & (ZI700)) {
(ZI666) = join_pre_types ((ZI696), (ZI700));
} else {
(ZI666) = ((ZI696) | (ZI700));
}
}
{
/* Join two partial types */
if (IS_NULL_type ((ZI697))) {
(ZI399) = (ZI701);
} else if (IS_NULL_type ((ZI701))) {
(ZI399) = (ZI697);
} else {
report (crt_loc, ERR_dcl_type_simple_many ((ZI697), (ZI701)));
(ZI399) = (ZI701);
}
}
{
CV_SPEC c = ((ZI698) & (ZI702));
if (c) report (crt_loc, ERR_dcl_type_cv_dup (c));
(ZI637) = ((ZI698) | (ZI702));
}
{
/* Combine two declaration specifiers */
DECL_SPEC d = (((ZI726) & (ZI728)) & dspec_duplicate);
/* Duplicate inline is allowed */
if (d & ~dspec_inline) report (crt_loc, ERR_dcl_spec_dup (d));
(ZI611) = ((ZI726) | (ZI728));
}
}
break;
default:
{
ZI666 = ZI696;
ZI399 = ZI697;
ZI637 = ZI698;
ZI611 = ZI726;
}
break;
}
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO666 = ZI666;
*ZO399 = ZI399;
*ZO637 = ZI637;
*ZO611 = ZI611;
}
void
ZR755 (IDENTIFIER ZI403, TYPE *ZO399)
{
TYPE ZI399;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
{
TYPE ZI573;
ADVANCE_LEXER;
{
func_type_defn (0);
begin_param ((ZI403));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
{
switch (CURRENT_TERMINAL) {
case lex_type_Hname: case lex_complex_Htype: case lex_ellipsis:
case lex_auto: case lex_char: case lex_const:
case lex_double: case lex_enum: case lex_extern:
case lex_float: case lex_int: case lex_long:
case lex_register: case lex_short: case lex_signed:
case lex_static: case lex_struct: case lex_typedef:
case lex_union: case lex_unsigned: case lex_void:
case lex_volatile: case lex_restrict: case lex_bool:
case lex_inline: case lex_wchar_Ht: case lex_bottom:
case lex_ptrdiff_Ht: case lex_size_Ht:
{
int ZI757;
ZR753 (&ZI757);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI573) = make_func_type (NULL_type, (ZI757), cv_c, empty_type_set);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_identifier: case lex_statement_Hname:
{
ZR754 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI573) = make_func_type (NULL_type, FUNC_PARAMS, cv_c, empty_type_set);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_close_Hround:
{
{
(ZI573) = make_func_type (NULL_type, FUNC_NO_PARAMS, cv_c, empty_type_set);
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
ZI399 = ZI573;
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
}
break;
case lex_weak:
{
int ZI757;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
func_type_defn (0);
begin_param ((ZI403));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR760 (&ZI757);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = make_func_type (NULL_type, ((ZI757) | FUNC_WEAK), cv_c, empty_type_set);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
}
break;
case lex_open_Hsquare_H1:
{
EXP ZI408;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR759 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
NAT n = make_array_dim ((ZI408));
MAKE_type_array (cv_none, NULL_type, n, (ZI399));
}
{
{
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:;
*ZO399 = ZI399;
}
void
ZR780 (IDENTIFIER *ZO552)
{
IDENTIFIER ZI552;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI666;
TYPE ZI697;
CV_SPEC ZI637;
DECL_SPEC ZI726;
TYPE ZI701;
DECL_SPEC ZI611;
TYPE ZI399;
IDENTIFIER ZI403;
ZR725 (&ZI666, &ZI697, &ZI637, &ZI726);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* Complete a declaration specifier and a type */
(ZI611) = complete_dspec ((ZI726), (ZI666), (ZI697), (ZI637));
(ZI701) = complete_pre_type ((ZI666), (ZI697), (ZI637), 0);
have_type_specifier = 0;
}
ZR776 (ZI701, &ZI399, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI552) = make_param_decl ((ZI611), (ZI399), (ZI403), CONTEXT_PARAMETER);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO552 = ZI552;
}
void
ZR895 (EXP ZI889, EXP ZI890, int ZI891, EXP *ZO892, EXP *ZO893, int *ZO894)
{
EXP ZI892;
EXP ZI893;
int ZI894;
ZL2_895:;
switch (CURRENT_TERMINAL) {
case lex_hash_Helif:
{
EXP ZI424;
int ZI541;
EXP ZI471;
int ZI573;
EXP ZI452;
EXP ZI408;
ZI424 = ZI890;
ZI541 = ZI891;
{
ZI471 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
{
EXP c = make_else_cond (crt_hash_cond);
crt_hash_cond = make_if_cond ((ZI471), c);
}
{
(ZI573) = unreached_code;
if ((ZI573)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
ZR556 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
unreached_prev = (ZI541);
}
{
(ZI408) = cont_hash_if_stmt ((ZI889), (ZI471), (ZI452));
}
ZI889 = ZI408;
ZI890 = ZI424;
ZI891 = ZI541;
goto ZL2_895;
}
/*UNREACHED*/
default:
{
ZI892 = ZI889;
ZI893 = ZI890;
ZI894 = ZI891;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO892 = ZI892;
*ZO893 = ZI893;
*ZO894 = ZI894;
}
void
ZR574 (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI420;
EXP ZI424;
int ZI541;
EXP ZI452;
ZR572 (&ZI420, &ZI424, &ZI541);
{
switch (CURRENT_TERMINAL) {
case lex_hash_Helse:
{
int ZI573;
ADVANCE_LEXER;
{
crt_hash_cond = make_else_cond (crt_hash_cond);
}
{
(ZI573) = unreached_code;
if ((ZI573)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
ZR556 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI452) = NULL_exp;
}
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
}
}
{
crt_hash_cond = (ZI424);
}
switch (CURRENT_TERMINAL) {
case lex_hash_Hendif:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
unreached_prev = (ZI541);
}
{
(ZI408) = end_hash_if_stmt ((ZI420), (ZI452));
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR664 (TYPE *ZO399)
{
TYPE ZI399;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI677;
ZR678 (&ZI677);
{
switch (CURRENT_TERMINAL) {
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
{
IDENTIFIER ZI403;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
ZR1040 (&ZI677, &ZI403, &ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hbrace_H1:
{
IDENTIFIER ZI403;
IDENTIFIER ZI424;
int ZI590;
IDENTIFIER ZI680;
{
HASHID nm = lookup_anon ();
(ZI403) = DEREF_id (hashid_id (nm));
}
{
(ZI424) = begin_class_defn ((ZI403), (ZI677), cinfo_none, NULL_type);
(ZI590) = in_function_defn;
in_function_defn = 0;
in_class_defn++;
really_in_class_defn++;
no_type_defns++;
end_base_class (crt_class, 1);
}
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR670 ();
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI680) = end_class_defn ((ZI424));
in_function_defn = (ZI590);
in_class_defn--;
really_in_class_defn--;
}
{
MAKE_type_pre (cv_none, btype_alias, qual_none, (ZI399));
COPY_id (type_name ((ZI399)), (ZI680));
have_type_specifier = 1;
}
{
RESCAN_LEXER;
}
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
}
void
ZR899 (EXP ZI897, EXP *ZO898)
{
EXP ZI898;
ZL2_899:;
switch (CURRENT_TERMINAL) {
case lex_logical_Hor_H1:
{
EXP ZI452;
EXP ZI408;
{
{
switch (CURRENT_TERMINAL) {
case lex_logical_Hor_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR503 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_log_or_exp ((ZI897), (ZI452));
}
ZI897 = ZI408;
goto ZL2_899;
}
/*UNREACHED*/
default:
{
ZI898 = ZI897;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO898 = ZI898;
}
void
ZR431 (NAMESPACE ZI430, IDENTIFIER *ZO403)
{
IDENTIFIER ZI403;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
IDENTIFIER ZI432;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI432 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI432 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI432 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
HASHID nm = DEREF_hashid (id_name ((ZI432)));
(ZI403) = find_qual_id ((ZI430), nm, 1, 0);
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO403 = ZI403;
}
void
ZR723 (BASE_TYPE *ZO666, TYPE *ZO399, CV_SPEC *ZO637, DECL_SPEC *ZO611)
{
BASE_TYPE ZI666;
TYPE ZI399;
CV_SPEC ZI637;
DECL_SPEC ZI611;
switch (CURRENT_TERMINAL) {
case lex_const: case lex_volatile: case lex_restrict:
{
ZR638 (&ZI637);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI666) = btype_none;
}
{
(ZI399) = NULL_type;
}
{
(ZI611) = dspec_none;
}
}
break;
case lex_type_Hname: case lex_complex_Htype: case lex_char:
case lex_double: case lex_enum: case lex_float:
case lex_int: case lex_long: case lex_short:
case lex_signed: case lex_struct: case lex_union:
case lex_unsigned: case lex_void: case lex_bool:
case lex_wchar_Ht: case lex_bottom: case lex_ptrdiff_Ht:
case lex_size_Ht:
{
ZR668 (&ZI666, &ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI637) = cv_none;
}
{
(ZI611) = dspec_none;
}
}
break;
case lex_auto: case lex_extern: case lex_register:
case lex_static: case lex_typedef: case lex_inline:
{
{
switch (CURRENT_TERMINAL) {
case lex_inline:
{
ZR718 (&ZI611);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_auto: case lex_extern: case lex_register:
case lex_static: case lex_typedef:
{
ZR716 (&ZI611);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
goto ZL1;
}
}
{
if (have_type_specifier) report (crt_loc, ERR_dcl_spec_order ((ZI611)));
}
{
(ZI666) = btype_none;
}
{
(ZI399) = NULL_type;
}
{
(ZI637) = cv_none;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO666 = ZI666;
*ZO399 = ZI399;
*ZO637 = ZI637;
*ZO611 = ZI611;
}
void
parse_init (IDENTIFIER ZI552, EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
ZR798 (ZI552, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI408) = NULL_exp;
}
}
ZL0:;
*ZO408 = ZI408;
}
void
ZR813 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
ZL2_813:;
{
BASE_TYPE ZI947;
TYPE ZI948;
CV_SPEC ZI949;
DECL_SPEC ZI950;
BASE_TYPE ZI951;
TYPE ZI952;
CV_SPEC ZI953;
DECL_SPEC ZI954;
EXP ZI408;
{
/* Resolve declaration-specifiers from other declarators */
(ZI0) = predict_dspec (0);
}
if (!ZI0)
goto ZL3;
ZR723 (&ZI947, &ZI948, &ZI949, &ZI950);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* A type-name can be a declarator-id */
if (have_type_specifier && crt_lex_token == lex_type_Hname) {
crt_lex_token = lex_identifier;
}
}
ZR734 (&ZI947, &ZI948, &ZI949, &ZI950, &ZI951, &ZI952, &ZI953, &ZI954);
ZR955 (&ZI951, &ZI952, &ZI953, &ZI954, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
external_declaration ((ZI408), 1);
}
goto ZL2_813;
}
/*UNREACHED*/
ZL3:;
switch (CURRENT_TERMINAL) {
case lex_semicolon:
{
ADVANCE_LEXER;
{
report (crt_loc, ERR_dcl_dcl_semicolon ());
}
goto ZL2_813;
}
/*UNREACHED*/
case lex_asm:
{
EXP ZI408;
ZR629 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
external_declaration ((ZI408), 1);
}
goto ZL2_813;
}
/*UNREACHED*/
case lex_hash_Hif: case lex_hash_Hpragma:
{
ZR816 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
} else {
goto ZL2_813;
}
}
/*UNREACHED*/
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
case lex_open_Hround: case lex_star:
{
BASE_TYPE ZI666;
TYPE ZI697;
CV_SPEC ZI637;
DECL_SPEC ZI726;
TYPE ZI399;
DECL_SPEC ZI611;
TYPE ZI573;
IDENTIFIER ZI403;
EXP ZI408;
{
(ZI666) = btype_none;
}
{
(ZI697) = NULL_type;
}
{
(ZI637) = cv_none;
}
{
(ZI726) = dspec_none;
}
{
/* Complete a declaration specifier and a type */
(ZI611) = complete_dspec ((ZI726), (ZI666), (ZI697), (ZI637));
(ZI399) = complete_pre_type ((ZI666), (ZI697), (ZI637), 0);
have_type_specifier = 0;
}
ZR762 (ZI399, &ZI573, &ZI403);
ZR829 (&ZI666, &ZI399, &ZI611, &ZI573, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = NULL_exp;
}
{
external_declaration ((ZI408), 1);
}
goto ZL2_813;
}
/*UNREACHED*/
default:
break;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR764 (TYPE *ZO399)
{
TYPE ZI399;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
{
IDENTIFIER ZI403;
TYPE ZI573;
ADVANCE_LEXER;
{
(ZI403) = NULL_id;
}
{
func_type_defn (0);
begin_param ((ZI403));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR765 (&ZI573);
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZI399 = ZI573;
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
}
break;
case lex_weak:
{
IDENTIFIER ZI403;
int ZI757;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI403) = NULL_id;
}
{
func_type_defn (0);
begin_param ((ZI403));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR760 (&ZI757);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = make_func_type (NULL_type, ((ZI757) | FUNC_WEAK), cv_c, empty_type_set);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
}
break;
case lex_open_Hsquare_H1:
{
EXP ZI408;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR759 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
NAT n = make_array_dim ((ZI408));
MAKE_type_array (cv_none, NULL_type, n, (ZI399));
}
{
{
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:;
*ZO399 = ZI399;
}
void
ZR561 (EXP ZI471, EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI420;
ZR560 (ZI471, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = end_compound_stmt ((ZI420));
}
{
RESCAN_LEXER;
}
}
goto ZL0;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI408) = end_compound_stmt ((ZI471));
}
{
RESCAN_LEXER;
}
}
ZL0:;
*ZO408 = ZI408;
}
void
ZR903 (EXP ZI901, EXP *ZO902)
{
EXP ZI902;
ZL2_903:;
switch (CURRENT_TERMINAL) {
case lex_logical_Hand_H1:
{
EXP ZI452;
EXP ZI408;
{
{
switch (CURRENT_TERMINAL) {
case lex_logical_Hand_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR501 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_log_and_exp ((ZI901), (ZI452));
}
ZI901 = ZI408;
goto ZL2_903;
}
/*UNREACHED*/
default:
{
ZI902 = ZI901;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO902 = ZI902;
}
void
ZR806 (DECL_SPEC ZI611, BASE_TYPE ZI666, TYPE ZI424)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
TYPE ZI399;
IDENTIFIER ZI403;
IDENTIFIER ZI552;
EXP ZI408;
ZR762 (ZI424, &ZI399, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
if (in_weak_param) {
(ZI552) = make_param_decl ((ZI611), (ZI399), (ZI403), CONTEXT_WEAK_PARAM);
} else if (type_tag ((ZI399)) == type_func_tag) {
check_weak_func ((ZI399), 0);
(ZI552) = make_func_decl ((ZI611), (ZI399), (ZI403), 0);
} else {
int def = predict_obj_defn ();
(ZI552) = make_object_decl ((ZI611), (ZI399), (ZI403), def);
}
if (IS_id_type_alias ((ZI552))) {
BASE_TYPE bs = DEREF_btype (id_type_alias_rep ((ZI552)));
bs |= (ZI666);
COPY_btype (id_type_alias_rep ((ZI552)), bs);
}
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR802 (ZI552, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
int def = init_object ((ZI552), (ZI408));
if (do_dump) dump_declare ((ZI552), &decl_loc, def);
}
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR564 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI696;
TYPE ZI1093;
CV_SPEC ZI698;
DECL_SPEC ZI1094;
BASE_TYPE ZI666;
TYPE ZI697;
CV_SPEC ZI637;
DECL_SPEC ZI726;
{
/* Resolve declaration-specifiers from other declarators */
(ZI0) = predict_dspec (0);
}
if (!ZI0)
goto ZL1;
ZR723 (&ZI696, &ZI1093, &ZI698, &ZI1094);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* A type-name can be a declarator-id */
if (have_type_specifier && crt_lex_token == lex_type_Hname) {
crt_lex_token = lex_identifier;
}
}
ZR734 (&ZI696, &ZI1093, &ZI698, &ZI1094, &ZI666, &ZI697, &ZI637, &ZI726);
ZR823 (&ZI666, &ZI697, &ZI637, &ZI726);
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR419 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_complex_Hexp:
{
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI408 = parse_exp_token (id, args);
RESCAN_LEXER;
}
ADVANCE_LEXER;
}
break;
case lex_ellipsis_Hexp:
{
ADVANCE_LEXER;
{
(ZI408) = make_ellipsis_exp ();
}
}
break;
case lex_identifier:
{
IDENTIFIER ZI403;
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
{
(ZI408) = make_id_exp ((ZI403));
}
}
break;
case lex_open_Hround:
{
EXP ZI420;
ADVANCE_LEXER;
{
IGNORE incr_value (OPT_VAL_paren_depth);
}
ZR418 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_paren_exp ((ZI420));
decr_value (OPT_VAL_paren_depth);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
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:
{
ZR413 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR626 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_reachable:
{
EXP ZI420;
ADVANCE_LEXER;
{
unreached_code = 0;
}
ZR532 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_reach_stmt ((ZI420), 1);
}
}
break;
case lex_unreachable:
{
EXP ZI420;
ADVANCE_LEXER;
{
unreached_code = 1;
}
ZR532 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_reach_stmt ((ZI420), 0);
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR907 (EXP ZI905, EXP *ZO906)
{
EXP ZI906;
ZL2_907:;
switch (CURRENT_TERMINAL) {
case lex_or_H1:
{
EXP ZI452;
EXP ZI408;
{
{
switch (CURRENT_TERMINAL) {
case lex_or_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR499 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_or_exp ((ZI905), (ZI452));
}
ZI905 = ZI408;
goto ZL2_907;
}
/*UNREACHED*/
default:
{
ZI906 = ZI905;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO906 = ZI906;
}
void
ZR678 (BASE_TYPE *ZO677)
{
BASE_TYPE ZI677;
switch (CURRENT_TERMINAL) {
case lex_struct:
{
ADVANCE_LEXER;
{
(ZI677) = btype_struct;
}
}
break;
case lex_union:
{
ADVANCE_LEXER;
{
(ZI677) = btype_union;
}
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO677 = ZI677;
}
void
ZR799 (IDENTIFIER ZI552, SID_LIST_EXP *ZO424)
{
SID_LIST_EXP ZI424;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI452;
EXP ZI420;
SID_LIST_EXP ZI427;
ZR798 (ZI552, &ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
MAKE_exp_location (type_void, crt_loc, (ZI452), (ZI420));
}
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
ZR1082 (&ZI552, &ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
default:
{
{
(ZI427) = NULL_list (EXP);
}
}
break;
}
}
{
CONS_exp ((ZI420), (ZI427), (ZI424));
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO424 = ZI424;
}
void
parse_tok_type (TYPE *ZO399)
{
TYPE ZI399;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
BASE_TYPE ZI666;
TYPE ZI424;
CV_SPEC ZI637;
TYPE ZI427;
ZR695 (&ZI666, &ZI424, &ZI637);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI427) = complete_pre_type ((ZI666), (ZI424), (ZI637), 1);
have_type_specifier = 0;
}
ZR770 (ZI427, &ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
}
void
ZR1037 (EXP *ZI1035, EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_comma:
{
SID_LIST_EXP ZI427;
SID_LIST_EXP ZI424;
ADVANCE_LEXER;
ZR519 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((*ZI1035), (ZI427), (ZI424));
}
{
(ZI408) = make_comma_exp ((ZI424));
}
}
break;
default:
{
ZI408 = *ZI1035;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR491 (void)
{
switch (CURRENT_TERMINAL) {
case lex_eq:
{
ADVANCE_LEXER;
}
break;
case lex_not_Heq_H1:
{
{
{
switch (CURRENT_TERMINAL) {
case lex_not_Heq_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
}
break;
case 358:
return;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR495 (EXP *ZO918)
{
EXP ZI918;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR492 (&ZI408);
ZR919 (ZI408, &ZI918);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO918 = ZI918;
}
void
ZR1038 (EXP *ZI420, SID_LIST_EXP *ZO424)
{
SID_LIST_EXP ZI424;
switch (CURRENT_TERMINAL) {
case lex_comma:
{
SID_LIST_EXP ZI427;
ADVANCE_LEXER;
ZR519 (&ZI427);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
CONS_exp ((*ZI420), (ZI427), (ZI424));
}
}
break;
default:
{
SID_LIST_EXP ZI427;
{
(ZI427) = NULL_list (EXP);
}
{
CONS_exp ((*ZI420), (ZI427), (ZI424));
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO424 = ZI424;
}
void
ZR911 (EXP ZI909, EXP *ZO910)
{
EXP ZI910;
ZL2_911:;
switch (CURRENT_TERMINAL) {
case lex_xor_H1:
{
EXP ZI452;
EXP ZI408;
{
{
switch (CURRENT_TERMINAL) {
case lex_xor_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR497 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_xor_exp ((ZI909), (ZI452));
}
ZI909 = ZI408;
goto ZL2_911;
}
/*UNREACHED*/
default:
{
ZI910 = ZI909;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO910 = ZI910;
}
void
ZR515 (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
switch (CURRENT_TERMINAL) {
case lex_inset_Hstart:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR1039 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR1039 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_set:
{
EXP ZI420;
ADVANCE_LEXER;
ZR418 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_set_exp ((ZI420));
}
switch (CURRENT_TERMINAL) {
case lex_inset_Hend:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_unused:
{
EXP ZI420;
ADVANCE_LEXER;
ZR418 (&ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_unused_exp ((ZI420));
}
switch (CURRENT_TERMINAL) {
case lex_inset_Hend:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR1040 (BASE_TYPE *ZI677, IDENTIFIER *ZI403, TYPE *ZO399)
{
TYPE ZI399;
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
{
IDENTIFIER ZI424;
int ZI590;
IDENTIFIER ZI680;
{
(ZI424) = begin_class_defn ((*ZI403), (*ZI677), cinfo_none, NULL_type);
(ZI590) = in_function_defn;
in_function_defn = 0;
in_class_defn++;
really_in_class_defn++;
no_type_defns++;
end_base_class (crt_class, 1);
}
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR670 ();
{
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
switch (CURRENT_TERMINAL) {
case lex_close_Hbrace_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
(ZI680) = end_class_defn ((ZI424));
in_function_defn = (ZI590);
in_class_defn--;
really_in_class_defn--;
}
{
MAKE_type_pre (cv_none, btype_alias, qual_none, (ZI399));
COPY_id (type_name ((ZI399)), (ZI680));
have_type_specifier = 1;
}
{
RESCAN_LEXER;
}
}
break;
default:
{
{
MAKE_type_pre (cv_none, (*ZI677), qual_none, (ZI399));
COPY_id (type_name ((ZI399)), (*ZI403));
if (have_type_declaration == TYPE_DECL_NONE) {
have_type_declaration = TYPE_DECL_ELABORATE;
}
have_type_specifier = 1;
}
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
}
void
parse_type_param (IDENTIFIER *ZO552)
{
IDENTIFIER ZI552;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI552) = NULL_id;
}
}
*ZO552 = ZI552;
}
void
ZR1041 (BASE_TYPE *ZI666, TYPE *ZI424, CV_SPEC *ZI637)
{
switch (CURRENT_TERMINAL) {
case lex_semicolon:
{
{
IGNORE empty_decl (dspec_none, NULL_type, (*ZI666), (*ZI424), (*ZI637), last_lex_token, 1);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
have_type_specifier = 0;
}
ADVANCE_LEXER;
}
break;
case lex_identifier: case lex_type_Hname: case lex_statement_Hname:
case lex_colon: case lex_open_Hround: case lex_star:
{
TYPE ZI399;
{
(ZI399) = complete_pre_type ((*ZI666), (*ZI424), (*ZI637), 1);
have_type_specifier = 0;
}
ZR834 (ZI399, *ZI666);
{
switch (CURRENT_TERMINAL) {
case lex_comma:
{
ADVANCE_LEXER;
ZR835 (ZI399, *ZI666);
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_semicolon:
{
ADVANCE_LEXER;
}
break;
case 358:
RESTORE_LEXER;
goto ZL1;
default:
goto ZL1;
}
}
}
break;
case 358:
return;
default:
goto ZL1;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR451 (EXP *ZO942)
{
EXP ZI942;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI408;
ZR419 (&ZI408);
ZR943 (ZI408, &ZI942);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO942 = ZI942;
}
void
ZR559 (EXP *ZO408)
{
EXP ZI408;
switch (CURRENT_TERMINAL) {
case lex_alignof:
{
int ZI1016;
EXP ZI1017;
EXP ZI1035;
EXP ZI420;
int ZI541;
ADVANCE_LEXER;
{
(ZI1016) = lex_alignof;
}
ZR465 (ZI1016, &ZI1017);
ZR1015 (&ZI1017, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_complex_Hexp:
{
EXP ZI1028;
EXP ZI1029;
EXP ZI1035;
EXP ZI420;
int ZI541;
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI1028 = parse_exp_token (id, args);
RESCAN_LEXER;
}
ADVANCE_LEXER;
ZR943 (ZI1028, &ZI1029);
ZR1015 (&ZI1029, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_complex_Hstmt:
{
EXP ZI420;
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI420 = parse_exp_token (id, args);
RESCAN_LEXER;
}
ADVANCE_LEXER;
{
(ZI408) = make_exp_stmt ((ZI420));
}
}
break;
case lex_discard:
{
EXP ZI1090;
EXP ZI971;
EXP ZI970;
EXP ZI969;
EXP ZI968;
EXP ZI967;
EXP ZI966;
EXP ZI965;
EXP ZI964;
EXP ZI963;
EXP ZI962;
EXP ZI961;
EXP ZI958;
EXP ZI1035;
EXP ZI420;
int ZI541;
ADVANCE_LEXER;
ZR463 (&ZI1090);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI971) = make_cast_exp (type_void, (ZI1090), 0);
}
ZR939 (ZI971, &ZI970);
ZR935 (ZI970, &ZI969);
ZR931 (ZI969, &ZI968);
ZR927 (ZI968, &ZI967);
ZR923 (ZI967, &ZI966);
ZR919 (ZI966, &ZI965);
ZR915 (ZI965, &ZI964);
ZR911 (ZI964, &ZI963);
ZR907 (ZI963, &ZI962);
ZR903 (ZI962, &ZI961);
ZR899 (ZI961, &ZI958);
ZR960 (&ZI958, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_ellipsis_Hexp:
{
EXP ZI1025;
EXP ZI1026;
EXP ZI1035;
EXP ZI420;
int ZI541;
ADVANCE_LEXER;
{
(ZI1025) = make_ellipsis_exp ();
}
ZR943 (ZI1025, &ZI1026);
ZR1015 (&ZI1026, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_identifier:
{
IDENTIFIER ZI403;
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
ZR1091 (&ZI403, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_inset_Hstart:
{
ADVANCE_LEXER;
ZR1088 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_minus_Hminus:
{
EXP ZI997;
EXP ZI998;
EXP ZI1035;
EXP ZI420;
int ZI541;
ADVANCE_LEXER;
ZR462 (&ZI997);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI998) = make_prefix_exp (lex_minus_Hminus, (ZI997));
}
ZR1015 (&ZI998, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_open_Hround:
{
EXP ZI1035;
EXP ZI420;
int ZI541;
ADVANCE_LEXER;
ZR993 (&ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_plus_Hplus:
{
EXP ZI994;
EXP ZI995;
EXP ZI1035;
EXP ZI420;
int ZI541;
ADVANCE_LEXER;
ZR462 (&ZI994);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI995) = make_prefix_exp (lex_plus_Hplus, (ZI994));
}
ZR1015 (&ZI995, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_semicolon:
{
ADVANCE_LEXER;
{
(ZI408) = NULL_exp;
}
}
break;
case lex_sizeof:
{
int ZI1013;
EXP ZI1014;
EXP ZI1035;
EXP ZI420;
int ZI541;
ADVANCE_LEXER;
{
(ZI1013) = lex_sizeof;
}
ZR465 (ZI1013, &ZI1014);
ZR1015 (&ZI1014, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_star:
{
EXP ZI1000;
EXP ZI1001;
EXP ZI1035;
EXP ZI420;
int ZI541;
ADVANCE_LEXER;
ZR463 (&ZI1000);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1001) = make_indir_exp ((ZI1000));
}
ZR1015 (&ZI1001, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
IDENTIFIER ZI403;
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
ZR1092 (&ZI403, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_type_Hname:
{
IDENTIFIER ZI403;
EXP ZI420;
EXP ZI452;
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
{
if (unreached_code) unreached_fall = 0;
}
{
(ZI420) = begin_label_stmt ((ZI403), lex_identifier);
}
switch (CURRENT_TERMINAL) {
case lex_colon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR532 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = end_label_stmt ((ZI420), (ZI452));
}
}
break;
case lex_and_H1:
{
EXP ZI1003;
EXP ZI1004;
EXP ZI1035;
EXP ZI420;
int ZI541;
{
{
switch (CURRENT_TERMINAL) {
case lex_and_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR463 (&ZI1003);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1004) = make_ref_exp ((ZI1003), 0);
}
ZR1015 (&ZI1004, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_asm:
{
ZR629 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_reachable: case lex_unreachable:
{
ZR626 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_case: case lex_default: case lex_fall:
{
ZR533 ();
ZR1089 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_set: case lex_unused:
{
EXP ZI1083;
EXP ZI420;
int ZI541;
ZR514 (&ZI1083);
ZR1085 (&ZI1083, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_do: case lex_for: case lex_while:
{
ZR608 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_break: case lex_continue: case lex_goto:
case lex_return:
{
ZR620 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_char_Hexp: case lex_wchar_Hexp: case lex_string_Hexp:
case lex_wstring_Hexp: case lex_integer_Hexp: case lex_floating_Hexp:
{
EXP ZI1019;
EXP ZI1020;
EXP ZI1035;
EXP ZI420;
int ZI541;
ZR413 (&ZI1019);
ZR943 (ZI1019, &ZI1020);
ZR1015 (&ZI1020, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_not_H1:
{
EXP ZI1006;
EXP ZI1007;
EXP ZI1035;
EXP ZI420;
int ZI541;
{
{
switch (CURRENT_TERMINAL) {
case lex_not_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR463 (&ZI1006);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1007) = make_not_exp ((ZI1006));
}
ZR1015 (&ZI1007, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case lex_hash_Hif: case lex_if: case lex_switch:
{
ZR585 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_compl_H1: case lex_minus: case lex_plus:
case lex_abs:
{
int ZI1009;
EXP ZI1010;
EXP ZI1011;
EXP ZI1035;
EXP ZI420;
int ZI541;
{
(ZI1009) = crt_lex_token;
}
ZR473 ();
ZR463 (&ZI1010);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1011) = make_uminus_exp ((ZI1009), (ZI1010));
}
ZR1015 (&ZI1011, &ZI1035);
ZR1037 (&ZI1035, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI541) = unreached_code;
if ((ZI541)) {
if (!unreached_last) {
report (crt_loc, ERR_stmt_stmt_unreach ());
unreached_last = 1;
}
} else {
unreached_last = 0;
}
}
{
(ZI408) = make_exp_stmt ((ZI420));
}
{
unreached_fall = 1;
}
switch (CURRENT_TERMINAL) {
case lex_semicolon:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
break;
case 358:
return;
default:
goto ZL1;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR670 (void)
{
if ((CURRENT_TERMINAL) == 358) {
return;
}
ZL2_670:;
{
BASE_TYPE ZI696;
TYPE ZI697;
CV_SPEC ZI698;
BASE_TYPE ZI666;
TYPE ZI424;
CV_SPEC ZI637;
{
/* Resolve type-specifiers from other declarators */
(ZI0) = predict_tspec (0);
}
if (!ZI0)
goto ZL3;
ZR694 (&ZI696, &ZI697, &ZI698);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* A type-name can be a declarator-id */
if (have_type_specifier && crt_lex_token == lex_type_Hname) {
crt_lex_token = lex_identifier;
}
}
ZR707 (&ZI696, &ZI697, &ZI698, &ZI666, &ZI424, &ZI637);
ZR1041 (&ZI666, &ZI424, &ZI637);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
} else {
goto ZL2_670;
}
}
/*UNREACHED*/
ZL3:;
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR915 (EXP ZI913, EXP *ZO914)
{
EXP ZI914;
ZL2_915:;
switch (CURRENT_TERMINAL) {
case lex_and_H1:
{
EXP ZI452;
EXP ZI408;
{
{
switch (CURRENT_TERMINAL) {
case lex_and_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR495 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_and_exp ((ZI913), (ZI452));
}
ZI913 = ZI408;
goto ZL2_915;
}
/*UNREACHED*/
default:
{
ZI914 = ZI913;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO914 = ZI914;
}
void
ZR465 (int ZI464, EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
int ZI466;
int ZI467;
EXP ZI471;
{
suppress_usage++;
}
{
(ZI466) = no_side_effects;
}
{
(ZI467) = no_type_defns;
}
{
switch (CURRENT_TERMINAL) {
case lex_alignof:
{
int ZI1079;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
ADVANCE_LEXER;
{
(ZI1079) = lex_alignof;
}
ZR465 (ZI1079, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
case lex_complex_Hexp:
{
EXP ZI1110;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
{
IDENTIFIER id = crt_token->pp_data.tok.id;
PPTOKEN *args = crt_token->pp_data.tok.args;
ZI1110 = parse_exp_token (id, args);
RESCAN_LEXER;
}
ADVANCE_LEXER;
ZR943 (ZI1110, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
case lex_ellipsis_Hexp:
{
EXP ZI1111;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
ADVANCE_LEXER;
{
(ZI1111) = make_ellipsis_exp ();
}
ZR943 (ZI1111, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
case lex_identifier:
{
IDENTIFIER ZI403;
EXP ZI1112;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
{
ZI403 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
{
(ZI1112) = make_id_exp ((ZI403));
}
ZR943 (ZI1112, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
case lex_minus_Hminus:
{
EXP ZI1072;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
ADVANCE_LEXER;
ZR462 (&ZI1072);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI420) = make_prefix_exp (lex_minus_Hminus, (ZI1072));
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
case lex_open_Hround:
{
ADVANCE_LEXER;
ZR1081 (&ZI464, &ZI466, &ZI467, &ZI471);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_plus_Hplus:
{
EXP ZI1071;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
ADVANCE_LEXER;
ZR462 (&ZI1071);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI420) = make_prefix_exp (lex_plus_Hplus, (ZI1071));
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
case lex_sizeof:
{
int ZI1078;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
ADVANCE_LEXER;
{
(ZI1078) = lex_sizeof;
}
ZR465 (ZI1078, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
case lex_star:
{
EXP ZI1073;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
ADVANCE_LEXER;
ZR463 (&ZI1073);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI420) = make_indir_exp ((ZI1073));
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
case lex_and_H1:
{
EXP ZI1074;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
{
{
switch (CURRENT_TERMINAL) {
case lex_and_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR463 (&ZI1074);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI420) = make_ref_exp ((ZI1074), 0);
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
case lex_char_Hexp: case lex_wchar_Hexp: case lex_string_Hexp:
case lex_wstring_Hexp: case lex_integer_Hexp: case lex_floating_Hexp:
{
EXP ZI1113;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
ZR413 (&ZI1113);
ZR943 (ZI1113, &ZI420);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
case lex_not_H1:
{
EXP ZI1075;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
{
{
switch (CURRENT_TERMINAL) {
case lex_not_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR463 (&ZI1075);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI420) = make_not_exp ((ZI1075));
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
case lex_compl_H1: case lex_minus: case lex_plus:
case lex_abs:
{
int ZI1076;
EXP ZI1077;
EXP ZI420;
int ZI469;
int ZI470;
TYPE ZI399;
{
(ZI1076) = crt_lex_token;
}
ZR473 ();
ZR463 (&ZI1077);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI420) = make_uminus_exp ((ZI1076), (ZI1077));
}
{
(ZI469) = no_side_effects - (ZI466);
}
{
(ZI470) = no_type_defns - (ZI467);
}
{
(ZI399) = typeof_exp (&(ZI420), (ZI469), (ZI464));
}
{
(ZI471) = make_sizeof_exp ((ZI399), (ZI420), (ZI470), (ZI464));
}
}
break;
default:
goto ZL1;
}
}
{
suppress_usage--;
}
ZI408 = ZI471;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR919 (EXP ZI917, EXP *ZO918)
{
EXP ZI918;
ZL2_919:;
switch (CURRENT_TERMINAL) {
case lex_max: case lex_min:
{
int ZI464;
EXP ZI452;
EXP ZI408;
{
(ZI464) = crt_lex_token;
}
{
switch (CURRENT_TERMINAL) {
case lex_max:
{
ADVANCE_LEXER;
}
break;
case lex_min:
{
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
ZR492 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_mult_exp ((ZI464), (ZI917), (ZI452));
}
ZI917 = ZI408;
goto ZL2_919;
}
/*UNREACHED*/
default:
{
ZI918 = ZI917;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO918 = ZI918;
}
void
ZR788 (void)
{
ZL2_788:;
switch (CURRENT_TERMINAL) {
case lex_comma:
{
IDENTIFIER ZI403;
ADVANCE_LEXER;
ZR787 (&ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
IDENTIFIER pid = underlying_id ((ZI403));
DEREF_loc (id_loc (pid), decl_loc);
}
{
IGNORE weak_param_decl ((ZI403));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
goto ZL2_788;
}
/*UNREACHED*/
case 358:
return;
default:
break;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
ZR774 (TYPE *ZO399, IDENTIFIER *ZO403)
{
TYPE ZI399;
IDENTIFIER ZI403;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
IDENTIFIER ZI1057;
TYPE ZI1058;
{
/* Resolve parameter declarators from type names */
(ZI0) = predict_param ();
}
if (!ZI0)
goto ZL2;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI1057 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI1057 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI1057 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
(ZI1058) = NULL_type;
}
{
IDENTIFIER pid = underlying_id ((ZI1057));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR870 (ZI1058, ZI1057, &ZI399, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
{
ADVANCE_LEXER;
ZR1056 (&ZI399, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_weak:
{
IDENTIFIER ZI1055;
int ZI757;
TYPE ZI1061;
IDENTIFIER ZI1062;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI1055) = NULL_id;
}
{
func_type_defn (0);
begin_param ((ZI1055));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR760 (&ZI757);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1061) = make_func_type (NULL_type, ((ZI757) | FUNC_WEAK), cv_c, empty_type_set);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
{
HASHID nm = lookup_anon ();
(ZI1062) = DEREF_id (hashid_id (nm));
}
{
IDENTIFIER pid = underlying_id ((ZI1062));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR870 (ZI1061, ZI1062, &ZI399, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_open_Hsquare_H1:
{
EXP ZI408;
TYPE ZI1059;
IDENTIFIER ZI1060;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR759 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
NAT n = make_array_dim ((ZI408));
MAKE_type_array (cv_none, NULL_type, n, (ZI1059));
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
HASHID nm = lookup_anon ();
(ZI1060) = DEREF_id (hashid_id (nm));
}
{
IDENTIFIER pid = underlying_id ((ZI1060));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR870 (ZI1059, ZI1060, &ZI399, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
break;
case lex_star:
{
TYPE ZI424;
TYPE ZI427;
ZR741 (&ZI424);
ZR774 (&ZI427, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (ZI424): inject_pre_type ((ZI427), (ZI424), 0));
}
}
break;
default:
{
{
(ZI399) = NULL_type;
}
{
HASHID nm = lookup_anon ();
(ZI403) = DEREF_id (hashid_id (nm));
}
{
IDENTIFIER pid = underlying_id ((ZI403));
DEREF_loc (id_loc (pid), decl_loc);
}
}
break;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
*ZO403 = ZI403;
}
void
ZR923 (EXP ZI921, EXP *ZO922)
{
EXP ZI922;
ZL2_923:;
switch (CURRENT_TERMINAL) {
case lex_eq: case lex_not_Heq_H1:
{
int ZI464;
EXP ZI452;
EXP ZI408;
{
(ZI464) = crt_lex_token;
}
ZR491 ();
ZR489 (&ZI452);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* op will be in its primary form */
(ZI408) = make_equality_exp ((ZI464), (ZI921), (ZI452));
}
ZI921 = ZI408;
goto ZL2_923;
}
/*UNREACHED*/
default:
{
ZI922 = ZI921;
}
break;
case 358:
return;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO922 = ZI922;
}
void
ZR629 (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI420;
SID_LIST_EXP ZI424;
switch (CURRENT_TERMINAL) {
case lex_asm:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
switch (CURRENT_TERMINAL) {
case lex_string_Hexp:
{
{
ZI420 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
case lex_wstring_Hexp:
{
{
ZI420 = crt_token->pp_data.exp;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
ZR630 (&ZI424);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI408) = make_asm ((ZI420), (ZI424));
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
ZR400 ();
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR776 (TYPE ZI424, TYPE *ZO399, IDENTIFIER *ZO403)
{
TYPE ZI399;
IDENTIFIER ZI403;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
IDENTIFIER ZI1057;
TYPE ZI1058;
TYPE ZI427;
{
/* Resolve parameter declarators from type names */
(ZI0) = predict_param ();
}
if (!ZI0)
goto ZL2;
{
switch (CURRENT_TERMINAL) {
case lex_identifier:
{
{
ZI1057 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_statement_Hname:
{
{
ZI1057 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
case lex_type_Hname:
{
{
ZI1057 = crt_token->pp_data.id.use;
}
ADVANCE_LEXER;
}
break;
default:
goto ZL1;
}
}
{
(ZI1058) = NULL_type;
}
{
IDENTIFIER pid = underlying_id ((ZI1057));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR870 (ZI1058, ZI1057, &ZI427, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (ZI424): inject_pre_type ((ZI427), (ZI424), 1));
}
goto ZL0;
}
/*UNREACHED*/
ZL2:;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
{
TYPE ZI427;
ADVANCE_LEXER;
ZR1056 (&ZI427, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (ZI424): inject_pre_type ((ZI427), (ZI424), 1));
}
}
break;
case lex_weak:
{
IDENTIFIER ZI1055;
int ZI757;
TYPE ZI1061;
IDENTIFIER ZI1062;
TYPE ZI427;
ADVANCE_LEXER;
switch (CURRENT_TERMINAL) {
case lex_open_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
(ZI1055) = NULL_id;
}
{
func_type_defn (0);
begin_param ((ZI1055));
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
ZR760 (&ZI757);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI1061) = make_func_type (NULL_type, ((ZI757) | FUNC_WEAK), cv_c, empty_type_set);
}
switch (CURRENT_TERMINAL) {
case lex_close_Hround:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
{
end_param ();
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 1;
}
{
HASHID nm = lookup_anon ();
(ZI1062) = DEREF_id (hashid_id (nm));
}
{
IDENTIFIER pid = underlying_id ((ZI1062));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR870 (ZI1061, ZI1062, &ZI427, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (ZI424): inject_pre_type ((ZI427), (ZI424), 1));
}
}
break;
case lex_open_Hsquare_H1:
{
EXP ZI408;
TYPE ZI1059;
IDENTIFIER ZI1060;
TYPE ZI427;
{
{
switch (CURRENT_TERMINAL) {
case lex_open_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
ZR759 (&ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
NAT n = make_array_dim ((ZI408));
MAKE_type_array (cv_none, NULL_type, n, (ZI1059));
}
{
{
switch (CURRENT_TERMINAL) {
case lex_close_Hsquare_H1:
break;
default:
goto ZL1;
}
ADVANCE_LEXER;
}
}
{
HASHID nm = lookup_anon ();
(ZI1060) = DEREF_id (hashid_id (nm));
}
{
IDENTIFIER pid = underlying_id ((ZI1060));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR870 (ZI1059, ZI1060, &ZI427, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (ZI424): inject_pre_type ((ZI427), (ZI424), 1));
}
}
break;
case lex_star:
{
TYPE ZI1063;
TYPE ZI1064;
TYPE ZI427;
ZR741 (&ZI1063);
ZR774 (&ZI1064, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI427) = (IS_NULL_type ((ZI1064)) ? (ZI1063): inject_pre_type ((ZI1064), (ZI1063), 0));
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (ZI424): inject_pre_type ((ZI427), (ZI424), 1));
}
}
break;
default:
{
TYPE ZI427;
{
(ZI427) = NULL_type;
}
{
HASHID nm = lookup_anon ();
(ZI403) = DEREF_id (hashid_id (nm));
}
{
IDENTIFIER pid = underlying_id ((ZI403));
DEREF_loc (id_loc (pid), decl_loc);
}
{
(ZI399) = (IS_NULL_type ((ZI427)) ? (ZI424): inject_pre_type ((ZI427), (ZI424), 1));
}
}
break;
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO399 = ZI399;
*ZO403 = ZI403;
}
void
ZR507 (EXP *ZO408)
{
EXP ZI408;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
EXP ZI958;
ZR505 (&ZI958);
ZR960 (&ZI958, &ZI408);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
}
goto ZL0;
ZL1:;
SAVE_LEXER (358);
return;
ZL0:;
*ZO408 = ZI408;
}
void
ZR1053 (TYPE *ZI424, BASE_TYPE *ZI427, IDENTIFIER *ZI1052)
{
switch (CURRENT_TERMINAL) {
case lex_colon:
{
EXP ZI471;
TYPE ZI399;
{
IDENTIFIER pid = underlying_id ((*ZI1052));
DEREF_loc (id_loc (pid), decl_loc);
}
ADVANCE_LEXER;
ZR522 (&ZI471);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
/* Check for anonymous bitfields */
HASHID nm = DEREF_hashid (id_name ((*ZI1052)));
int z = IS_hashid_anon (nm);
(ZI399) = make_bitfield_type ((*ZI424), (*ZI427), (ZI471), z);
}
{
IDENTIFIER id = make_member_decl (dspec_none, (ZI399), (*ZI1052), 0);
if (do_dump) dump_declare (id, &decl_loc, 0);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
}
break;
default:
{
TYPE ZI1051;
TYPE ZI1045;
IDENTIFIER ZI403;
TYPE ZI399;
{
(ZI1051) = NULL_type;
}
{
IDENTIFIER pid = underlying_id ((*ZI1052));
DEREF_loc (id_loc (pid), decl_loc);
}
ZR878 (ZI1051, *ZI1052, &ZI1045, &ZI403);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
(ZI399) = (IS_NULL_type ((ZI1045)) ? (*ZI424): inject_pre_type ((ZI1045), (*ZI424), 1));
}
{
IDENTIFIER id = make_member_decl (dspec_none, (ZI399), (ZI403), 0);
if (do_dump) dump_declare (id, &decl_loc, 0);
have_type_declaration = TYPE_DECL_NONE;
have_func_declarator = 0;
}
}
break;
case 358:
return;
}
return;
ZL1:;
SAVE_LEXER (358);
return;
}
void
parse_type (TYPE *ZO399)
{
TYPE ZI399;
if ((CURRENT_TERMINAL) == 358) {
return;
}
{
parse_tok_type (&ZI399);
if ((CURRENT_TERMINAL) == 358) {
RESTORE_LEXER;
goto ZL1;
}
{
object_type ((ZI399), null_tag);
}
}
goto ZL0;
ZL1:;
{
{
/* Syntax errors */
ERROR err = ERR_lex_parse (crt_token);
report (crt_loc, err);
have_syntax_error = 1;
}
{
(ZI399) = NULL_type;
}
}
ZL0:;
*ZO399 = ZI399;
}
/* END OF FILE */
syntax highlighted by Code2HTML, v. 0.9.1