WebSVN – tendra.SVN – Blame – /branches/tendra5/src/producers/c/syntax/syntax1.c

Rev	Author	Line No.	Line
2	7u83	1	`/*`
		2	`* Automatically generated from the files:`
		3	`* /u/g/release/Source/src/producers/c/syntax/syntax.sid`
		4	`* and`
		5	`* /u/g/release/Source/src/producers/c/syntax/syntax.act`
		6	`* by:`
		7	`* sid`
		8	`*/`
		9
		10	`/* BEGINNING OF HEADER */`
		11
		12	`#define __SID_SPLIT`
		13
		14	`/*`
		15	`Crown Copyright (c) 1997, 1998`
		16
		17	`This TenDRA(r) Computer Program is subject to Copyright`
		18	`owned by the United Kingdom Secretary of State for Defence`
		19	`acting through the Defence Evaluation and Research Agency`
		20	`(DERA). It is made available to Recipients with a`
		21	`royalty-free licence for its use, reproduction, transfer`
		22	`to other parties and amendment for any purpose not excluding`
		23	`product development provided that any such use et cetera`
		24	`shall be deemed to be acceptance of the following conditions:-`
		25
		26	`(1) Its Recipients shall ensure that this Notice is`
		27	`reproduced upon any copies or amended versions of it;`
		28
		29	`(2) Any amended version of it shall be clearly marked to`
		30	`show both the nature of and the organisation responsible`
		31	`for the relevant amendment or amendments;`
		32
		33	`(3) Its onward transfer from a recipient to another`
		34	`party shall be deemed to be that party's acceptance of`
		35	`these conditions;`
		36
		37	`(4) DERA gives no warranty or assurance as to its`
		38	`quality or suitability for any purpose and DERA accepts`
		39	`no liability whatsoever in relation to any use to which`
		40	`it may be put.`
		41	`*/`
		42
		43
		44	`#include "config.h"`
		45	`#include "c_types.h"`
		46	`#include "exp_ops.h"`
		47	`#include "hashid_ops.h"`
		48	`#include "id_ops.h"`
		49	`#include "type_ops.h"`
		50	`#include "error.h"`
		51	`#include "catalog.h"`
		52	`#include "option.h"`
		53	`#include "access.h"`
		54	`#include "allocate.h"`
		55	`#include "assign.h"`
		56	`#include "basetype.h"`
		57	`#include "cast.h"`
		58	`#include "chktype.h"`
		59	`#include "class.h"`
		60	`#include "constant.h"`
		61	`#include "construct.h"`
		62	`#include "convert.h"`
		63	`#include "declare.h"`
		64	`#include "derive.h"`
		65	`#include "dump.h"`
		66	`#include "exception.h"`
		67	`#include "expression.h"`
		68	`#include "function.h"`
		69	`#include "hash.h"`
		70	`#include "identifier.h"`
		71	`#include "initialise.h"`
		72	`#include "inttype.h"`
		73	`#include "label.h"`
		74	`#include "lex.h"`
		75	`#include "literal.h"`
		76	`#include "member.h"`
		77	`#include "namespace.h"`
		78	`#include "parse.h"`
		79	`#include "pragma.h"`
		80	`#include "predict.h"`
		81	`#include "preproc.h"`
		82	`#include "redeclare.h"`
		83	`#include "rewrite.h"`
		84	`#include "statement.h"`
		85	`#include "symbols.h"`
		86	`#include "template.h"`
		87	`#include "tokdef.h"`
		88	`#include "token.h"`
		89	`#include "typeid.h"`
		90	`#include "variable.h"`
		91
		92
		93	`/*`
		94	`COMPOUND TYPE ALIASES`
		95
		96	`These are the aliases for the compound types used in the parser.`
		97	`*/`
		98
		99	`typedef LIST ( EXP ) SID_LIST_EXP ;`
		100
		101
		102	`/*`
		103	`FUNCTION DECLARATIONS`
		104
		105	`The function declarations are included at this point so that the`
		106	`type definitions are in scope.`
		107	`*/`
		108
		109	`#include "syntax.h"`
		110
		111
		112	`/*`
		113	`COMPILATION MODE`
		114
		115	`The output of sid is automatically generated. Hence it is not`
		116	`necessarily appropriate to apply the same level of checking to this`
		117	`as to the rest of the program. These pragmas describe the relaxations`
		118	`allowed for the sid output.`
		119	`*/`
		120
		121	`#if FS_TENDRA`
		122	`#pragma TenDRA begin`
		123	`#pragma TenDRA const conditional allow`
		124	`#pragma TenDRA unreachable code allow`
		125	`#pragma TenDRA variable analysis off`
		126	`#endif`
		127
		128
		129
		130	`/* BEGINNING OF STATIC VARIABLES */`
		131
		132	`int ZI0;`
		133
		134	`/* BEGINNING OF FUNCTION DEFINITIONS */`
		135
		136	`void`
		137	`ZR659 PROTO_N ((ZO658))`
		138	`PROTO_T (BASE_TYPE *ZO658)`
		139	`{`
		140	`BASE_TYPE ZI658;`
		141
		142	`switch (CURRENT_TERMINAL) {`
		143	`case 184:`
		144	`{`
		145	`ADVANCE_LEXER;`
		146	`{`
		147	`(ZI658) = btype_bottom ;`
		148	`}`
		149	`}`
		150	`break;`
		151	`case 97:`
		152	`{`
		153	`ADVANCE_LEXER;`
		154	`{`
		155	`(ZI658) = btype_char ;`
		156	`}`
		157	`}`
		158	`break;`
		159	`case 102:`
		160	`{`
		161	`ADVANCE_LEXER;`
		162	`{`
		163	`(ZI658) = btype_double ;`
		164	`}`
		165	`}`
		166	`break;`
		167	`case 106:`
		168	`{`
		169	`ADVANCE_LEXER;`
		170	`{`
		171	`(ZI658) = btype_float ;`
		172	`}`
		173	`}`
		174	`break;`
		175	`case 110:`
		176	`{`
		177	`ADVANCE_LEXER;`
		178	`{`
		179	`(ZI658) = btype_int ;`
		180	`}`
		181	`}`
		182	`break;`
		183	`case 111:`
		184	`{`
		185	`ADVANCE_LEXER;`
		186	`{`
		187	`(ZI658) = btype_long ;`
		188	`}`
		189	`}`
		190	`break;`
		191	`case 285:`
		192	`{`
		193	`ADVANCE_LEXER;`
		194	`{`
		195	`(ZI658) = btype_ptrdiff_t ;`
		196	`}`
		197	`}`
		198	`break;`
		199	`case 114:`
		200	`{`
		201	`ADVANCE_LEXER;`
		202	`{`
		203	`(ZI658) = btype_short ;`
		204	`}`
		205	`}`
		206	`break;`
		207	`case 115:`
		208	`{`
		209	`ADVANCE_LEXER;`
		210	`{`
		211	`(ZI658) = btype_signed ;`
		212	`}`
		213	`}`
		214	`break;`
		215	`case 298:`
		216	`{`
		217	`ADVANCE_LEXER;`
		218	`{`
		219	`(ZI658) = btype_size_t ;`
		220	`}`
		221	`}`
		222	`break;`
		223	`case 122:`
		224	`{`
		225	`ADVANCE_LEXER;`
		226	`{`
		227	`(ZI658) = btype_unsigned ;`
		228	`}`
		229	`}`
		230	`break;`
		231	`case 123:`
		232	`{`
		233	`ADVANCE_LEXER;`
		234	`{`
		235	`(ZI658) = btype_void ;`
		236	`}`
		237	`}`
		238	`break;`
		239	`case 156:`
		240	`{`
		241	`ADVANCE_LEXER;`
		242	`{`
		243	`(ZI658) = btype_wchar_t ;`
		244	`}`
		245	`}`
		246	`break;`
		247	`case 354:`
		248	`return;`
		249	`default:`
		250	`goto ZL1;`
		251	`}`
		252	`goto ZL0;`
		253	`ZL1:;`
		254	`SAVE_LEXER (354);`
		255	`return;`
		256	`ZL0:;`
		257	`*ZO658 = ZI658;`
		258	`}`
		259
		260	`void`
		261	`ZR890 PROTO_N ((ZI888, ZO889))`
		262	`PROTO_T (EXP ZI888 X EXP *ZO889)`
		263	`{`
		264	`EXP ZI889;`
		265
		266	`ZL2_890:;`
		267	`switch (CURRENT_TERMINAL) {`
		268	`case 80:`
		269	`{`
		270	`EXP ZI448;`
		271	`EXP ZI404;`
		272
		273	`{`
		274	`{`
		275	`switch (CURRENT_TERMINAL) {`
		276	`case 80:`
		277	`break;`
		278	`default:`
		279	`goto ZL1;`
		280	`}`
		281	`ADVANCE_LEXER;`
		282	`}`
		283	`}`
		284	`ZR493 (&ZI448);`
		285	`if ((CURRENT_TERMINAL) == 354) {`
		286	`RESTORE_LEXER;`
		287	`goto ZL1;`
		288	`}`
		289	`{`
		290
		291	`(ZI404) = make_xor_exp ( (ZI888), (ZI448) ) ;`
		292	`}`
		293	`ZI888 = ZI404;`
		294	`goto ZL2_890;`
		295	`}`
		296	`/UNREACHED/`
		297	`default:`
		298	`{`
		299	`ZI889 = ZI888;`
		300	`}`
		301	`break;`
		302	`case 354:`
		303	`return;`
		304	`}`
		305	`goto ZL0;`
		306	`ZL1:;`
		307	`SAVE_LEXER (354);`
		308	`return;`
		309	`ZL0:;`
		310	`*ZO889 = ZI889;`
		311	`}`
		312
		313	`void`
		314	`ZR715 PROTO_N ((ZO658, ZO395, ZO630, ZO605))`
		315	`PROTO_T (BASE_TYPE ZO658 X TYPE ZO395 X CV_SPEC ZO630 X DECL_SPEC ZO605)`
		316	`{`
		317	`BASE_TYPE ZI658;`
		318	`TYPE ZI395;`
		319	`CV_SPEC ZI630;`
		320	`DECL_SPEC ZI605;`
		321
		322	`if ((CURRENT_TERMINAL) == 354) {`
		323	`return;`
		324	`}`
		325	`{`
		326	`BASE_TYPE ZI688;`
		327	`TYPE ZI689;`
		328	`CV_SPEC ZI690;`
		329	`DECL_SPEC ZI716;`
		330
		331	`ZR714 (&ZI688, &ZI689, &ZI690, &ZI716);`
		332	`if ((CURRENT_TERMINAL) == 354) {`
		333	`RESTORE_LEXER;`
		334	`goto ZL1;`
		335	`}`
		336	`{`
		337
		338	`/* A type-name can be a declarator-id */`
		339	`if ( have_type_specifier && crt_lex_token == lex_type_Hname ) {`
		340	`crt_lex_token = lex_identifier ;`
		341	`}`
		342	`}`
		343	`{`
		344	`switch (CURRENT_TERMINAL) {`
		345	`case 2: case 25: case 94: case 97: case 98:`
		346	`case 102: case 104: case 105: case 106: case 110:`
		347	`case 111: case 112: case 114: case 115: case 117:`
		348	`case 118: case 120: case 121: case 122: case 123:`
		349	`case 124: case 137: case 156: case 184: case 285:`
		350	`case 298:`
		351	`{`
		352	`BASE_TYPE ZI692;`
		353	`TYPE ZI693;`
		354	`CV_SPEC ZI694;`
		355	`DECL_SPEC ZI718;`
		356
		357	`ZR715 (&ZI692, &ZI693, &ZI694, &ZI718);`
		358	`if ((CURRENT_TERMINAL) == 354) {`
		359	`RESTORE_LEXER;`
		360	`goto ZL1;`
		361	`}`
		362	`{`
		363
		364	`if ( (ZI688) & (ZI692) ) {`
		365	`(ZI658) = join_pre_types ( (ZI688), (ZI692) ) ;`
		366	`} else {`
		367	`(ZI658) = ( (ZI688) \| (ZI692) ) ;`
		368	`}`
		369	`}`
		370	`{`
		371
		372	`/* Join two partial types */`
		373	`if ( IS_NULL_type ( (ZI689) ) ) {`
		374	`(ZI395) = (ZI693) ;`
		375	`} else if ( IS_NULL_type ( (ZI693) ) ) {`
		376	`(ZI395) = (ZI689) ;`
		377	`} else {`
		378	`report ( crt_loc, ERR_dcl_type_simple_many ( (ZI689), (ZI693) ) ) ;`
		379	`(ZI395) = (ZI693) ;`
		380	`}`
		381	`}`
		382	`{`
		383
		384	`CV_SPEC c = ( (ZI690) & (ZI694) ) ;`
		385	`if ( c ) report ( crt_loc, ERR_dcl_type_cv_dup ( c ) ) ;`
		386	`(ZI630) = ( (ZI690) \| (ZI694) ) ;`
		387	`}`
		388	`{`
		389
		390	`/* Combine two declaration specifiers */`
		391	`DECL_SPEC d = ( ( (ZI716) & (ZI718) ) & dspec_duplicate ) ;`
		392	`if ( d ) report ( crt_loc, ERR_dcl_spec_dup ( d ) ) ;`
		393	`(ZI605) = ( (ZI716) \| (ZI718) ) ;`
		394	`}`
		395	`}`
		396	`break;`
		397	`default:`
		398	`{`
		399	`ZI658 = ZI688;`
		400	`ZI395 = ZI689;`
		401	`ZI630 = ZI690;`
		402	`ZI605 = ZI716;`
		403	`}`
		404	`break;`
		405	`}`
		406	`}`
		407	`}`
		408	`goto ZL0;`
		409	`ZL1:;`
		410	`SAVE_LEXER (354);`
		411	`return;`
		412	`ZL0:;`
		413	`*ZO658 = ZI658;`
		414	`*ZO395 = ZI395;`
		415	`*ZO630 = ZI630;`
		416	`*ZO605 = ZI605;`
		417	`}`
		418
		419	`void`
		420	`ZR745 PROTO_N ((ZI399, ZO395))`
		421	`PROTO_T (IDENTIFIER ZI399 X TYPE *ZO395)`
		422	`{`
		423	`TYPE ZI395;`
		424
		425	`switch (CURRENT_TERMINAL) {`
		426	`case 65:`
		427	`{`
		428	`TYPE ZI568;`
		429
		430	`ADVANCE_LEXER;`
		431	`{`
		432
		433	`func_type_defn ( 0 ) ;`
		434	`begin_param ( (ZI399) ) ;`
		435	`have_type_declaration = TYPE_DECL_NONE ;`
		436	`have_func_declarator = 0 ;`
		437	`}`
		438	`{`
		439	`switch (CURRENT_TERMINAL) {`
		440	`case 2: case 25: case 47: case 94: case 97:`
		441	`case 98: case 102: case 104: case 105: case 106:`
		442	`case 110: case 111: case 112: case 114: case 115:`
		443	`case 117: case 118: case 120: case 121: case 122:`
		444	`case 123: case 124: case 137: case 156: case 184:`
		445	`case 285: case 298:`
		446	`{`
		447	`int ZI747;`
		448
		449	`ZR743 (&ZI747);`
		450	`if ((CURRENT_TERMINAL) == 354) {`
		451	`RESTORE_LEXER;`
		452	`goto ZL1;`
		453	`}`
		454	`{`
		455
		456	`(ZI568) = make_func_type ( NULL_type, (ZI747), cv_c, empty_type_set ) ;`
		457	`}`
		458	`switch (CURRENT_TERMINAL) {`
		459	`case 39:`
		460	`break;`
		461	`default:`
		462	`goto ZL1;`
		463	`}`
		464	`ADVANCE_LEXER;`
		465	`}`
		466	`break;`
		467	`case 1: case 4:`
		468	`{`
		469	`ZR744 ();`
		470	`if ((CURRENT_TERMINAL) == 354) {`
		471	`RESTORE_LEXER;`
		472	`goto ZL1;`
		473	`}`
		474	`{`
		475
		476	`(ZI568) = make_func_type ( NULL_type, FUNC_PARAMS, cv_c, empty_type_set ) ;`
		477	`}`
		478	`switch (CURRENT_TERMINAL) {`
		479	`case 39:`
		480	`break;`
		481	`default:`
		482	`goto ZL1;`
		483	`}`
		484	`ADVANCE_LEXER;`
		485	`}`
		486	`break;`
		487	`case 39:`
		488	`{`
		489	`{`
		490
		491	`(ZI568) = make_func_type ( NULL_type, FUNC_NO_PARAMS, cv_c, empty_type_set ) ;`
		492	`}`
		493	`ADVANCE_LEXER;`
		494	`}`
		495	`break;`
		496	`default:`
		497	`goto ZL1;`
		498	`}`
		499	`}`
		500	`ZI395 = ZI568;`
		501	`{`
		502
		503	`end_param () ;`
		504	`have_type_declaration = TYPE_DECL_NONE ;`
		505	`have_func_declarator = 1 ;`
		506	`}`
		507	`}`
		508	`break;`
		509	`case 331:`
		510	`{`
		511	`int ZI747;`
		512
		513	`ADVANCE_LEXER;`
		514	`switch (CURRENT_TERMINAL) {`
		515	`case 65:`
		516	`break;`
		517	`default:`
		518	`goto ZL1;`
		519	`}`
		520	`ADVANCE_LEXER;`
		521	`{`
		522
		523	`func_type_defn ( 0 ) ;`
		524	`begin_param ( (ZI399) ) ;`
		525	`have_type_declaration = TYPE_DECL_NONE ;`
		526	`have_func_declarator = 0 ;`
		527	`}`
		528	`ZR758 (&ZI747);`
		529	`if ((CURRENT_TERMINAL) == 354) {`
		530	`RESTORE_LEXER;`
		531	`goto ZL1;`
		532	`}`
		533	`{`
		534
		535	`(ZI395) = make_func_type ( NULL_type, ( (ZI747) \| FUNC_WEAK ), cv_c, empty_type_set ) ;`
		536	`}`
		537	`switch (CURRENT_TERMINAL) {`
		538	`case 39:`
		539	`break;`
		540	`default:`
		541	`goto ZL1;`
		542	`}`
		543	`ADVANCE_LEXER;`
		544	`{`
		545
		546	`end_param () ;`
		547	`have_type_declaration = TYPE_DECL_NONE ;`
		548	`have_func_declarator = 1 ;`
		549	`}`
		550	`}`
		551	`break;`
		552	`case 66:`
		553	`{`
		554	`EXP ZI404;`
		555
		556	`{`
		557	`{`
		558	`switch (CURRENT_TERMINAL) {`
		559	`case 66:`
		560	`break;`
		561	`default:`
		562	`goto ZL1;`
		563	`}`
		564	`ADVANCE_LEXER;`
		565	`}`
		566	`}`
		567	`ZR757 (&ZI404);`
		568	`if ((CURRENT_TERMINAL) == 354) {`
		569	`RESTORE_LEXER;`
		570	`goto ZL1;`
		571	`}`
		572	`{`
		573
		574	`NAT n = make_array_dim ( (ZI404) ) ;`
		575	`MAKE_type_array ( cv_none, NULL_type, n, (ZI395) ) ;`
		576	`}`
		577	`{`
		578	`{`
		579	`switch (CURRENT_TERMINAL) {`
		580	`case 40:`
		581	`break;`
		582	`default:`
		583	`goto ZL1;`
		584	`}`
		585	`ADVANCE_LEXER;`
		586	`}`
		587	`}`
		588	`}`
		589	`break;`
		590	`case 354:`
		591	`return;`
		592	`default:`
		593	`goto ZL1;`
		594	`}`
		595	`goto ZL0;`
		596	`ZL1:;`
		597	`SAVE_LEXER (354);`
		598	`return;`
		599	`ZL0:;`
		600	`*ZO395 = ZI395;`
		601	`}`
		602
		603	`void`
		604	`ZR894 PROTO_N ((ZI892, ZO893))`
		605	`PROTO_T (EXP ZI892 X EXP *ZO893)`
		606	`{`
		607	`EXP ZI893;`
		608
		609	`ZL2_894:;`
		610	`switch (CURRENT_TERMINAL) {`
		611	`case 33:`
		612	`{`
		613	`EXP ZI448;`
		614	`EXP ZI404;`
		615
		616	`{`
		617	`{`
		618	`switch (CURRENT_TERMINAL) {`
		619	`case 33:`
		620	`break;`
		621	`default:`
		622	`goto ZL1;`
		623	`}`
		624	`ADVANCE_LEXER;`
		625	`}`
		626	`}`
		627	`ZR491 (&ZI448);`
		628	`if ((CURRENT_TERMINAL) == 354) {`
		629	`RESTORE_LEXER;`
		630	`goto ZL1;`
		631	`}`
		632	`{`
		633
		634	`(ZI404) = make_and_exp ( (ZI892), (ZI448) ) ;`
		635	`}`
		636	`ZI892 = ZI404;`
		637	`goto ZL2_894;`
		638	`}`
		639	`/UNREACHED/`
		640	`default:`
		641	`{`
		642	`ZI893 = ZI892;`
		643	`}`
		644	`break;`
		645	`case 354:`
		646	`return;`
		647	`}`
		648	`goto ZL0;`
		649	`ZL1:;`
		650	`SAVE_LEXER (354);`
		651	`return;`
		652	`ZL0:;`
		653	`*ZO893 = ZI893;`
		654	`}`
		655
		656	`void`
		657	`ZR770 PROTO_N ((ZO547))`
		658	`PROTO_T (IDENTIFIER *ZO547)`
		659	`{`
		660	`IDENTIFIER ZI547;`
		661
		662	`if ((CURRENT_TERMINAL) == 354) {`
		663	`return;`
		664	`}`
		665	`{`
		666	`BASE_TYPE ZI658;`
		667	`TYPE ZI689;`
		668	`CV_SPEC ZI630;`
		669	`DECL_SPEC ZI716;`
		670	`TYPE ZI693;`
		671	`DECL_SPEC ZI605;`
		672	`TYPE ZI395;`
		673	`IDENTIFIER ZI399;`
		674
		675	`ZR715 (&ZI658, &ZI689, &ZI630, &ZI716);`
		676	`if ((CURRENT_TERMINAL) == 354) {`
		677	`RESTORE_LEXER;`
		678	`goto ZL1;`
		679	`}`
		680	`{`
		681
		682	`/* Complete a declaration specifier and a type */`
		683	`(ZI605) = complete_dspec ( (ZI716), (ZI658), (ZI689), (ZI630) ) ;`
		684	`(ZI693) = complete_pre_type ( (ZI658), (ZI689), (ZI630), 0 ) ;`
		685	`have_type_specifier = 0 ;`
		686	`}`
		687	`ZR766 (ZI693, &ZI395, &ZI399);`
		688	`if ((CURRENT_TERMINAL) == 354) {`
		689	`RESTORE_LEXER;`
		690	`goto ZL1;`
		691	`}`
		692	`{`
		693
		694	`(ZI547) = make_param_decl ( (ZI605), (ZI395), (ZI399), CONTEXT_PARAMETER ) ;`
		695	`have_type_declaration = TYPE_DECL_NONE ;`
		696	`have_func_declarator = 0 ;`
		697	`}`
		698	`}`
		699	`goto ZL0;`
		700	`ZL1:;`
		701	`SAVE_LEXER (354);`
		702	`return;`
		703	`ZL0:;`
		704	`*ZO547 = ZI547;`
		705	`}`
		706
		707	`void`
		708	`ZR569 PROTO_N ((ZO404))`
		709	`PROTO_T (EXP *ZO404)`
		710	`{`
		711	`EXP ZI404;`
		712
		713	`if ((CURRENT_TERMINAL) == 354) {`
		714	`return;`
		715	`}`
		716	`{`
		717	`EXP ZI416;`
		718	`EXP ZI420;`
		719	`int ZI537;`
		720	`EXP ZI448;`
		721
		722	`ZR567 (&ZI416, &ZI420, &ZI537);`
		723	`{`
		724	`switch (CURRENT_TERMINAL) {`
		725	`case 28:`
		726	`{`
		727	`int ZI568;`
		728
		729	`ADVANCE_LEXER;`
		730	`{`
		731
		732	`crt_hash_cond = make_else_cond ( crt_hash_cond ) ;`
		733	`}`
		734	`{`
		735
		736	`(ZI568) = unreached_code ;`
		737	`if ( (ZI568) ) {`
		738	`if ( !unreached_last ) {`
		739	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		740	`unreached_last = 1 ;`
		741	`}`
		742	`} else {`
		743	`unreached_last = 0 ;`
		744	`}`
		745	`}`
		746	`ZR551 (&ZI448);`
		747	`if ((CURRENT_TERMINAL) == 354) {`
		748	`RESTORE_LEXER;`
		749	`goto ZL1;`
		750	`}`
		751	`}`
		752	`break;`
		753	`default:`
		754	`{`
		755	`{`
		756
		757	`(ZI448) = NULL_exp ;`
		758	`}`
		759	`}`
		760	`break;`
		761	`case 354:`
		762	`RESTORE_LEXER;`
		763	`goto ZL1;`
		764	`}`
		765	`}`
		766	`{`
		767
		768	`crt_hash_cond = (ZI420) ;`
		769	`}`
		770	`switch (CURRENT_TERMINAL) {`
		771	`case 29:`
		772	`break;`
		773	`default:`
		774	`goto ZL1;`
		775	`}`
		776	`ADVANCE_LEXER;`
		777	`{`
		778	`unreached_prev = (ZI537) ;`
		779	`}`
		780	`{`
		781
		782	`(ZI404) = end_hash_if_stmt ( (ZI416), (ZI448) ) ;`
		783	`}`
		784	`}`
		785	`goto ZL0;`
		786	`ZL1:;`
		787	`SAVE_LEXER (354);`
		788	`return;`
		789	`ZL0:;`
		790	`*ZO404 = ZI404;`
		791	`}`
		792
		793	`void`
		794	`ZR898 PROTO_N ((ZI896, ZO897))`
		795	`PROTO_T (EXP ZI896 X EXP *ZO897)`
		796	`{`
		797	`EXP ZI897;`
		798
		799	`ZL2_898:;`
		800	`switch (CURRENT_TERMINAL) {`
		801	`case 86: case 87:`
		802	`{`
		803	`int ZI460;`
		804	`EXP ZI448;`
		805	`EXP ZI404;`
		806
		807	`{`
		808	`(ZI460) = crt_lex_token ;`
		809	`}`
		810	`{`
		811	`switch (CURRENT_TERMINAL) {`
		812	`case 86:`
		813	`{`
		814	`ADVANCE_LEXER;`
		815	`}`
		816	`break;`
		817	`case 87:`
		818	`{`
		819	`ADVANCE_LEXER;`
		820	`}`
		821	`break;`
		822	`default:`
		823	`goto ZL1;`
		824	`}`
		825	`}`
		826	`ZR488 (&ZI448);`
		827	`if ((CURRENT_TERMINAL) == 354) {`
		828	`RESTORE_LEXER;`
		829	`goto ZL1;`
		830	`}`
		831	`{`
		832
		833	`(ZI404) = make_mult_exp ( (ZI460), (ZI896), (ZI448) ) ;`
		834	`}`
		835	`ZI896 = ZI404;`
		836	`goto ZL2_898;`
		837	`}`
		838	`/UNREACHED/`
		839	`default:`
		840	`{`
		841	`ZI897 = ZI896;`
		842	`}`
		843	`break;`
		844	`case 354:`
		845	`return;`
		846	`}`
		847	`goto ZL0;`
		848	`ZL1:;`
		849	`SAVE_LEXER (354);`
		850	`return;`
		851	`ZL0:;`
		852	`*ZO897 = ZI897;`
		853	`}`
		854
		855	`void`
		856	`ZR656 PROTO_N ((ZO395))`
		857	`PROTO_T (TYPE *ZO395)`
		858	`{`
		859	`TYPE ZI395;`
		860
		861	`if ((CURRENT_TERMINAL) == 354) {`
		862	`return;`
		863	`}`
		864	`{`
		865	`BASE_TYPE ZI669;`
		866
		867	`ZR670 (&ZI669);`
		868	`{`
		869	`switch (CURRENT_TERMINAL) {`
		870	`case 1: case 2: case 4:`
		871	`{`
		872	`IDENTIFIER ZI399;`
		873
		874	`{`
		875	`switch (CURRENT_TERMINAL) {`
		876	`case 1:`
		877	`{`
		878	`{`
		879
		880	`ZI399 = crt_token->pp_data.id.use ;`
		881	`}`
		882	`ADVANCE_LEXER;`
		883	`}`
		884	`break;`
		885	`case 4:`
		886	`{`
		887	`{`
		888
		889	`ZI399 = crt_token->pp_data.id.use ;`
		890	`}`
		891	`ADVANCE_LEXER;`
		892	`}`
		893	`break;`
		894	`case 2:`
		895	`{`
		896	`{`
		897
		898	`ZI399 = crt_token->pp_data.id.use ;`
		899	`}`
		900	`ADVANCE_LEXER;`
		901	`}`
		902	`break;`
		903	`default:`
		904	`goto ZL1;`
		905	`}`
		906	`}`
		907	`ZR1030 (&ZI669, &ZI399, &ZI395);`
		908	`if ((CURRENT_TERMINAL) == 354) {`
		909	`RESTORE_LEXER;`
		910	`goto ZL1;`
		911	`}`
		912	`}`
		913	`break;`
		914	`case 64:`
		915	`{`
		916	`IDENTIFIER ZI399;`
		917	`IDENTIFIER ZI420;`
		918	`int ZI585;`
		919	`IDENTIFIER ZI672;`
		920
		921	`{`
		922
		923	`HASHID nm = lookup_anon () ;`
		924	`(ZI399) = DEREF_id ( hashid_id ( nm ) ) ;`
		925	`}`
		926	`{`
		927
		928	`(ZI420) = begin_class_defn ( (ZI399), (ZI669), cinfo_none, NULL_type ) ;`
		929	`(ZI585) = in_function_defn ;`
		930	`in_function_defn = 0 ;`
		931	`in_class_defn++ ;`
		932	`really_in_class_defn++ ;`
		933	`no_type_defns++ ;`
		934	`end_base_class ( crt_class, 1 ) ;`
		935	`}`
		936	`{`
		937	`{`
		938	`switch (CURRENT_TERMINAL) {`
		939	`case 64:`
		940	`break;`
		941	`default:`
		942	`goto ZL1;`
		943	`}`
		944	`ADVANCE_LEXER;`
		945	`}`
		946	`}`
		947	`ZR662 ();`
		948	`{`
		949	`if ((CURRENT_TERMINAL) == 354) {`
		950	`RESTORE_LEXER;`
		951	`goto ZL1;`
		952	`}`
		953	`{`
		954	`switch (CURRENT_TERMINAL) {`
		955	`case 38:`
		956	`break;`
		957	`default:`
		958	`goto ZL1;`
		959	`}`
		960	`ADVANCE_LEXER;`
		961	`}`
		962	`}`
		963	`{`
		964
		965	`(ZI672) = end_class_defn ( (ZI420) ) ;`
		966	`in_function_defn = (ZI585) ;`
		967	`in_class_defn-- ;`
		968	`really_in_class_defn-- ;`
		969	`}`
		970	`{`
		971
		972	`MAKE_type_pre ( cv_none, btype_alias, qual_none, (ZI395) ) ;`
		973	`COPY_id ( type_name ( (ZI395) ), (ZI672) ) ;`
		974	`have_type_specifier = 1 ;`
		975	`}`
		976	`{`
		977
		978	`RESCAN_LEXER ;`
		979	`}`
		980	`}`
		981	`break;`
		982	`case 354:`
		983	`RESTORE_LEXER;`
		984	`goto ZL1;`
		985	`default:`
		986	`goto ZL1;`
		987	`}`
		988	`}`
		989	`}`
		990	`goto ZL0;`
		991	`ZL1:;`
		992	`SAVE_LEXER (354);`
		993	`return;`
		994	`ZL0:;`
		995	`*ZO395 = ZI395;`
		996	`}`
		997
		998	`void`
		999	`ZR427 PROTO_N ((ZI426, ZO399))`
		1000	`PROTO_T (NAMESPACE ZI426 X IDENTIFIER *ZO399)`
		1001	`{`
		1002	`IDENTIFIER ZI399;`
		1003
		1004	`if ((CURRENT_TERMINAL) == 354) {`
		1005	`return;`
		1006	`}`
		1007	`{`
		1008	`IDENTIFIER ZI428;`
		1009
		1010	`{`
		1011	`switch (CURRENT_TERMINAL) {`
		1012	`case 1:`
		1013	`{`
		1014	`{`
		1015
		1016	`ZI428 = crt_token->pp_data.id.use ;`
		1017	`}`
		1018	`ADVANCE_LEXER;`
		1019	`}`
		1020	`break;`
		1021	`case 4:`
		1022	`{`
		1023	`{`
		1024
		1025	`ZI428 = crt_token->pp_data.id.use ;`
		1026	`}`
		1027	`ADVANCE_LEXER;`
		1028	`}`
		1029	`break;`
		1030	`case 2:`
		1031	`{`
		1032	`{`
		1033
		1034	`ZI428 = crt_token->pp_data.id.use ;`
		1035	`}`
		1036	`ADVANCE_LEXER;`
		1037	`}`
		1038	`break;`
		1039	`default:`
		1040	`goto ZL1;`
		1041	`}`
		1042	`}`
		1043	`{`
		1044
		1045	`HASHID nm = DEREF_hashid ( id_name ( (ZI428) ) ) ;`
		1046	`(ZI399) = find_qual_id ( (ZI426), nm, 1, 0 ) ;`
		1047	`}`
		1048	`}`
		1049	`goto ZL0;`
		1050	`ZL1:;`
		1051	`SAVE_LEXER (354);`
		1052	`return;`
		1053	`ZL0:;`
		1054	`*ZO399 = ZI399;`
		1055	`}`
		1056
		1057	`void`
		1058	`ZR714 PROTO_N ((ZO658, ZO395, ZO630, ZO605))`
		1059	`PROTO_T (BASE_TYPE ZO658 X TYPE ZO395 X CV_SPEC ZO630 X DECL_SPEC ZO605)`
		1060	`{`
		1061	`BASE_TYPE ZI658;`
		1062	`TYPE ZI395;`
		1063	`CV_SPEC ZI630;`
		1064	`DECL_SPEC ZI605;`
		1065
		1066	`switch (CURRENT_TERMINAL) {`
		1067	`case 98: case 124:`
		1068	`{`
		1069	`ZR631 (&ZI630);`
		1070	`if ((CURRENT_TERMINAL) == 354) {`
		1071	`RESTORE_LEXER;`
		1072	`goto ZL1;`
		1073	`}`
		1074	`{`
		1075	`(ZI658) = btype_none ;`
		1076	`}`
		1077	`{`
		1078
		1079	`(ZI395) = NULL_type ;`
		1080	`}`
		1081	`{`
		1082	`(ZI605) = dspec_none ;`
		1083	`}`
		1084	`}`
		1085	`break;`
		1086	`case 94: case 105: case 112: case 117: case 120:`
		1087	`case 137:`
		1088	`{`
		1089	`ZR709 (&ZI605);`
		1090	`if ((CURRENT_TERMINAL) == 354) {`
		1091	`RESTORE_LEXER;`
		1092	`goto ZL1;`
		1093	`}`
		1094	`{`
		1095
		1096	`if ( have_type_specifier ) report ( crt_loc, ERR_dcl_spec_order ( (ZI605) ) ) ;`
		1097	`}`
		1098	`{`
		1099	`(ZI658) = btype_none ;`
		1100	`}`
		1101	`{`
		1102
		1103	`(ZI395) = NULL_type ;`
		1104	`}`
		1105	`{`
		1106	`(ZI630) = cv_none ;`
		1107	`}`
		1108	`}`
		1109	`break;`
		1110	`case 2: case 25: case 97: case 102: case 104:`
		1111	`case 106: case 110: case 111: case 114: case 115:`
		1112	`case 118: case 121: case 122: case 123: case 156:`
		1113	`case 184: case 285: case 298:`
		1114	`{`
		1115	`ZR660 (&ZI658, &ZI395);`
		1116	`if ((CURRENT_TERMINAL) == 354) {`
		1117	`RESTORE_LEXER;`
		1118	`goto ZL1;`
		1119	`}`
		1120	`{`
		1121	`(ZI630) = cv_none ;`
		1122	`}`
		1123	`{`
		1124	`(ZI605) = dspec_none ;`
		1125	`}`
		1126	`}`
		1127	`break;`
		1128	`case 354:`
		1129	`return;`
		1130	`default:`
		1131	`goto ZL1;`
		1132	`}`
		1133	`goto ZL0;`
		1134	`ZL1:;`
		1135	`SAVE_LEXER (354);`
		1136	`return;`
		1137	`ZL0:;`
		1138	`*ZO658 = ZI658;`
		1139	`*ZO395 = ZI395;`
		1140	`*ZO630 = ZI630;`
		1141	`*ZO605 = ZI605;`
		1142	`}`
		1143
		1144	`void`
		1145	`parse_init PROTO_N ((ZI547, ZO404))`
		1146	`PROTO_T (IDENTIFIER ZI547 X EXP *ZO404)`
		1147	`{`
		1148	`EXP ZI404;`
		1149
		1150	`if ((CURRENT_TERMINAL) == 354) {`
		1151	`return;`
		1152	`}`
		1153	`{`
		1154	`ZR788 (ZI547, &ZI404);`
		1155	`if ((CURRENT_TERMINAL) == 354) {`
		1156	`RESTORE_LEXER;`
		1157	`goto ZL1;`
		1158	`}`
		1159	`}`
		1160	`goto ZL0;`
		1161	`ZL1:;`
		1162	`{`
		1163	`{`
		1164
		1165	`/* Syntax errors */`
		1166	`ERROR err = ERR_lex_parse ( crt_token ) ;`
		1167	`report ( crt_loc, err ) ;`
		1168	`have_syntax_error = 1 ;`
		1169	`}`
		1170	`{`
		1171
		1172	`(ZI404) = NULL_exp ;`
		1173	`}`
		1174	`}`
		1175	`ZL0:;`
		1176	`*ZO404 = ZI404;`
		1177	`}`
		1178
		1179	`void`
		1180	`ZR1027 PROTO_N ((ZI1025, ZO404))`
		1181	`PROTO_T (EXP ZI1025 X EXP ZO404)`
		1182	`{`
		1183	`EXP ZI404;`
		1184
		1185	`switch (CURRENT_TERMINAL) {`
		1186	`case 42:`
		1187	`{`
		1188	`SID_LIST_EXP ZI423;`
		1189	`SID_LIST_EXP ZI420;`
		1190
		1191	`ADVANCE_LEXER;`
		1192	`ZR515 (&ZI423);`
		1193	`if ((CURRENT_TERMINAL) == 354) {`
		1194	`RESTORE_LEXER;`
		1195	`goto ZL1;`
		1196	`}`
		1197	`{`
		1198
		1199	`CONS_exp ( (*ZI1025), (ZI423), (ZI420) ) ;`
		1200	`}`
		1201	`{`
		1202
		1203	`(ZI404) = make_comma_exp ( (ZI420) ) ;`
		1204	`}`
		1205	`}`
		1206	`break;`
		1207	`default:`
		1208	`{`
		1209	`ZI404 = *ZI1025;`
		1210	`}`
		1211	`break;`
		1212	`case 354:`
		1213	`return;`
		1214	`}`
		1215	`goto ZL0;`
		1216	`ZL1:;`
		1217	`SAVE_LEXER (354);`
		1218	`return;`
		1219	`ZL0:;`
		1220	`*ZO404 = ZI404;`
		1221	`}`
		1222
		1223	`void`
		1224	`ZR803 PROTO_Z ()`
		1225	`{`
		1226	`if ((CURRENT_TERMINAL) == 354) {`
		1227	`return;`
		1228	`}`
		1229	`ZL2_803:;`
		1230	`{`
		1231	`BASE_TYPE ZI937;`
		1232	`TYPE ZI938;`
		1233	`CV_SPEC ZI939;`
		1234	`DECL_SPEC ZI940;`
		1235	`BASE_TYPE ZI941;`
		1236	`TYPE ZI942;`
		1237	`CV_SPEC ZI943;`
		1238	`DECL_SPEC ZI944;`
		1239	`EXP ZI404;`
		1240
		1241	`{`
		1242
		1243	`/* Resolve declaration-specifiers from other declarators */`
		1244	`(ZI0) = predict_dspec ( 0 ) ;`
		1245	`}`
		1246	`if (!ZI0)`
		1247	`goto ZL3;`
		1248	`ZR714 (&ZI937, &ZI938, &ZI939, &ZI940);`
		1249	`if ((CURRENT_TERMINAL) == 354) {`
		1250	`RESTORE_LEXER;`
		1251	`goto ZL1;`
		1252	`}`
		1253	`{`
		1254
		1255	`/* A type-name can be a declarator-id */`
		1256	`if ( have_type_specifier && crt_lex_token == lex_type_Hname ) {`
		1257	`crt_lex_token = lex_identifier ;`
		1258	`}`
		1259	`}`
		1260	`ZR724 (&ZI937, &ZI938, &ZI939, &ZI940, &ZI941, &ZI942, &ZI943, &ZI944);`
		1261	`ZR945 (&ZI941, &ZI942, &ZI943, &ZI944, &ZI404);`
		1262	`if ((CURRENT_TERMINAL) == 354) {`
		1263	`RESTORE_LEXER;`
		1264	`goto ZL1;`
		1265	`}`
		1266	`{`
		1267
		1268	`external_declaration ( (ZI404), 1 ) ;`
		1269	`}`
		1270	`goto ZL2_803;`
		1271	`}`
		1272	`/UNREACHED/`
		1273	`ZL3:;`
		1274	`switch (CURRENT_TERMINAL) {`
		1275	`case 77:`
		1276	`{`
		1277	`ADVANCE_LEXER;`
		1278	`{`
		1279
		1280	`report ( crt_loc, ERR_dcl_dcl_semicolon () ) ;`
		1281	`}`
		1282	`goto ZL2_803;`
		1283	`}`
		1284	`/UNREACHED/`
		1285	`case 126:`
		1286	`{`
		1287	`EXP ZI404;`
		1288
		1289	`ZR623 (&ZI404);`
		1290	`if ((CURRENT_TERMINAL) == 354) {`
		1291	`RESTORE_LEXER;`
		1292	`goto ZL1;`
		1293	`}`
		1294	`{`
		1295
		1296	`external_declaration ( (ZI404), 1 ) ;`
		1297	`}`
		1298	`goto ZL2_803;`
		1299	`}`
		1300	`/UNREACHED/`
		1301	`case 26: case 30:`
		1302	`{`
		1303	`ZR806 ();`
		1304	`if ((CURRENT_TERMINAL) == 354) {`
		1305	`RESTORE_LEXER;`
		1306	`goto ZL1;`
		1307	`} else {`
		1308	`goto ZL2_803;`
		1309	`}`
		1310	`}`
		1311	`/UNREACHED/`
		1312	`case 1: case 2: case 4: case 65: case 78:`
		1313	`{`
		1314	`BASE_TYPE ZI658;`
		1315	`TYPE ZI689;`
		1316	`CV_SPEC ZI630;`
		1317	`DECL_SPEC ZI716;`
		1318	`TYPE ZI395;`
		1319	`DECL_SPEC ZI605;`
		1320	`TYPE ZI568;`
		1321	`IDENTIFIER ZI399;`
		1322	`EXP ZI404;`
		1323
		1324	`{`
		1325	`(ZI658) = btype_none ;`
		1326	`}`
		1327	`{`
		1328
		1329	`(ZI689) = NULL_type ;`
		1330	`}`
		1331	`{`
		1332	`(ZI630) = cv_none ;`
		1333	`}`
		1334	`{`
		1335	`(ZI716) = dspec_none ;`
		1336	`}`
		1337	`{`
		1338
		1339	`/* Complete a declaration specifier and a type */`
		1340	`(ZI605) = complete_dspec ( (ZI716), (ZI658), (ZI689), (ZI630) ) ;`
		1341	`(ZI395) = complete_pre_type ( (ZI658), (ZI689), (ZI630), 0 ) ;`
		1342	`have_type_specifier = 0 ;`
		1343	`}`
		1344	`ZR752 (ZI395, &ZI568, &ZI399);`
		1345	`ZR819 (&ZI658, &ZI395, &ZI605, &ZI568, &ZI399);`
		1346	`if ((CURRENT_TERMINAL) == 354) {`
		1347	`RESTORE_LEXER;`
		1348	`goto ZL1;`
		1349	`}`
		1350	`{`
		1351
		1352	`(ZI404) = NULL_exp ;`
		1353	`}`
		1354	`{`
		1355
		1356	`external_declaration ( (ZI404), 1 ) ;`
		1357	`}`
		1358	`goto ZL2_803;`
		1359	`}`
		1360	`/UNREACHED/`
		1361	`default:`
		1362	`break;`
		1363	`}`
		1364	`return;`
		1365	`ZL1:;`
		1366	`SAVE_LEXER (354);`
		1367	`return;`
		1368	`}`
		1369
		1370	`void`
		1371	`ZR1028 PROTO_N ((ZI416, ZO420))`
		1372	`PROTO_T (EXP ZI416 X SID_LIST_EXP ZO420)`
		1373	`{`
		1374	`SID_LIST_EXP ZI420;`
		1375
		1376	`switch (CURRENT_TERMINAL) {`
		1377	`case 42:`
		1378	`{`
		1379	`SID_LIST_EXP ZI423;`
		1380
		1381	`ADVANCE_LEXER;`
		1382	`ZR515 (&ZI423);`
		1383	`if ((CURRENT_TERMINAL) == 354) {`
		1384	`RESTORE_LEXER;`
		1385	`goto ZL1;`
		1386	`}`
		1387	`{`
		1388
		1389	`CONS_exp ( (*ZI416), (ZI423), (ZI420) ) ;`
		1390	`}`
		1391	`}`
		1392	`break;`
		1393	`default:`
		1394	`{`
		1395	`SID_LIST_EXP ZI423;`
		1396
		1397	`{`
		1398
		1399	`(ZI423) = NULL_list ( EXP ) ;`
		1400	`}`
		1401	`{`
		1402
		1403	`CONS_exp ( (*ZI416), (ZI423), (ZI420) ) ;`
		1404	`}`
		1405	`}`
		1406	`break;`
		1407	`case 354:`
		1408	`return;`
		1409	`}`
		1410	`goto ZL0;`
		1411	`ZL1:;`
		1412	`SAVE_LEXER (354);`
		1413	`return;`
		1414	`ZL0:;`
		1415	`*ZO420 = ZI420;`
		1416	`}`
		1417
		1418	`void`
		1419	`ZR754 PROTO_N ((ZO395))`
		1420	`PROTO_T (TYPE *ZO395)`
		1421	`{`
		1422	`TYPE ZI395;`
		1423
		1424	`switch (CURRENT_TERMINAL) {`
		1425	`case 65:`
		1426	`{`
		1427	`IDENTIFIER ZI399;`
		1428	`TYPE ZI568;`
		1429
		1430	`ADVANCE_LEXER;`
		1431	`{`
		1432
		1433	`(ZI399) = NULL_id ;`
		1434	`}`
		1435	`{`
		1436
		1437	`func_type_defn ( 0 ) ;`
		1438	`begin_param ( (ZI399) ) ;`
		1439	`have_type_declaration = TYPE_DECL_NONE ;`
		1440	`have_func_declarator = 0 ;`
		1441	`}`
		1442	`ZR755 (&ZI568);`
		1443	`switch (CURRENT_TERMINAL) {`
		1444	`case 39:`
		1445	`break;`
		1446	`case 354:`
		1447	`RESTORE_LEXER;`
		1448	`goto ZL1;`
		1449	`default:`
		1450	`goto ZL1;`
		1451	`}`
		1452	`ADVANCE_LEXER;`
		1453	`ZI395 = ZI568;`
		1454	`{`
		1455
		1456	`end_param () ;`
		1457	`have_type_declaration = TYPE_DECL_NONE ;`
		1458	`have_func_declarator = 1 ;`
		1459	`}`
		1460	`}`
		1461	`break;`
		1462	`case 331:`
		1463	`{`
		1464	`IDENTIFIER ZI399;`
		1465	`int ZI747;`
		1466
		1467	`ADVANCE_LEXER;`
		1468	`switch (CURRENT_TERMINAL) {`
		1469	`case 65:`
		1470	`break;`
		1471	`default:`
		1472	`goto ZL1;`
		1473	`}`
		1474	`ADVANCE_LEXER;`
		1475	`{`
		1476
		1477	`(ZI399) = NULL_id ;`
		1478	`}`
		1479	`{`
		1480
		1481	`func_type_defn ( 0 ) ;`
		1482	`begin_param ( (ZI399) ) ;`
		1483	`have_type_declaration = TYPE_DECL_NONE ;`
		1484	`have_func_declarator = 0 ;`
		1485	`}`
		1486	`ZR758 (&ZI747);`
		1487	`if ((CURRENT_TERMINAL) == 354) {`
		1488	`RESTORE_LEXER;`
		1489	`goto ZL1;`
		1490	`}`
		1491	`{`
		1492
		1493	`(ZI395) = make_func_type ( NULL_type, ( (ZI747) \| FUNC_WEAK ), cv_c, empty_type_set ) ;`
		1494	`}`
		1495	`switch (CURRENT_TERMINAL) {`
		1496	`case 39:`
		1497	`break;`
		1498	`default:`
		1499	`goto ZL1;`
		1500	`}`
		1501	`ADVANCE_LEXER;`
		1502	`{`
		1503
		1504	`end_param () ;`
		1505	`have_type_declaration = TYPE_DECL_NONE ;`
		1506	`have_func_declarator = 1 ;`
		1507	`}`
		1508	`}`
		1509	`break;`
		1510	`case 66:`
		1511	`{`
		1512	`EXP ZI404;`
		1513
		1514	`{`
		1515	`{`
		1516	`switch (CURRENT_TERMINAL) {`
		1517	`case 66:`
		1518	`break;`
		1519	`default:`
		1520	`goto ZL1;`
		1521	`}`
		1522	`ADVANCE_LEXER;`
		1523	`}`
		1524	`}`
		1525	`ZR757 (&ZI404);`
		1526	`if ((CURRENT_TERMINAL) == 354) {`
		1527	`RESTORE_LEXER;`
		1528	`goto ZL1;`
		1529	`}`
		1530	`{`
		1531
		1532	`NAT n = make_array_dim ( (ZI404) ) ;`
		1533	`MAKE_type_array ( cv_none, NULL_type, n, (ZI395) ) ;`
		1534	`}`
		1535	`{`
		1536	`{`
		1537	`switch (CURRENT_TERMINAL) {`
		1538	`case 40:`
		1539	`break;`
		1540	`default:`
		1541	`goto ZL1;`
		1542	`}`
		1543	`ADVANCE_LEXER;`
		1544	`}`
		1545	`}`
		1546	`}`
		1547	`break;`
		1548	`case 354:`
		1549	`return;`
		1550	`default:`
		1551	`goto ZL1;`
		1552	`}`
		1553	`goto ZL0;`
		1554	`ZL1:;`
		1555	`SAVE_LEXER (354);`
		1556	`return;`
		1557	`ZL0:;`
		1558	`*ZO395 = ZI395;`
		1559	`}`
		1560
		1561	`void`
		1562	`ZR1029 PROTO_N ((ZO404))`
		1563	`PROTO_T (EXP *ZO404)`
		1564	`{`
		1565	`EXP ZI404;`
		1566
		1567	`switch (CURRENT_TERMINAL) {`
		1568	`case 297:`
		1569	`{`
		1570	`EXP ZI416;`
		1571
		1572	`ADVANCE_LEXER;`
		1573	`ZR414 (&ZI416);`
		1574	`if ((CURRENT_TERMINAL) == 354) {`
		1575	`RESTORE_LEXER;`
		1576	`goto ZL1;`
		1577	`}`
		1578	`{`
		1579
		1580	`(ZI404) = make_set_exp ( (ZI416) ) ;`
		1581	`}`
		1582	`switch (CURRENT_TERMINAL) {`
		1583	`case 346:`
		1584	`break;`
		1585	`default:`
		1586	`goto ZL1;`
		1587	`}`
		1588	`ADVANCE_LEXER;`
		1589	`}`
		1590	`break;`
		1591	`case 323:`
		1592	`{`
		1593	`EXP ZI416;`
		1594
		1595	`ADVANCE_LEXER;`
		1596	`ZR414 (&ZI416);`
		1597	`if ((CURRENT_TERMINAL) == 354) {`
		1598	`RESTORE_LEXER;`
		1599	`goto ZL1;`
		1600	`}`
		1601	`{`
		1602
		1603	`(ZI404) = make_unused_exp ( (ZI416) ) ;`
		1604	`}`
		1605	`switch (CURRENT_TERMINAL) {`
		1606	`case 346:`
		1607	`break;`
		1608	`default:`
		1609	`goto ZL1;`
		1610	`}`
		1611	`ADVANCE_LEXER;`
		1612	`}`
		1613	`break;`
		1614	`case 354:`
		1615	`return;`
		1616	`default:`
		1617	`goto ZL1;`
		1618	`}`
		1619	`goto ZL0;`
		1620	`ZL1:;`
		1621	`SAVE_LEXER (354);`
		1622	`return;`
		1623	`ZL0:;`
		1624	`*ZO404 = ZI404;`
		1625	`}`
		1626
		1627	`void`
		1628	`ZR902 PROTO_N ((ZI900, ZO901))`
		1629	`PROTO_T (EXP ZI900 X EXP *ZO901)`
		1630	`{`
		1631	`EXP ZI901;`
		1632
		1633	`ZL2_902:;`
		1634	`switch (CURRENT_TERMINAL) {`
		1635	`case 48: case 63:`
		1636	`{`
		1637	`int ZI460;`
		1638	`EXP ZI448;`
		1639	`EXP ZI404;`
		1640
		1641	`{`
		1642	`(ZI460) = crt_lex_token ;`
		1643	`}`
		1644	`ZR487 ();`
		1645	`ZR485 (&ZI448);`
		1646	`if ((CURRENT_TERMINAL) == 354) {`
		1647	`RESTORE_LEXER;`
		1648	`goto ZL1;`
		1649	`}`
		1650	`{`
		1651
		1652	`/* op will be in its primary form */`
		1653	`(ZI404) = make_equality_exp ( (ZI460), (ZI900), (ZI448) ) ;`
		1654	`}`
		1655	`ZI900 = ZI404;`
		1656	`goto ZL2_902;`
		1657	`}`
		1658	`/UNREACHED/`
		1659	`default:`
		1660	`{`
		1661	`ZI901 = ZI900;`
		1662	`}`
		1663	`break;`
		1664	`case 354:`
		1665	`return;`
		1666	`}`
		1667	`goto ZL0;`
		1668	`ZL1:;`
		1669	`SAVE_LEXER (354);`
		1670	`return;`
		1671	`ZL0:;`
		1672	`*ZO901 = ZI901;`
		1673	`}`
		1674
		1675	`void`
		1676	`ZR556 PROTO_N ((ZI467, ZO404))`
		1677	`PROTO_T (EXP ZI467 X EXP *ZO404)`
		1678	`{`
		1679	`EXP ZI404;`
		1680
		1681	`if ((CURRENT_TERMINAL) == 354) {`
		1682	`return;`
		1683	`}`
		1684	`{`
		1685	`EXP ZI416;`
		1686
		1687	`ZR555 (ZI467, &ZI416);`
		1688	`if ((CURRENT_TERMINAL) == 354) {`
		1689	`RESTORE_LEXER;`
		1690	`goto ZL1;`
		1691	`}`
		1692	`{`
		1693
		1694	`(ZI404) = end_compound_stmt ( (ZI416) ) ;`
		1695	`}`
		1696	`{`
		1697
		1698	`RESCAN_LEXER ;`
		1699	`}`
		1700	`}`
		1701	`goto ZL0;`
		1702	`ZL1:;`
		1703	`{`
		1704	`{`
		1705
		1706	`/* Syntax errors */`
		1707	`ERROR err = ERR_lex_parse ( crt_token ) ;`
		1708	`report ( crt_loc, err ) ;`
		1709	`have_syntax_error = 1 ;`
		1710	`}`
		1711	`{`
		1712
		1713	`(ZI404) = end_compound_stmt ( (ZI467) ) ;`
		1714	`}`
		1715	`{`
		1716
		1717	`RESCAN_LEXER ;`
		1718	`}`
		1719	`}`
		1720	`ZL0:;`
		1721	`*ZO404 = ZI404;`
		1722	`}`
		1723
		1724	`void`
		1725	`ZR1030 PROTO_N ((ZI669, ZI399, ZO395))`
		1726	`PROTO_T (BASE_TYPE ZI669 X IDENTIFIER ZI399 X TYPE *ZO395)`
		1727	`{`
		1728	`TYPE ZI395;`
		1729
		1730	`switch (CURRENT_TERMINAL) {`
		1731	`case 64:`
		1732	`{`
		1733	`IDENTIFIER ZI420;`
		1734	`int ZI585;`
		1735	`IDENTIFIER ZI672;`
		1736
		1737	`{`
		1738
		1739	`(ZI420) = begin_class_defn ( (ZI399), (ZI669), cinfo_none, NULL_type ) ;`
		1740	`(ZI585) = in_function_defn ;`
		1741	`in_function_defn = 0 ;`
		1742	`in_class_defn++ ;`
		1743	`really_in_class_defn++ ;`
		1744	`no_type_defns++ ;`
		1745	`end_base_class ( crt_class, 1 ) ;`
		1746	`}`
		1747	`{`
		1748	`{`
		1749	`switch (CURRENT_TERMINAL) {`
		1750	`case 64:`
		1751	`break;`
		1752	`default:`
		1753	`goto ZL1;`
		1754	`}`
		1755	`ADVANCE_LEXER;`
		1756	`}`
		1757	`}`
		1758	`ZR662 ();`
		1759	`{`
		1760	`if ((CURRENT_TERMINAL) == 354) {`
		1761	`RESTORE_LEXER;`
		1762	`goto ZL1;`
		1763	`}`
		1764	`{`
		1765	`switch (CURRENT_TERMINAL) {`
		1766	`case 38:`
		1767	`break;`
		1768	`default:`
		1769	`goto ZL1;`
		1770	`}`
		1771	`ADVANCE_LEXER;`
		1772	`}`
		1773	`}`
		1774	`{`
		1775
		1776	`(ZI672) = end_class_defn ( (ZI420) ) ;`
		1777	`in_function_defn = (ZI585) ;`
		1778	`in_class_defn-- ;`
		1779	`really_in_class_defn-- ;`
		1780	`}`
		1781	`{`
		1782
		1783	`MAKE_type_pre ( cv_none, btype_alias, qual_none, (ZI395) ) ;`
		1784	`COPY_id ( type_name ( (ZI395) ), (ZI672) ) ;`
		1785	`have_type_specifier = 1 ;`
		1786	`}`
		1787	`{`
		1788
		1789	`RESCAN_LEXER ;`
		1790	`}`
		1791	`}`
		1792	`break;`
		1793	`default:`
		1794	`{`
		1795	`{`
		1796
		1797	`MAKE_type_pre ( cv_none, (*ZI669), qual_none, (ZI395) ) ;`
		1798	`COPY_id ( type_name ( (ZI395) ), (*ZI399) ) ;`
		1799	`if ( have_type_declaration == TYPE_DECL_NONE ) {`
		1800	`have_type_declaration = TYPE_DECL_ELABORATE ;`
		1801	`}`
		1802	`have_type_specifier = 1 ;`
		1803	`}`
		1804	`}`
		1805	`break;`
		1806	`case 354:`
		1807	`return;`
		1808	`}`
		1809	`goto ZL0;`
		1810	`ZL1:;`
		1811	`SAVE_LEXER (354);`
		1812	`return;`
		1813	`ZL0:;`
		1814	`*ZO395 = ZI395;`
		1815	`}`
		1816
		1817	`void`
		1818	`ZR796 PROTO_N ((ZI605, ZI658, ZI420))`
		1819	`PROTO_T (DECL_SPEC ZI605 X BASE_TYPE ZI658 X TYPE ZI420)`
		1820	`{`
		1821	`if ((CURRENT_TERMINAL) == 354) {`
		1822	`return;`
		1823	`}`
		1824	`{`
		1825	`TYPE ZI395;`
		1826	`IDENTIFIER ZI399;`
		1827	`IDENTIFIER ZI547;`
		1828	`EXP ZI404;`
		1829
		1830	`ZR752 (ZI420, &ZI395, &ZI399);`
		1831	`if ((CURRENT_TERMINAL) == 354) {`
		1832	`RESTORE_LEXER;`
		1833	`goto ZL1;`
		1834	`}`
		1835	`{`
		1836
		1837	`if ( in_weak_param ) {`
		1838	`(ZI547) = make_param_decl ( (ZI605), (ZI395), (ZI399), CONTEXT_WEAK_PARAM ) ;`
		1839	`} else if ( type_tag ( (ZI395) ) == type_func_tag ) {`
		1840	`check_weak_func ( (ZI395), 0 ) ;`
		1841	`(ZI547) = make_func_decl ( (ZI605), (ZI395), (ZI399), 0 ) ;`
		1842	`} else {`
		1843	`int def = predict_obj_defn () ;`
		1844	`(ZI547) = make_object_decl ( (ZI605), (ZI395), (ZI399), def ) ;`
		1845	`}`
		1846	`if ( IS_id_type_alias ( (ZI547) ) ) {`
		1847	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI547) ) ) ;`
		1848	`bs \|= (ZI658) ;`
		1849	`COPY_btype ( id_type_alias_rep ( (ZI547) ), bs ) ;`
		1850	`}`
		1851	`have_type_declaration = TYPE_DECL_NONE ;`
		1852	`have_func_declarator = 0 ;`
		1853	`}`
		1854	`ZR792 (ZI547, &ZI404);`
		1855	`if ((CURRENT_TERMINAL) == 354) {`
		1856	`RESTORE_LEXER;`
		1857	`goto ZL1;`
		1858	`}`
		1859	`{`
		1860
		1861	`int def = init_object ( (ZI547), (ZI404) ) ;`
		1862	`if ( do_dump ) dump_declare ( (ZI547), &decl_loc, def ) ;`
		1863	`}`
		1864	`}`
		1865	`return;`
		1866	`ZL1:;`
		1867	`SAVE_LEXER (354);`
		1868	`return;`
		1869	`}`
		1870
		1871	`void`
		1872	`ZR1031 PROTO_N ((ZI658, ZI420, ZI630))`
		1873	`PROTO_T (BASE_TYPE ZI658 X TYPE ZI420 X CV_SPEC *ZI630)`
		1874	`{`
		1875	`switch (CURRENT_TERMINAL) {`
		1876	`case 77:`
		1877	`{`
		1878	`{`
		1879
		1880	`IGNORE empty_decl ( dspec_none, NULL_type, (ZI658), (ZI420), (*ZI630), last_lex_token, 1 ) ;`
		1881	`have_type_declaration = TYPE_DECL_NONE ;`
		1882	`have_func_declarator = 0 ;`
		1883	`have_type_specifier = 0 ;`
		1884	`}`
		1885	`ADVANCE_LEXER;`
		1886	`}`
		1887	`break;`
		1888	`case 1: case 2: case 4: case 41: case 65:`
		1889	`case 78:`
		1890	`{`
		1891	`TYPE ZI395;`
		1892
		1893	`{`
		1894
		1895	`(ZI395) = complete_pre_type ( (ZI658), (ZI420), (*ZI630), 1 ) ;`
		1896	`have_type_specifier = 0 ;`
		1897	`}`
		1898	`ZR824 (ZI395, *ZI658);`
		1899	`{`
		1900	`switch (CURRENT_TERMINAL) {`
		1901	`case 42:`
		1902	`{`
		1903	`ADVANCE_LEXER;`
		1904	`ZR825 (ZI395, *ZI658);`
		1905	`switch (CURRENT_TERMINAL) {`
		1906	`case 77:`
		1907	`break;`
		1908	`case 354:`
		1909	`RESTORE_LEXER;`
		1910	`goto ZL1;`
		1911	`default:`
		1912	`goto ZL1;`
		1913	`}`
		1914	`ADVANCE_LEXER;`
		1915	`}`
		1916	`break;`
		1917	`case 77:`
		1918	`{`
		1919	`ADVANCE_LEXER;`
		1920	`}`
		1921	`break;`
		1922	`case 354:`
		1923	`RESTORE_LEXER;`
		1924	`goto ZL1;`
		1925	`default:`
		1926	`goto ZL1;`
		1927	`}`
		1928	`}`
		1929	`}`
		1930	`break;`
		1931	`case 354:`
		1932	`return;`
		1933	`default:`
		1934	`goto ZL1;`
		1935	`}`
		1936	`return;`
		1937	`ZL1:;`
		1938	`SAVE_LEXER (354);`
		1939	`return;`
		1940	`}`
		1941
		1942	`void`
		1943	`ZR559 PROTO_Z ()`
		1944	`{`
		1945	`if ((CURRENT_TERMINAL) == 354) {`
		1946	`return;`
		1947	`}`
		1948	`{`
		1949	`BASE_TYPE ZI688;`
		1950	`TYPE ZI1094;`
		1951	`CV_SPEC ZI690;`
		1952	`DECL_SPEC ZI1095;`
		1953	`BASE_TYPE ZI658;`
		1954	`TYPE ZI689;`
		1955	`CV_SPEC ZI630;`
		1956	`DECL_SPEC ZI716;`
		1957
		1958	`{`
		1959
		1960	`/* Resolve declaration-specifiers from other declarators */`
		1961	`(ZI0) = predict_dspec ( 0 ) ;`
		1962	`}`
		1963	`if (!ZI0)`
		1964	`goto ZL1;`
		1965	`ZR714 (&ZI688, &ZI1094, &ZI690, &ZI1095);`
		1966	`if ((CURRENT_TERMINAL) == 354) {`
		1967	`RESTORE_LEXER;`
		1968	`goto ZL1;`
		1969	`}`
		1970	`{`
		1971
		1972	`/* A type-name can be a declarator-id */`
		1973	`if ( have_type_specifier && crt_lex_token == lex_type_Hname ) {`
		1974	`crt_lex_token = lex_identifier ;`
		1975	`}`
		1976	`}`
		1977	`ZR724 (&ZI688, &ZI1094, &ZI690, &ZI1095, &ZI658, &ZI689, &ZI630, &ZI716);`
		1978	`ZR813 (&ZI658, &ZI689, &ZI630, &ZI716);`
		1979	`switch (CURRENT_TERMINAL) {`
		1980	`case 77:`
		1981	`break;`
		1982	`case 354:`
		1983	`RESTORE_LEXER;`
		1984	`goto ZL1;`
		1985	`default:`
		1986	`goto ZL1;`
		1987	`}`
		1988	`ADVANCE_LEXER;`
		1989	`}`
		1990	`return;`
		1991	`ZL1:;`
		1992	`SAVE_LEXER (354);`
		1993	`return;`
		1994	`}`
		1995
		1996	`void`
		1997	`ZR415 PROTO_N ((ZO404))`
		1998	`PROTO_T (EXP *ZO404)`
		1999	`{`
		2000	`EXP ZI404;`
		2001
		2002	`switch (CURRENT_TERMINAL) {`
		2003	`case 23:`
		2004	`{`
		2005	`{`
		2006
		2007	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		2008	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		2009	`ZI404 = parse_exp_token ( id, args ) ;`
		2010	`RESCAN_LEXER ;`
		2011	`}`
		2012	`ADVANCE_LEXER;`
		2013	`}`
		2014	`break;`
		2015	`case 209:`
		2016	`{`
		2017	`ADVANCE_LEXER;`
		2018	`{`
		2019
		2020	`(ZI404) = make_ellipsis_exp () ;`
		2021	`}`
		2022	`}`
		2023	`break;`
		2024	`case 1:`
		2025	`{`
		2026	`IDENTIFIER ZI399;`
		2027
		2028	`{`
		2029
		2030	`ZI399 = crt_token->pp_data.id.use ;`
		2031	`}`
		2032	`ADVANCE_LEXER;`
		2033	`{`
		2034
		2035	`(ZI404) = make_id_exp ( (ZI399) ) ;`
		2036	`}`
		2037	`}`
		2038	`break;`
		2039	`case 65:`
		2040	`{`
		2041	`EXP ZI416;`
		2042
		2043	`ADVANCE_LEXER;`
		2044	`{`
		2045
		2046	`IGNORE incr_value ( OPT_VAL_paren_depth ) ;`
		2047	`}`
		2048	`ZR414 (&ZI416);`
		2049	`if ((CURRENT_TERMINAL) == 354) {`
		2050	`RESTORE_LEXER;`
		2051	`goto ZL1;`
		2052	`}`
		2053	`{`
		2054
		2055	`(ZI404) = make_paren_exp ( (ZI416) ) ;`
		2056	`decr_value ( OPT_VAL_paren_depth ) ;`
		2057	`}`
		2058	`switch (CURRENT_TERMINAL) {`
		2059	`case 39:`
		2060	`break;`
		2061	`default:`
		2062	`goto ZL1;`
		2063	`}`
		2064	`ADVANCE_LEXER;`
		2065	`}`
		2066	`break;`
		2067	`case 17: case 18: case 19: case 20: case 21:`
		2068	`case 22:`
		2069	`{`
		2070	`ZR409 (&ZI404);`
		2071	`if ((CURRENT_TERMINAL) == 354) {`
		2072	`RESTORE_LEXER;`
		2073	`goto ZL1;`
		2074	`}`
		2075	`}`
		2076	`break;`
		2077	`case 354:`
		2078	`return;`
		2079	`default:`
		2080	`goto ZL1;`
		2081	`}`
		2082	`goto ZL0;`
		2083	`ZL1:;`
		2084	`SAVE_LEXER (354);`
		2085	`return;`
		2086	`ZL0:;`
		2087	`*ZO404 = ZI404;`
		2088	`}`
		2089
		2090	`void`
		2091	`ZR906 PROTO_N ((ZI904, ZO905))`
		2092	`PROTO_T (EXP ZI904 X EXP *ZO905)`
		2093	`{`
		2094	`EXP ZI905;`
		2095
		2096	`ZL2_906:;`
		2097	`switch (CURRENT_TERMINAL) {`
		2098	`case 49: case 50: case 53: case 54:`
		2099	`{`
		2100	`int ZI460;`
		2101	`EXP ZI448;`
		2102	`EXP ZI404;`
		2103
		2104	`{`
		2105	`(ZI460) = crt_lex_token ;`
		2106	`}`
		2107	`{`
		2108	`switch (CURRENT_TERMINAL) {`
		2109	`case 49:`
		2110	`{`
		2111	`ADVANCE_LEXER;`
		2112	`}`
		2113	`break;`
		2114	`case 50:`
		2115	`{`
		2116	`ADVANCE_LEXER;`
		2117	`}`
		2118	`break;`
		2119	`case 53:`
		2120	`{`
		2121	`ADVANCE_LEXER;`
		2122	`}`
		2123	`break;`
		2124	`case 54:`
		2125	`{`
		2126	`ADVANCE_LEXER;`
		2127	`}`
		2128	`break;`
		2129	`default:`
		2130	`goto ZL1;`
		2131	`}`
		2132	`}`
		2133	`ZR482 (&ZI448);`
		2134	`if ((CURRENT_TERMINAL) == 354) {`
		2135	`RESTORE_LEXER;`
		2136	`goto ZL1;`
		2137	`}`
		2138	`{`
		2139
		2140	`/* op will be in its primary form */`
		2141	`(ZI404) = make_relation_exp ( (ZI460), (ZI904), (ZI448) ) ;`
		2142	`}`
		2143	`ZI904 = ZI404;`
		2144	`goto ZL2_906;`
		2145	`}`
		2146	`/UNREACHED/`
		2147	`default:`
		2148	`{`
		2149	`ZI905 = ZI904;`
		2150	`}`
		2151	`break;`
		2152	`case 354:`
		2153	`return;`
		2154	`}`
		2155	`goto ZL0;`
		2156	`ZL1:;`
		2157	`SAVE_LEXER (354);`
		2158	`return;`
		2159	`ZL0:;`
		2160	`*ZO905 = ZI905;`
		2161	`}`
		2162
		2163	`void`
		2164	`ZR620 PROTO_N ((ZO404))`
		2165	`PROTO_T (EXP *ZO404)`
		2166	`{`
		2167	`EXP ZI404;`
		2168
		2169	`switch (CURRENT_TERMINAL) {`
		2170	`case 288:`
		2171	`{`
		2172	`EXP ZI416;`
		2173
		2174	`ADVANCE_LEXER;`
		2175	`{`
		2176	`unreached_code = 0 ;`
		2177	`}`
		2178	`ZR528 (&ZI416);`
		2179	`if ((CURRENT_TERMINAL) == 354) {`
		2180	`RESTORE_LEXER;`
		2181	`goto ZL1;`
		2182	`}`
		2183	`{`
		2184
		2185	`(ZI404) = make_reach_stmt ( (ZI416), 1 ) ;`
		2186	`}`
		2187	`}`
		2188	`break;`
		2189	`case 322:`
		2190	`{`
		2191	`EXP ZI416;`
		2192
		2193	`ADVANCE_LEXER;`
		2194	`{`
		2195	`unreached_code = 1 ;`
		2196	`}`
		2197	`ZR528 (&ZI416);`
		2198	`if ((CURRENT_TERMINAL) == 354) {`
		2199	`RESTORE_LEXER;`
		2200	`goto ZL1;`
		2201	`}`
		2202	`{`
		2203
		2204	`(ZI404) = make_reach_stmt ( (ZI416), 0 ) ;`
		2205	`}`
		2206	`}`
		2207	`break;`
		2208	`case 354:`
		2209	`return;`
		2210	`default:`
		2211	`goto ZL1;`
		2212	`}`
		2213	`goto ZL0;`
		2214	`ZL1:;`
		2215	`SAVE_LEXER (354);`
		2216	`return;`
		2217	`ZL0:;`
		2218	`*ZO404 = ZI404;`
		2219	`}`
		2220
		2221	`void`
		2222	`ZR670 PROTO_N ((ZO669))`
		2223	`PROTO_T (BASE_TYPE *ZO669)`
		2224	`{`
		2225	`BASE_TYPE ZI669;`
		2226
		2227	`switch (CURRENT_TERMINAL) {`
		2228	`case 118:`
		2229	`{`
		2230	`ADVANCE_LEXER;`
		2231	`{`
		2232	`(ZI669) = btype_struct ;`
		2233	`}`
		2234	`}`
		2235	`break;`
		2236	`case 121:`
		2237	`{`
		2238	`ADVANCE_LEXER;`
		2239	`{`
		2240	`(ZI669) = btype_union ;`
		2241	`}`
		2242	`}`
		2243	`break;`
		2244	`case 354:`
		2245	`return;`
		2246	`default:`
		2247	`goto ZL1;`
		2248	`}`
		2249	`goto ZL0;`
		2250	`ZL1:;`
		2251	`SAVE_LEXER (354);`
		2252	`return;`
		2253	`ZL0:;`
		2254	`*ZO669 = ZI669;`
		2255	`}`
		2256
		2257	`void`
		2258	`ZR789 PROTO_N ((ZI547, ZO420))`
		2259	`PROTO_T (IDENTIFIER ZI547 X SID_LIST_EXP *ZO420)`
		2260	`{`
		2261	`SID_LIST_EXP ZI420;`
		2262
		2263	`if ((CURRENT_TERMINAL) == 354) {`
		2264	`return;`
		2265	`}`
		2266	`{`
		2267	`EXP ZI448;`
		2268	`EXP ZI416;`
		2269	`SID_LIST_EXP ZI423;`
		2270
		2271	`ZR788 (ZI547, &ZI448);`
		2272	`if ((CURRENT_TERMINAL) == 354) {`
		2273	`RESTORE_LEXER;`
		2274	`goto ZL1;`
		2275	`}`
		2276	`{`
		2277
		2278	`MAKE_exp_location ( type_void, crt_loc, (ZI448), (ZI416) ) ;`
		2279	`}`
		2280	`{`
		2281	`switch (CURRENT_TERMINAL) {`
		2282	`case 42:`
		2283	`{`
		2284	`ADVANCE_LEXER;`
		2285	`ZR1072 (&ZI547, &ZI423);`
		2286	`if ((CURRENT_TERMINAL) == 354) {`
		2287	`RESTORE_LEXER;`
		2288	`goto ZL1;`
		2289	`}`
		2290	`}`
		2291	`break;`
		2292	`default:`
		2293	`{`
		2294	`{`
		2295
		2296	`(ZI423) = NULL_list ( EXP ) ;`
		2297	`}`
		2298	`}`
		2299	`break;`
		2300	`}`
		2301	`}`
		2302	`{`
		2303
		2304	`CONS_exp ( (ZI416), (ZI423), (ZI420) ) ;`
		2305	`}`
		2306	`}`
		2307	`goto ZL0;`
		2308	`ZL1:;`
		2309	`SAVE_LEXER (354);`
		2310	`return;`
		2311	`ZL0:;`
		2312	`*ZO420 = ZI420;`
		2313	`}`
		2314
		2315	`void`
		2316	`parse_tok_type PROTO_N ((ZO395))`
		2317	`PROTO_T (TYPE *ZO395)`
		2318	`{`
		2319	`TYPE ZI395;`
		2320
		2321	`if ((CURRENT_TERMINAL) == 354) {`
		2322	`return;`
		2323	`}`
		2324	`{`
		2325	`BASE_TYPE ZI658;`
		2326	`TYPE ZI420;`
		2327	`CV_SPEC ZI630;`
		2328	`TYPE ZI423;`
		2329
		2330	`ZR687 (&ZI658, &ZI420, &ZI630);`
		2331	`if ((CURRENT_TERMINAL) == 354) {`
		2332	`RESTORE_LEXER;`
		2333	`goto ZL1;`
		2334	`}`
		2335	`{`
		2336
		2337	`(ZI423) = complete_pre_type ( (ZI658), (ZI420), (ZI630), 1 ) ;`
		2338	`have_type_specifier = 0 ;`
		2339	`}`
		2340	`ZR760 (ZI423, &ZI395);`
		2341	`if ((CURRENT_TERMINAL) == 354) {`
		2342	`RESTORE_LEXER;`
		2343	`goto ZL1;`
		2344	`}`
		2345	`}`
		2346	`goto ZL0;`
		2347	`ZL1:;`
		2348	`SAVE_LEXER (354);`
		2349	`return;`
		2350	`ZL0:;`
		2351	`*ZO395 = ZI395;`
		2352	`}`
		2353
		2354	`void`
		2355	`ZR910 PROTO_N ((ZI908, ZO909))`
		2356	`PROTO_T (EXP ZI908 X EXP *ZO909)`
		2357	`{`
		2358	`EXP ZI909;`
		2359
		2360	`ZL2_910:;`
		2361	`switch (CURRENT_TERMINAL) {`
		2362	`case 57:`
		2363	`{`
		2364	`EXP ZI448;`
		2365	`EXP ZI404;`
		2366
		2367	`ADVANCE_LEXER;`
		2368	`ZR479 (&ZI448);`
		2369	`if ((CURRENT_TERMINAL) == 354) {`
		2370	`RESTORE_LEXER;`
		2371	`goto ZL1;`
		2372	`}`
		2373	`{`
		2374
		2375	`(ZI404) = make_shift_exp ( lex_lshift, (ZI908), (ZI448) ) ;`
		2376	`}`
		2377	`ZI908 = ZI404;`
		2378	`goto ZL2_910;`
		2379	`}`
		2380	`/UNREACHED/`
		2381	`case 75:`
		2382	`{`
		2383	`EXP ZI448;`
		2384	`EXP ZI404;`
		2385
		2386	`ADVANCE_LEXER;`
		2387	`ZR479 (&ZI448);`
		2388	`if ((CURRENT_TERMINAL) == 354) {`
		2389	`RESTORE_LEXER;`
		2390	`goto ZL1;`
		2391	`}`
		2392	`{`
		2393
		2394	`(ZI404) = make_shift_exp ( lex_rshift, (ZI908), (ZI448) ) ;`
		2395	`}`
		2396	`ZI908 = ZI404;`
		2397	`goto ZL2_910;`
		2398	`}`
		2399	`/UNREACHED/`
		2400	`default:`
		2401	`{`
		2402	`ZI909 = ZI908;`
		2403	`}`
		2404	`break;`
		2405	`case 354:`
		2406	`return;`
		2407	`}`
		2408	`goto ZL0;`
		2409	`ZL1:;`
		2410	`SAVE_LEXER (354);`
		2411	`return;`
		2412	`ZL0:;`
		2413	`*ZO909 = ZI909;`
		2414	`}`
		2415
		2416	`void`
		2417	`ZR487 PROTO_Z ()`
		2418	`{`
		2419	`switch (CURRENT_TERMINAL) {`
		2420	`case 48:`
		2421	`{`
		2422	`ADVANCE_LEXER;`
		2423	`}`
		2424	`break;`
		2425	`case 63:`
		2426	`{`
		2427	`{`
		2428	`{`
		2429	`switch (CURRENT_TERMINAL) {`
		2430	`case 63:`
		2431	`break;`
		2432	`default:`
		2433	`goto ZL1;`
		2434	`}`
		2435	`ADVANCE_LEXER;`
		2436	`}`
		2437	`}`
		2438	`}`
		2439	`break;`
		2440	`case 354:`
		2441	`return;`
		2442	`default:`
		2443	`goto ZL1;`
		2444	`}`
		2445	`return;`
		2446	`ZL1:;`
		2447	`SAVE_LEXER (354);`
		2448	`return;`
		2449	`}`
		2450
		2451	`void`
		2452	`ZR491 PROTO_N ((ZO897))`
		2453	`PROTO_T (EXP *ZO897)`
		2454	`{`
		2455	`EXP ZI897;`
		2456
		2457	`if ((CURRENT_TERMINAL) == 354) {`
		2458	`return;`
		2459	`}`
		2460	`{`
		2461	`EXP ZI404;`
		2462
		2463	`ZR488 (&ZI404);`
		2464	`ZR898 (ZI404, &ZI897);`
		2465	`if ((CURRENT_TERMINAL) == 354) {`
		2466	`RESTORE_LEXER;`
		2467	`goto ZL1;`
		2468	`}`
		2469	`}`
		2470	`goto ZL0;`
		2471	`ZL1:;`
		2472	`SAVE_LEXER (354);`
		2473	`return;`
		2474	`ZL0:;`
		2475	`*ZO897 = ZI897;`
		2476	`}`
		2477
		2478	`void`
		2479	`ZR511 PROTO_N ((ZO404))`
		2480	`PROTO_T (EXP *ZO404)`
		2481	`{`
		2482	`EXP ZI404;`
		2483
		2484	`if ((CURRENT_TERMINAL) == 354) {`
		2485	`return;`
		2486	`}`
		2487	`{`
		2488	`switch (CURRENT_TERMINAL) {`
		2489	`case 345:`
		2490	`break;`
		2491	`default:`
		2492	`goto ZL1;`
		2493	`}`
		2494	`ADVANCE_LEXER;`
		2495	`ZR1029 (&ZI404);`
		2496	`if ((CURRENT_TERMINAL) == 354) {`
		2497	`RESTORE_LEXER;`
		2498	`goto ZL1;`
		2499	`}`
		2500	`}`
		2501	`goto ZL0;`
		2502	`ZL1:;`
		2503	`SAVE_LEXER (354);`
		2504	`return;`
		2505	`ZL0:;`
		2506	`*ZO404 = ZI404;`
		2507	`}`
		2508
		2509	`void`
		2510	`parse_type_param PROTO_N ((ZO547))`
		2511	`PROTO_T (IDENTIFIER *ZO547)`
		2512	`{`
		2513	`IDENTIFIER ZI547;`
		2514
		2515	`if ((CURRENT_TERMINAL) == 354) {`
		2516	`return;`
		2517	`}`
		2518	`{`
		2519	`{`
		2520
		2521	`/* Syntax errors */`
		2522	`ERROR err = ERR_lex_parse ( crt_token ) ;`
		2523	`report ( crt_loc, err ) ;`
		2524	`have_syntax_error = 1 ;`
		2525	`}`
		2526	`{`
		2527
		2528	`(ZI547) = NULL_id ;`
		2529	`}`
		2530	`}`
		2531	`*ZO547 = ZI547;`
		2532	`}`
		2533
		2534	`void`
		2535	`ZR914 PROTO_N ((ZI912, ZO913))`
		2536	`PROTO_T (EXP ZI912 X EXP *ZO913)`
		2537	`{`
		2538	`EXP ZI913;`
		2539
		2540	`ZL2_914:;`
		2541	`switch (CURRENT_TERMINAL) {`
		2542	`case 59:`
		2543	`{`
		2544	`EXP ZI448;`
		2545	`EXP ZI404;`
		2546
		2547	`ADVANCE_LEXER;`
		2548	`ZR476 (&ZI448);`
		2549	`if ((CURRENT_TERMINAL) == 354) {`
		2550	`RESTORE_LEXER;`
		2551	`goto ZL1;`
		2552	`}`
		2553	`{`
		2554
		2555	`(ZI404) = make_minus_exp ( (ZI912), (ZI448) ) ;`
		2556	`}`
		2557	`ZI912 = ZI404;`
		2558	`goto ZL2_914;`
		2559	`}`
		2560	`/UNREACHED/`
		2561	`case 69:`
		2562	`{`
		2563	`EXP ZI448;`
		2564	`EXP ZI404;`
		2565
		2566	`ADVANCE_LEXER;`
		2567	`ZR476 (&ZI448);`
		2568	`if ((CURRENT_TERMINAL) == 354) {`
		2569	`RESTORE_LEXER;`
		2570	`goto ZL1;`
		2571	`}`
		2572	`{`
		2573
		2574	`(ZI404) = make_plus_exp ( (ZI912), (ZI448) ) ;`
		2575	`}`
		2576	`ZI912 = ZI404;`
		2577	`goto ZL2_914;`
		2578	`}`
		2579	`/UNREACHED/`
		2580	`default:`
		2581	`{`
		2582	`ZI913 = ZI912;`
		2583	`}`
		2584	`break;`
		2585	`case 354:`
		2586	`return;`
		2587	`}`
		2588	`goto ZL0;`
		2589	`ZL1:;`
		2590	`SAVE_LEXER (354);`
		2591	`return;`
		2592	`ZL0:;`
		2593	`*ZO913 = ZI913;`
		2594	`}`
		2595
		2596	`void`
		2597	`ZR447 PROTO_N ((ZO921))`
		2598	`PROTO_T (EXP *ZO921)`
		2599	`{`
		2600	`EXP ZI921;`
		2601
		2602	`if ((CURRENT_TERMINAL) == 354) {`
		2603	`return;`
		2604	`}`
		2605	`{`
		2606	`EXP ZI404;`
		2607
		2608	`ZR415 (&ZI404);`
		2609	`ZR922 (ZI404, &ZI921);`
		2610	`if ((CURRENT_TERMINAL) == 354) {`
		2611	`RESTORE_LEXER;`
		2612	`goto ZL1;`
		2613	`}`
		2614	`}`
		2615	`goto ZL0;`
		2616	`ZL1:;`
		2617	`SAVE_LEXER (354);`
		2618	`return;`
		2619	`ZL0:;`
		2620	`*ZO921 = ZI921;`
		2621	`}`
		2622
		2623	`void`
		2624	`ZR554 PROTO_N ((ZO404))`
		2625	`PROTO_T (EXP *ZO404)`
		2626	`{`
		2627	`EXP ZI404;`
		2628
		2629	`switch (CURRENT_TERMINAL) {`
		2630	`case 170:`
		2631	`{`
		2632	`int ZI1006;`
		2633	`EXP ZI1007;`
		2634	`EXP ZI1025;`
		2635	`EXP ZI416;`
		2636	`int ZI537;`
		2637
		2638	`ADVANCE_LEXER;`
		2639	`{`
		2640	`(ZI1006) = lex_alignof ;`
		2641	`}`
		2642	`ZR461 (ZI1006, &ZI1007);`
		2643	`ZR1014 (&ZI1007, &ZI1025);`
		2644	`ZR1027 (&ZI1025, &ZI416);`
		2645	`if ((CURRENT_TERMINAL) == 354) {`
		2646	`RESTORE_LEXER;`
		2647	`goto ZL1;`
		2648	`}`
		2649	`{`
		2650
		2651	`(ZI537) = unreached_code ;`
		2652	`if ( (ZI537) ) {`
		2653	`if ( !unreached_last ) {`
		2654	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		2655	`unreached_last = 1 ;`
		2656	`}`
		2657	`} else {`
		2658	`unreached_last = 0 ;`
		2659	`}`
		2660	`}`
		2661	`{`
		2662
		2663	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		2664	`}`
		2665	`{`
		2666
		2667	`unreached_fall = 1 ;`
		2668	`}`
		2669	`switch (CURRENT_TERMINAL) {`
		2670	`case 77:`
		2671	`break;`
		2672	`default:`
		2673	`goto ZL1;`
		2674	`}`
		2675	`ADVANCE_LEXER;`
		2676	`}`
		2677	`break;`
		2678	`case 23:`
		2679	`{`
		2680	`EXP ZI1018;`
		2681	`EXP ZI1019;`
		2682	`EXP ZI1025;`
		2683	`EXP ZI416;`
		2684	`int ZI537;`
		2685
		2686	`{`
		2687
		2688	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		2689	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		2690	`ZI1018 = parse_exp_token ( id, args ) ;`
		2691	`RESCAN_LEXER ;`
		2692	`}`
		2693	`ADVANCE_LEXER;`
		2694	`ZR922 (ZI1018, &ZI1019);`
		2695	`ZR1014 (&ZI1019, &ZI1025);`
		2696	`ZR1027 (&ZI1025, &ZI416);`
		2697	`if ((CURRENT_TERMINAL) == 354) {`
		2698	`RESTORE_LEXER;`
		2699	`goto ZL1;`
		2700	`}`
		2701	`{`
		2702
		2703	`(ZI537) = unreached_code ;`
		2704	`if ( (ZI537) ) {`
		2705	`if ( !unreached_last ) {`
		2706	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		2707	`unreached_last = 1 ;`
		2708	`}`
		2709	`} else {`
		2710	`unreached_last = 0 ;`
		2711	`}`
		2712	`}`
		2713	`{`
		2714
		2715	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		2716	`}`
		2717	`{`
		2718
		2719	`unreached_fall = 1 ;`
		2720	`}`
		2721	`switch (CURRENT_TERMINAL) {`
		2722	`case 77:`
		2723	`break;`
		2724	`default:`
		2725	`goto ZL1;`
		2726	`}`
		2727	`ADVANCE_LEXER;`
		2728	`}`
		2729	`break;`
		2730	`case 24:`
		2731	`{`
		2732	`EXP ZI416;`
		2733
		2734	`{`
		2735
		2736	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		2737	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		2738	`ZI416 = parse_exp_token ( id, args ) ;`
		2739	`RESCAN_LEXER ;`
		2740	`}`
		2741	`ADVANCE_LEXER;`
		2742	`{`
		2743
		2744	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		2745	`}`
		2746	`}`
		2747	`break;`
		2748	`case 205:`
		2749	`{`
		2750	`EXP ZI1080;`
		2751	`EXP ZI961;`
		2752	`EXP ZI960;`
		2753	`EXP ZI959;`
		2754	`EXP ZI958;`
		2755	`EXP ZI957;`
		2756	`EXP ZI956;`
		2757	`EXP ZI955;`
		2758	`EXP ZI954;`
		2759	`EXP ZI953;`
		2760	`EXP ZI952;`
		2761	`EXP ZI951;`
		2762	`EXP ZI948;`
		2763	`EXP ZI1025;`
		2764	`EXP ZI416;`
		2765	`int ZI537;`
		2766
		2767	`ADVANCE_LEXER;`
		2768	`ZR459 (&ZI1080);`
		2769	`if ((CURRENT_TERMINAL) == 354) {`
		2770	`RESTORE_LEXER;`
		2771	`goto ZL1;`
		2772	`}`
		2773	`{`
		2774
		2775	`(ZI961) = make_cast_exp ( type_void, (ZI1080), 0 ) ;`
		2776	`}`
		2777	`ZR918 (ZI961, &ZI960);`
		2778	`ZR914 (ZI960, &ZI959);`
		2779	`ZR910 (ZI959, &ZI958);`
		2780	`ZR906 (ZI958, &ZI957);`
		2781	`ZR902 (ZI957, &ZI956);`
		2782	`ZR898 (ZI956, &ZI955);`
		2783	`ZR894 (ZI955, &ZI954);`
		2784	`ZR890 (ZI954, &ZI953);`
		2785	`ZR886 (ZI953, &ZI952);`
		2786	`ZR882 (ZI952, &ZI951);`
		2787	`ZR878 (ZI951, &ZI948);`
		2788	`ZR950 (&ZI948, &ZI1025);`
		2789	`ZR1027 (&ZI1025, &ZI416);`
		2790	`if ((CURRENT_TERMINAL) == 354) {`
		2791	`RESTORE_LEXER;`
		2792	`goto ZL1;`
		2793	`}`
		2794	`{`
		2795
		2796	`(ZI537) = unreached_code ;`
		2797	`if ( (ZI537) ) {`
		2798	`if ( !unreached_last ) {`
		2799	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		2800	`unreached_last = 1 ;`
		2801	`}`
		2802	`} else {`
		2803	`unreached_last = 0 ;`
		2804	`}`
		2805	`}`
		2806	`{`
		2807
		2808	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		2809	`}`
		2810	`{`
		2811
		2812	`unreached_fall = 1 ;`
		2813	`}`
		2814	`switch (CURRENT_TERMINAL) {`
		2815	`case 77:`
		2816	`break;`
		2817	`default:`
		2818	`goto ZL1;`
		2819	`}`
		2820	`ADVANCE_LEXER;`
		2821	`}`
		2822	`break;`
		2823	`case 209:`
		2824	`{`
		2825	`EXP ZI1015;`
		2826	`EXP ZI1016;`
		2827	`EXP ZI1025;`
		2828	`EXP ZI416;`
		2829	`int ZI537;`
		2830
		2831	`ADVANCE_LEXER;`
		2832	`{`
		2833
		2834	`(ZI1015) = make_ellipsis_exp () ;`
		2835	`}`
		2836	`ZR922 (ZI1015, &ZI1016);`
		2837	`ZR1014 (&ZI1016, &ZI1025);`
		2838	`ZR1027 (&ZI1025, &ZI416);`
		2839	`if ((CURRENT_TERMINAL) == 354) {`
		2840	`RESTORE_LEXER;`
		2841	`goto ZL1;`
		2842	`}`
		2843	`{`
		2844
		2845	`(ZI537) = unreached_code ;`
		2846	`if ( (ZI537) ) {`
		2847	`if ( !unreached_last ) {`
		2848	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		2849	`unreached_last = 1 ;`
		2850	`}`
		2851	`} else {`
		2852	`unreached_last = 0 ;`
		2853	`}`
		2854	`}`
		2855	`{`
		2856
		2857	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		2858	`}`
		2859	`{`
		2860
		2861	`unreached_fall = 1 ;`
		2862	`}`
		2863	`switch (CURRENT_TERMINAL) {`
		2864	`case 77:`
		2865	`break;`
		2866	`default:`
		2867	`goto ZL1;`
		2868	`}`
		2869	`ADVANCE_LEXER;`
		2870	`}`
		2871	`break;`
		2872	`case 1:`
		2873	`{`
		2874	`IDENTIFIER ZI399;`
		2875
		2876	`{`
		2877
		2878	`ZI399 = crt_token->pp_data.id.use ;`
		2879	`}`
		2880	`ADVANCE_LEXER;`
		2881	`ZR1081 (&ZI399, &ZI404);`
		2882	`if ((CURRENT_TERMINAL) == 354) {`
		2883	`RESTORE_LEXER;`
		2884	`goto ZL1;`
		2885	`}`
		2886	`}`
		2887	`break;`
		2888	`case 345:`
		2889	`{`
		2890	`ADVANCE_LEXER;`
		2891	`ZR1078 (&ZI404);`
		2892	`if ((CURRENT_TERMINAL) == 354) {`
		2893	`RESTORE_LEXER;`
		2894	`goto ZL1;`
		2895	`}`
		2896	`}`
		2897	`break;`
		2898	`case 61:`
		2899	`{`
		2900	`EXP ZI987;`
		2901	`EXP ZI988;`
		2902	`EXP ZI1025;`
		2903	`EXP ZI416;`
		2904	`int ZI537;`
		2905
		2906	`ADVANCE_LEXER;`
		2907	`ZR458 (&ZI987);`
		2908	`if ((CURRENT_TERMINAL) == 354) {`
		2909	`RESTORE_LEXER;`
		2910	`goto ZL1;`
		2911	`}`
		2912	`{`
		2913
		2914	`(ZI988) = make_prefix_exp ( lex_minus_Hminus, (ZI987) ) ;`
		2915	`}`
		2916	`ZR1014 (&ZI988, &ZI1025);`
		2917	`ZR1027 (&ZI1025, &ZI416);`
		2918	`if ((CURRENT_TERMINAL) == 354) {`
		2919	`RESTORE_LEXER;`
		2920	`goto ZL1;`
		2921	`}`
		2922	`{`
		2923
		2924	`(ZI537) = unreached_code ;`
		2925	`if ( (ZI537) ) {`
		2926	`if ( !unreached_last ) {`
		2927	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		2928	`unreached_last = 1 ;`
		2929	`}`
		2930	`} else {`
		2931	`unreached_last = 0 ;`
		2932	`}`
		2933	`}`
		2934	`{`
		2935
		2936	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		2937	`}`
		2938	`{`
		2939
		2940	`unreached_fall = 1 ;`
		2941	`}`
		2942	`switch (CURRENT_TERMINAL) {`
		2943	`case 77:`
		2944	`break;`
		2945	`default:`
		2946	`goto ZL1;`
		2947	`}`
		2948	`ADVANCE_LEXER;`
		2949	`}`
		2950	`break;`
		2951	`case 65:`
		2952	`{`
		2953	`EXP ZI1025;`
		2954	`EXP ZI416;`
		2955	`int ZI537;`
		2956
		2957	`ADVANCE_LEXER;`
		2958	`ZR983 (&ZI1025);`
		2959	`ZR1027 (&ZI1025, &ZI416);`
		2960	`if ((CURRENT_TERMINAL) == 354) {`
		2961	`RESTORE_LEXER;`
		2962	`goto ZL1;`
		2963	`}`
		2964	`{`
		2965
		2966	`(ZI537) = unreached_code ;`
		2967	`if ( (ZI537) ) {`
		2968	`if ( !unreached_last ) {`
		2969	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		2970	`unreached_last = 1 ;`
		2971	`}`
		2972	`} else {`
		2973	`unreached_last = 0 ;`
		2974	`}`
		2975	`}`
		2976	`{`
		2977
		2978	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		2979	`}`
		2980	`{`
		2981
		2982	`unreached_fall = 1 ;`
		2983	`}`
		2984	`switch (CURRENT_TERMINAL) {`
		2985	`case 77:`
		2986	`break;`
		2987	`default:`
		2988	`goto ZL1;`
		2989	`}`
		2990	`ADVANCE_LEXER;`
		2991	`}`
		2992	`break;`
		2993	`case 71:`
		2994	`{`
		2995	`EXP ZI984;`
		2996	`EXP ZI985;`
		2997	`EXP ZI1025;`
		2998	`EXP ZI416;`
		2999	`int ZI537;`
		3000
		3001	`ADVANCE_LEXER;`
		3002	`ZR458 (&ZI984);`
		3003	`if ((CURRENT_TERMINAL) == 354) {`
		3004	`RESTORE_LEXER;`
		3005	`goto ZL1;`
		3006	`}`
		3007	`{`
		3008
		3009	`(ZI985) = make_prefix_exp ( lex_plus_Hplus, (ZI984) ) ;`
		3010	`}`
		3011	`ZR1014 (&ZI985, &ZI1025);`
		3012	`ZR1027 (&ZI1025, &ZI416);`
		3013	`if ((CURRENT_TERMINAL) == 354) {`
		3014	`RESTORE_LEXER;`
		3015	`goto ZL1;`
		3016	`}`
		3017	`{`
		3018
		3019	`(ZI537) = unreached_code ;`
		3020	`if ( (ZI537) ) {`
		3021	`if ( !unreached_last ) {`
		3022	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		3023	`unreached_last = 1 ;`
		3024	`}`
		3025	`} else {`
		3026	`unreached_last = 0 ;`
		3027	`}`
		3028	`}`
		3029	`{`
		3030
		3031	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		3032	`}`
		3033	`{`
		3034
		3035	`unreached_fall = 1 ;`
		3036	`}`
		3037	`switch (CURRENT_TERMINAL) {`
		3038	`case 77:`
		3039	`break;`
		3040	`default:`
		3041	`goto ZL1;`
		3042	`}`
		3043	`ADVANCE_LEXER;`
		3044	`}`
		3045	`break;`
		3046	`case 77:`
		3047	`{`
		3048	`ADVANCE_LEXER;`
		3049	`{`
		3050
		3051	`(ZI404) = NULL_exp ;`
		3052	`}`
		3053	`}`
		3054	`break;`
		3055	`case 116:`
		3056	`{`
		3057	`int ZI1003;`
		3058	`EXP ZI1004;`
		3059	`EXP ZI1025;`
		3060	`EXP ZI416;`
		3061	`int ZI537;`
		3062
		3063	`ADVANCE_LEXER;`
		3064	`{`
		3065	`(ZI1003) = lex_sizeof ;`
		3066	`}`
		3067	`ZR461 (ZI1003, &ZI1004);`
		3068	`ZR1014 (&ZI1004, &ZI1025);`
		3069	`ZR1027 (&ZI1025, &ZI416);`
		3070	`if ((CURRENT_TERMINAL) == 354) {`
		3071	`RESTORE_LEXER;`
		3072	`goto ZL1;`
		3073	`}`
		3074	`{`
		3075
		3076	`(ZI537) = unreached_code ;`
		3077	`if ( (ZI537) ) {`
		3078	`if ( !unreached_last ) {`
		3079	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		3080	`unreached_last = 1 ;`
		3081	`}`
		3082	`} else {`
		3083	`unreached_last = 0 ;`
		3084	`}`
		3085	`}`
		3086	`{`
		3087
		3088	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		3089	`}`
		3090	`{`
		3091
		3092	`unreached_fall = 1 ;`
		3093	`}`
		3094	`switch (CURRENT_TERMINAL) {`
		3095	`case 77:`
		3096	`break;`
		3097	`default:`
		3098	`goto ZL1;`
		3099	`}`
		3100	`ADVANCE_LEXER;`
		3101	`}`
		3102	`break;`
		3103	`case 78:`
		3104	`{`
		3105	`EXP ZI990;`
		3106	`EXP ZI991;`
		3107	`EXP ZI1025;`
		3108	`EXP ZI416;`
		3109	`int ZI537;`
		3110
		3111	`ADVANCE_LEXER;`
		3112	`ZR459 (&ZI990);`
		3113	`if ((CURRENT_TERMINAL) == 354) {`
		3114	`RESTORE_LEXER;`
		3115	`goto ZL1;`
		3116	`}`
		3117	`{`
		3118
		3119	`(ZI991) = make_indir_exp ( (ZI990) ) ;`
		3120	`}`
		3121	`ZR1014 (&ZI991, &ZI1025);`
		3122	`ZR1027 (&ZI1025, &ZI416);`
		3123	`if ((CURRENT_TERMINAL) == 354) {`
		3124	`RESTORE_LEXER;`
		3125	`goto ZL1;`
		3126	`}`
		3127	`{`
		3128
		3129	`(ZI537) = unreached_code ;`
		3130	`if ( (ZI537) ) {`
		3131	`if ( !unreached_last ) {`
		3132	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		3133	`unreached_last = 1 ;`
		3134	`}`
		3135	`} else {`
		3136	`unreached_last = 0 ;`
		3137	`}`
		3138	`}`
		3139	`{`
		3140
		3141	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		3142	`}`
		3143	`{`
		3144
		3145	`unreached_fall = 1 ;`
		3146	`}`
		3147	`switch (CURRENT_TERMINAL) {`
		3148	`case 77:`
		3149	`break;`
		3150	`default:`
		3151	`goto ZL1;`
		3152	`}`
		3153	`ADVANCE_LEXER;`
		3154	`}`
		3155	`break;`
		3156	`case 4:`
		3157	`{`
		3158	`IDENTIFIER ZI399;`
		3159
		3160	`{`
		3161
		3162	`ZI399 = crt_token->pp_data.id.use ;`
		3163	`}`
		3164	`ADVANCE_LEXER;`
		3165	`ZR1082 (&ZI399, &ZI404);`
		3166	`if ((CURRENT_TERMINAL) == 354) {`
		3167	`RESTORE_LEXER;`
		3168	`goto ZL1;`
		3169	`}`
		3170	`}`
		3171	`break;`
		3172	`case 2:`
		3173	`{`
		3174	`IDENTIFIER ZI399;`
		3175	`EXP ZI416;`
		3176	`EXP ZI448;`
		3177
		3178	`{`
		3179
		3180	`ZI399 = crt_token->pp_data.id.use ;`
		3181	`}`
		3182	`ADVANCE_LEXER;`
		3183	`{`
		3184
		3185	`if ( unreached_code ) unreached_fall = 0 ;`
		3186	`}`
		3187	`{`
		3188
		3189	`(ZI416) = begin_label_stmt ( (ZI399), lex_identifier ) ;`
		3190	`}`
		3191	`switch (CURRENT_TERMINAL) {`
		3192	`case 41:`
		3193	`break;`
		3194	`default:`
		3195	`goto ZL1;`
		3196	`}`
		3197	`ADVANCE_LEXER;`
		3198	`ZR528 (&ZI448);`
		3199	`if ((CURRENT_TERMINAL) == 354) {`
		3200	`RESTORE_LEXER;`
		3201	`goto ZL1;`
		3202	`}`
		3203	`{`
		3204
		3205	`(ZI404) = end_label_stmt ( (ZI416), (ZI448) ) ;`
		3206	`}`
		3207	`}`
		3208	`break;`
		3209	`case 33:`
		3210	`{`
		3211	`EXP ZI993;`
		3212	`EXP ZI994;`
		3213	`EXP ZI1025;`
		3214	`EXP ZI416;`
		3215	`int ZI537;`
		3216
		3217	`{`
		3218	`{`
		3219	`switch (CURRENT_TERMINAL) {`
		3220	`case 33:`
		3221	`break;`
		3222	`default:`
		3223	`goto ZL1;`
		3224	`}`
		3225	`ADVANCE_LEXER;`
		3226	`}`
		3227	`}`
		3228	`ZR459 (&ZI993);`
		3229	`if ((CURRENT_TERMINAL) == 354) {`
		3230	`RESTORE_LEXER;`
		3231	`goto ZL1;`
		3232	`}`
		3233	`{`
		3234
		3235	`(ZI994) = make_ref_exp ( (ZI993), 0 ) ;`
		3236	`}`
		3237	`ZR1014 (&ZI994, &ZI1025);`
		3238	`ZR1027 (&ZI1025, &ZI416);`
		3239	`if ((CURRENT_TERMINAL) == 354) {`
		3240	`RESTORE_LEXER;`
		3241	`goto ZL1;`
		3242	`}`
		3243	`{`
		3244
		3245	`(ZI537) = unreached_code ;`
		3246	`if ( (ZI537) ) {`
		3247	`if ( !unreached_last ) {`
		3248	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		3249	`unreached_last = 1 ;`
		3250	`}`
		3251	`} else {`
		3252	`unreached_last = 0 ;`
		3253	`}`
		3254	`}`
		3255	`{`
		3256
		3257	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		3258	`}`
		3259	`{`
		3260
		3261	`unreached_fall = 1 ;`
		3262	`}`
		3263	`switch (CURRENT_TERMINAL) {`
		3264	`case 77:`
		3265	`break;`
		3266	`default:`
		3267	`goto ZL1;`
		3268	`}`
		3269	`ADVANCE_LEXER;`
		3270	`}`
		3271	`break;`
		3272	`case 126:`
		3273	`{`
		3274	`ZR623 (&ZI404);`
		3275	`if ((CURRENT_TERMINAL) == 354) {`
		3276	`RESTORE_LEXER;`
		3277	`goto ZL1;`
		3278	`}`
		3279	`}`
		3280	`break;`
		3281	`case 288: case 322:`
		3282	`{`
		3283	`ZR620 (&ZI404);`
		3284	`if ((CURRENT_TERMINAL) == 354) {`
		3285	`RESTORE_LEXER;`
		3286	`goto ZL1;`
		3287	`}`
		3288	`}`
		3289	`break;`
		3290	`case 96: case 100: case 222:`
		3291	`{`
		3292	`ZR529 ();`
		3293	`ZR1079 (&ZI404);`
		3294	`if ((CURRENT_TERMINAL) == 354) {`
		3295	`RESTORE_LEXER;`
		3296	`goto ZL1;`
		3297	`}`
		3298	`}`
		3299	`break;`
		3300	`case 297: case 323:`
		3301	`{`
		3302	`EXP ZI1073;`
		3303	`EXP ZI416;`
		3304	`int ZI537;`
		3305
		3306	`ZR510 (&ZI1073);`
		3307	`ZR1075 (&ZI1073, &ZI416);`
		3308	`if ((CURRENT_TERMINAL) == 354) {`
		3309	`RESTORE_LEXER;`
		3310	`goto ZL1;`
		3311	`}`
		3312	`{`
		3313
		3314	`(ZI537) = unreached_code ;`
		3315	`if ( (ZI537) ) {`
		3316	`if ( !unreached_last ) {`
		3317	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		3318	`unreached_last = 1 ;`
		3319	`}`
		3320	`} else {`
		3321	`unreached_last = 0 ;`
		3322	`}`
		3323	`}`
		3324	`{`
		3325
		3326	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		3327	`}`
		3328	`{`
		3329
		3330	`unreached_fall = 1 ;`
		3331	`}`
		3332	`switch (CURRENT_TERMINAL) {`
		3333	`case 77:`
		3334	`break;`
		3335	`default:`
		3336	`goto ZL1;`
		3337	`}`
		3338	`ADVANCE_LEXER;`
		3339	`}`
		3340	`break;`
		3341	`case 101: case 107: case 125:`
		3342	`{`
		3343	`ZR602 (&ZI404);`
		3344	`if ((CURRENT_TERMINAL) == 354) {`
		3345	`RESTORE_LEXER;`
		3346	`goto ZL1;`
		3347	`}`
		3348	`}`
		3349	`break;`
		3350	`case 95: case 99: case 108: case 113:`
		3351	`{`
		3352	`ZR614 (&ZI404);`
		3353	`if ((CURRENT_TERMINAL) == 354) {`
		3354	`RESTORE_LEXER;`
		3355	`goto ZL1;`
		3356	`}`
		3357	`}`
		3358	`break;`
		3359	`case 17: case 18: case 19: case 20: case 21:`
		3360	`case 22:`
		3361	`{`
		3362	`EXP ZI1009;`
		3363	`EXP ZI1010;`
		3364	`EXP ZI1025;`
		3365	`EXP ZI416;`
		3366	`int ZI537;`
		3367
		3368	`ZR409 (&ZI1009);`
		3369	`ZR922 (ZI1009, &ZI1010);`
		3370	`ZR1014 (&ZI1010, &ZI1025);`
		3371	`ZR1027 (&ZI1025, &ZI416);`
		3372	`if ((CURRENT_TERMINAL) == 354) {`
		3373	`RESTORE_LEXER;`
		3374	`goto ZL1;`
		3375	`}`
		3376	`{`
		3377
		3378	`(ZI537) = unreached_code ;`
		3379	`if ( (ZI537) ) {`
		3380	`if ( !unreached_last ) {`
		3381	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		3382	`unreached_last = 1 ;`
		3383	`}`
		3384	`} else {`
		3385	`unreached_last = 0 ;`
		3386	`}`
		3387	`}`
		3388	`{`
		3389
		3390	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		3391	`}`
		3392	`{`
		3393
		3394	`unreached_fall = 1 ;`
		3395	`}`
		3396	`switch (CURRENT_TERMINAL) {`
		3397	`case 77:`
		3398	`break;`
		3399	`default:`
		3400	`goto ZL1;`
		3401	`}`
		3402	`ADVANCE_LEXER;`
		3403	`}`
		3404	`break;`
		3405	`case 62:`
		3406	`{`
		3407	`EXP ZI996;`
		3408	`EXP ZI997;`
		3409	`EXP ZI1025;`
		3410	`EXP ZI416;`
		3411	`int ZI537;`
		3412
		3413	`{`
		3414	`{`
		3415	`switch (CURRENT_TERMINAL) {`
		3416	`case 62:`
		3417	`break;`
		3418	`default:`
		3419	`goto ZL1;`
		3420	`}`
		3421	`ADVANCE_LEXER;`
		3422	`}`
		3423	`}`
		3424	`ZR459 (&ZI996);`
		3425	`if ((CURRENT_TERMINAL) == 354) {`
		3426	`RESTORE_LEXER;`
		3427	`goto ZL1;`
		3428	`}`
		3429	`{`
		3430
		3431	`(ZI997) = make_not_exp ( (ZI996) ) ;`
		3432	`}`
		3433	`ZR1014 (&ZI997, &ZI1025);`
		3434	`ZR1027 (&ZI1025, &ZI416);`
		3435	`if ((CURRENT_TERMINAL) == 354) {`
		3436	`RESTORE_LEXER;`
		3437	`goto ZL1;`
		3438	`}`
		3439	`{`
		3440
		3441	`(ZI537) = unreached_code ;`
		3442	`if ( (ZI537) ) {`
		3443	`if ( !unreached_last ) {`
		3444	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		3445	`unreached_last = 1 ;`
		3446	`}`
		3447	`} else {`
		3448	`unreached_last = 0 ;`
		3449	`}`
		3450	`}`
		3451	`{`
		3452
		3453	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		3454	`}`
		3455	`{`
		3456
		3457	`unreached_fall = 1 ;`
		3458	`}`
		3459	`switch (CURRENT_TERMINAL) {`
		3460	`case 77:`
		3461	`break;`
		3462	`default:`
		3463	`goto ZL1;`
		3464	`}`
		3465	`ADVANCE_LEXER;`
		3466	`}`
		3467	`break;`
		3468	`case 26: case 109: case 119:`
		3469	`{`
		3470	`ZR580 (&ZI404);`
		3471	`if ((CURRENT_TERMINAL) == 354) {`
		3472	`RESTORE_LEXER;`
		3473	`goto ZL1;`
		3474	`}`
		3475	`}`
		3476	`break;`
		3477	`case 43: case 59: case 69: case 85:`
		3478	`{`
		3479	`int ZI999;`
		3480	`EXP ZI1000;`
		3481	`EXP ZI1001;`
		3482	`EXP ZI1025;`
		3483	`EXP ZI416;`
		3484	`int ZI537;`
		3485
		3486	`{`
		3487	`(ZI999) = crt_lex_token ;`
		3488	`}`
		3489	`ZR469 ();`
		3490	`ZR459 (&ZI1000);`
		3491	`if ((CURRENT_TERMINAL) == 354) {`
		3492	`RESTORE_LEXER;`
		3493	`goto ZL1;`
		3494	`}`
		3495	`{`
		3496
		3497	`(ZI1001) = make_uminus_exp ( (ZI999), (ZI1000) ) ;`
		3498	`}`
		3499	`ZR1014 (&ZI1001, &ZI1025);`
		3500	`ZR1027 (&ZI1025, &ZI416);`
		3501	`if ((CURRENT_TERMINAL) == 354) {`
		3502	`RESTORE_LEXER;`
		3503	`goto ZL1;`
		3504	`}`
		3505	`{`
		3506
		3507	`(ZI537) = unreached_code ;`
		3508	`if ( (ZI537) ) {`
		3509	`if ( !unreached_last ) {`
		3510	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		3511	`unreached_last = 1 ;`
		3512	`}`
		3513	`} else {`
		3514	`unreached_last = 0 ;`
		3515	`}`
		3516	`}`
		3517	`{`
		3518
		3519	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		3520	`}`
		3521	`{`
		3522
		3523	`unreached_fall = 1 ;`
		3524	`}`
		3525	`switch (CURRENT_TERMINAL) {`
		3526	`case 77:`
		3527	`break;`
		3528	`default:`
		3529	`goto ZL1;`
		3530	`}`
		3531	`ADVANCE_LEXER;`
		3532	`}`
		3533	`break;`
		3534	`case 354:`
		3535	`return;`
		3536	`default:`
		3537	`goto ZL1;`
		3538	`}`
		3539	`goto ZL0;`
		3540	`ZL1:;`
		3541	`SAVE_LEXER (354);`
		3542	`return;`
		3543	`ZL0:;`
		3544	`*ZO404 = ZI404;`
		3545	`}`
		3546
		3547	`void`
		3548	`ZR662 PROTO_Z ()`
		3549	`{`
		3550	`if ((CURRENT_TERMINAL) == 354) {`
		3551	`return;`
		3552	`}`
		3553	`ZL2_662:;`
		3554	`{`
		3555	`BASE_TYPE ZI688;`
		3556	`TYPE ZI689;`
		3557	`CV_SPEC ZI690;`
		3558	`BASE_TYPE ZI658;`
		3559	`TYPE ZI420;`
		3560	`CV_SPEC ZI630;`
		3561
		3562	`{`
		3563
		3564	`/* Resolve type-specifiers from other declarators */`
		3565	`(ZI0) = predict_tspec ( 0 ) ;`
		3566	`}`
		3567	`if (!ZI0)`
		3568	`goto ZL3;`
		3569	`ZR686 (&ZI688, &ZI689, &ZI690);`
		3570	`if ((CURRENT_TERMINAL) == 354) {`
		3571	`RESTORE_LEXER;`
		3572	`goto ZL1;`
		3573	`}`
		3574	`{`
		3575
		3576	`/* A type-name can be a declarator-id */`
		3577	`if ( have_type_specifier && crt_lex_token == lex_type_Hname ) {`
		3578	`crt_lex_token = lex_identifier ;`
		3579	`}`
		3580	`}`
		3581	`ZR699 (&ZI688, &ZI689, &ZI690, &ZI658, &ZI420, &ZI630);`
		3582	`ZR1031 (&ZI658, &ZI420, &ZI630);`
		3583	`if ((CURRENT_TERMINAL) == 354) {`
		3584	`RESTORE_LEXER;`
		3585	`goto ZL1;`
		3586	`} else {`
		3587	`goto ZL2_662;`
		3588	`}`
		3589	`}`
		3590	`/UNREACHED/`
		3591	`ZL3:;`
		3592	`return;`
		3593	`ZL1:;`
		3594	`SAVE_LEXER (354);`
		3595	`return;`
		3596	`}`
		3597
		3598	`void`
		3599	`ZR1043 PROTO_N ((ZI420, ZI423, ZI1042))`
		3600	`PROTO_T (TYPE ZI420 X BASE_TYPE ZI423 X IDENTIFIER *ZI1042)`
		3601	`{`
		3602	`switch (CURRENT_TERMINAL) {`
		3603	`case 41:`
		3604	`{`
		3605	`EXP ZI467;`
		3606	`TYPE ZI395;`
		3607
		3608	`{`
		3609
		3610	`IDENTIFIER pid = underlying_id ( (*ZI1042) ) ;`
		3611	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		3612	`}`
		3613	`ADVANCE_LEXER;`
		3614	`ZR518 (&ZI467);`
		3615	`if ((CURRENT_TERMINAL) == 354) {`
		3616	`RESTORE_LEXER;`
		3617	`goto ZL1;`
		3618	`}`
		3619	`{`
		3620
		3621	`/* Check for anonymous bitfields */`
		3622	`HASHID nm = DEREF_hashid ( id_name ( (*ZI1042) ) ) ;`
		3623	`int z = IS_hashid_anon ( nm ) ;`
		3624	`(ZI395) = make_bitfield_type ( (ZI420), (ZI423), (ZI467), z ) ;`
		3625	`}`
		3626	`{`
		3627
		3628	`IDENTIFIER id = make_member_decl ( dspec_none, (ZI395), (*ZI1042), 0 ) ;`
		3629	`if ( do_dump ) dump_declare ( id, &decl_loc, 0 ) ;`
		3630	`have_type_declaration = TYPE_DECL_NONE ;`
		3631	`have_func_declarator = 0 ;`
		3632	`}`
		3633	`}`
		3634	`break;`
		3635	`default:`
		3636	`{`
		3637	`TYPE ZI1041;`
		3638	`TYPE ZI1035;`
		3639	`IDENTIFIER ZI399;`
		3640	`TYPE ZI395;`
		3641
		3642	`{`
		3643
		3644	`(ZI1041) = NULL_type ;`
		3645	`}`
		3646	`{`
		3647
		3648	`IDENTIFIER pid = underlying_id ( (*ZI1042) ) ;`
		3649	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		3650	`}`
		3651	`ZR868 (ZI1041, *ZI1042, &ZI1035, &ZI399);`
		3652	`if ((CURRENT_TERMINAL) == 354) {`
		3653	`RESTORE_LEXER;`
		3654	`goto ZL1;`
		3655	`}`
		3656	`{`
		3657
		3658	`(ZI395) = ( IS_NULL_type ( (ZI1035) ) ? (ZI420) : inject_pre_type ( (ZI1035), (ZI420), 1 ) ) ;`
		3659	`}`
		3660	`{`
		3661
		3662	`IDENTIFIER id = make_member_decl ( dspec_none, (ZI395), (ZI399), 0 ) ;`
		3663	`if ( do_dump ) dump_declare ( id, &decl_loc, 0 ) ;`
		3664	`have_type_declaration = TYPE_DECL_NONE ;`
		3665	`have_func_declarator = 0 ;`
		3666	`}`
		3667	`}`
		3668	`break;`
		3669	`case 354:`
		3670	`return;`
		3671	`}`
		3672	`return;`
		3673	`ZL1:;`
		3674	`SAVE_LEXER (354);`
		3675	`return;`
		3676	`}`
		3677
		3678	`void`
		3679	`ZR461 PROTO_N ((ZI460, ZO404))`
		3680	`PROTO_T (int ZI460 X EXP *ZO404)`
		3681	`{`
		3682	`EXP ZI404;`
		3683
		3684	`if ((CURRENT_TERMINAL) == 354) {`
		3685	`return;`
		3686	`}`
		3687	`{`
		3688	`int ZI462;`
		3689	`int ZI463;`
		3690	`EXP ZI467;`
		3691
		3692	`{`
		3693
		3694	`suppress_usage++ ;`
		3695	`}`
		3696	`{`
		3697
		3698	`(ZI462) = no_side_effects ;`
		3699	`}`
		3700	`{`
		3701
		3702	`(ZI463) = no_type_defns ;`
		3703	`}`
		3704	`{`
		3705	`switch (CURRENT_TERMINAL) {`
		3706	`case 170:`
		3707	`{`
		3708	`int ZI1069;`
		3709	`EXP ZI416;`
		3710	`int ZI465;`
		3711	`int ZI466;`
		3712	`TYPE ZI395;`
		3713
		3714	`ADVANCE_LEXER;`
		3715	`{`
		3716	`(ZI1069) = lex_alignof ;`
		3717	`}`
		3718	`ZR461 (ZI1069, &ZI416);`
		3719	`if ((CURRENT_TERMINAL) == 354) {`
		3720	`RESTORE_LEXER;`
		3721	`goto ZL1;`
		3722	`}`
		3723	`{`
		3724
		3725	`(ZI465) = no_side_effects - (ZI462) ;`
		3726	`}`
		3727	`{`
		3728
		3729	`(ZI466) = no_type_defns - (ZI463) ;`
		3730	`}`
		3731	`{`
		3732
		3733	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		3734	`}`
		3735	`{`
		3736
		3737	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		3738	`}`
		3739	`}`
		3740	`break;`
		3741	`case 23:`
		3742	`{`
		3743	`EXP ZI1100;`
		3744	`EXP ZI416;`
		3745	`int ZI465;`
		3746	`int ZI466;`
		3747	`TYPE ZI395;`
		3748
		3749	`{`
		3750
		3751	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		3752	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		3753	`ZI1100 = parse_exp_token ( id, args ) ;`
		3754	`RESCAN_LEXER ;`
		3755	`}`
		3756	`ADVANCE_LEXER;`
		3757	`ZR922 (ZI1100, &ZI416);`
		3758	`if ((CURRENT_TERMINAL) == 354) {`
		3759	`RESTORE_LEXER;`
		3760	`goto ZL1;`
		3761	`}`
		3762	`{`
		3763
		3764	`(ZI465) = no_side_effects - (ZI462) ;`
		3765	`}`
		3766	`{`
		3767
		3768	`(ZI466) = no_type_defns - (ZI463) ;`
		3769	`}`
		3770	`{`
		3771
		3772	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		3773	`}`
		3774	`{`
		3775
		3776	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		3777	`}`
		3778	`}`
		3779	`break;`
		3780	`case 209:`
		3781	`{`
		3782	`EXP ZI1101;`
		3783	`EXP ZI416;`
		3784	`int ZI465;`
		3785	`int ZI466;`
		3786	`TYPE ZI395;`
		3787
		3788	`ADVANCE_LEXER;`
		3789	`{`
		3790
		3791	`(ZI1101) = make_ellipsis_exp () ;`
		3792	`}`
		3793	`ZR922 (ZI1101, &ZI416);`
		3794	`if ((CURRENT_TERMINAL) == 354) {`
		3795	`RESTORE_LEXER;`
		3796	`goto ZL1;`
		3797	`}`
		3798	`{`
		3799
		3800	`(ZI465) = no_side_effects - (ZI462) ;`
		3801	`}`
		3802	`{`
		3803
		3804	`(ZI466) = no_type_defns - (ZI463) ;`
		3805	`}`
		3806	`{`
		3807
		3808	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		3809	`}`
		3810	`{`
		3811
		3812	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		3813	`}`
		3814	`}`
		3815	`break;`
		3816	`case 1:`
		3817	`{`
		3818	`IDENTIFIER ZI399;`
		3819	`EXP ZI1102;`
		3820	`EXP ZI416;`
		3821	`int ZI465;`
		3822	`int ZI466;`
		3823	`TYPE ZI395;`
		3824
		3825	`{`
		3826
		3827	`ZI399 = crt_token->pp_data.id.use ;`
		3828	`}`
		3829	`ADVANCE_LEXER;`
		3830	`{`
		3831
		3832	`(ZI1102) = make_id_exp ( (ZI399) ) ;`
		3833	`}`
		3834	`ZR922 (ZI1102, &ZI416);`
		3835	`if ((CURRENT_TERMINAL) == 354) {`
		3836	`RESTORE_LEXER;`
		3837	`goto ZL1;`
		3838	`}`
		3839	`{`
		3840
		3841	`(ZI465) = no_side_effects - (ZI462) ;`
		3842	`}`
		3843	`{`
		3844
		3845	`(ZI466) = no_type_defns - (ZI463) ;`
		3846	`}`
		3847	`{`
		3848
		3849	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		3850	`}`
		3851	`{`
		3852
		3853	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		3854	`}`
		3855	`}`
		3856	`break;`
		3857	`case 61:`
		3858	`{`
		3859	`EXP ZI1062;`
		3860	`EXP ZI416;`
		3861	`int ZI465;`
		3862	`int ZI466;`
		3863	`TYPE ZI395;`
		3864
		3865	`ADVANCE_LEXER;`
		3866	`ZR458 (&ZI1062);`
		3867	`if ((CURRENT_TERMINAL) == 354) {`
		3868	`RESTORE_LEXER;`
		3869	`goto ZL1;`
		3870	`}`
		3871	`{`
		3872
		3873	`(ZI416) = make_prefix_exp ( lex_minus_Hminus, (ZI1062) ) ;`
		3874	`}`
		3875	`{`
		3876
		3877	`(ZI465) = no_side_effects - (ZI462) ;`
		3878	`}`
		3879	`{`
		3880
		3881	`(ZI466) = no_type_defns - (ZI463) ;`
		3882	`}`
		3883	`{`
		3884
		3885	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		3886	`}`
		3887	`{`
		3888
		3889	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		3890	`}`
		3891	`}`
		3892	`break;`
		3893	`case 65:`
		3894	`{`
		3895	`ADVANCE_LEXER;`
		3896	`ZR1071 (&ZI460, &ZI462, &ZI463, &ZI467);`
		3897	`if ((CURRENT_TERMINAL) == 354) {`
		3898	`RESTORE_LEXER;`
		3899	`goto ZL1;`
		3900	`}`
		3901	`}`
		3902	`break;`
		3903	`case 71:`
		3904	`{`
		3905	`EXP ZI1061;`
		3906	`EXP ZI416;`
		3907	`int ZI465;`
		3908	`int ZI466;`
		3909	`TYPE ZI395;`
		3910
		3911	`ADVANCE_LEXER;`
		3912	`ZR458 (&ZI1061);`
		3913	`if ((CURRENT_TERMINAL) == 354) {`
		3914	`RESTORE_LEXER;`
		3915	`goto ZL1;`
		3916	`}`
		3917	`{`
		3918
		3919	`(ZI416) = make_prefix_exp ( lex_plus_Hplus, (ZI1061) ) ;`
		3920	`}`
		3921	`{`
		3922
		3923	`(ZI465) = no_side_effects - (ZI462) ;`
		3924	`}`
		3925	`{`
		3926
		3927	`(ZI466) = no_type_defns - (ZI463) ;`
		3928	`}`
		3929	`{`
		3930
		3931	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		3932	`}`
		3933	`{`
		3934
		3935	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		3936	`}`
		3937	`}`
		3938	`break;`
		3939	`case 116:`
		3940	`{`
		3941	`int ZI1068;`
		3942	`EXP ZI416;`
		3943	`int ZI465;`
		3944	`int ZI466;`
		3945	`TYPE ZI395;`
		3946
		3947	`ADVANCE_LEXER;`
		3948	`{`
		3949	`(ZI1068) = lex_sizeof ;`
		3950	`}`
		3951	`ZR461 (ZI1068, &ZI416);`
		3952	`if ((CURRENT_TERMINAL) == 354) {`
		3953	`RESTORE_LEXER;`
		3954	`goto ZL1;`
		3955	`}`
		3956	`{`
		3957
		3958	`(ZI465) = no_side_effects - (ZI462) ;`
		3959	`}`
		3960	`{`
		3961
		3962	`(ZI466) = no_type_defns - (ZI463) ;`
		3963	`}`
		3964	`{`
		3965
		3966	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		3967	`}`
		3968	`{`
		3969
		3970	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		3971	`}`
		3972	`}`
		3973	`break;`
		3974	`case 78:`
		3975	`{`
		3976	`EXP ZI1063;`
		3977	`EXP ZI416;`
		3978	`int ZI465;`
		3979	`int ZI466;`
		3980	`TYPE ZI395;`
		3981
		3982	`ADVANCE_LEXER;`
		3983	`ZR459 (&ZI1063);`
		3984	`if ((CURRENT_TERMINAL) == 354) {`
		3985	`RESTORE_LEXER;`
		3986	`goto ZL1;`
		3987	`}`
		3988	`{`
		3989
		3990	`(ZI416) = make_indir_exp ( (ZI1063) ) ;`
		3991	`}`
		3992	`{`
		3993
		3994	`(ZI465) = no_side_effects - (ZI462) ;`
		3995	`}`
		3996	`{`
		3997
		3998	`(ZI466) = no_type_defns - (ZI463) ;`
		3999	`}`
		4000	`{`
		4001
		4002	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		4003	`}`
		4004	`{`
		4005
		4006	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		4007	`}`
		4008	`}`
		4009	`break;`
		4010	`case 33:`
		4011	`{`
		4012	`EXP ZI1064;`
		4013	`EXP ZI416;`
		4014	`int ZI465;`
		4015	`int ZI466;`
		4016	`TYPE ZI395;`
		4017
		4018	`{`
		4019	`{`
		4020	`switch (CURRENT_TERMINAL) {`
		4021	`case 33:`
		4022	`break;`
		4023	`default:`
		4024	`goto ZL1;`
		4025	`}`
		4026	`ADVANCE_LEXER;`
		4027	`}`
		4028	`}`
		4029	`ZR459 (&ZI1064);`
		4030	`if ((CURRENT_TERMINAL) == 354) {`
		4031	`RESTORE_LEXER;`
		4032	`goto ZL1;`
		4033	`}`
		4034	`{`
		4035
		4036	`(ZI416) = make_ref_exp ( (ZI1064), 0 ) ;`
		4037	`}`
		4038	`{`
		4039
		4040	`(ZI465) = no_side_effects - (ZI462) ;`
		4041	`}`
		4042	`{`
		4043
		4044	`(ZI466) = no_type_defns - (ZI463) ;`
		4045	`}`
		4046	`{`
		4047
		4048	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		4049	`}`
		4050	`{`
		4051
		4052	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		4053	`}`
		4054	`}`
		4055	`break;`
		4056	`case 17: case 18: case 19: case 20: case 21:`
		4057	`case 22:`
		4058	`{`
		4059	`EXP ZI1103;`
		4060	`EXP ZI416;`
		4061	`int ZI465;`
		4062	`int ZI466;`
		4063	`TYPE ZI395;`
		4064
		4065	`ZR409 (&ZI1103);`
		4066	`ZR922 (ZI1103, &ZI416);`
		4067	`if ((CURRENT_TERMINAL) == 354) {`
		4068	`RESTORE_LEXER;`
		4069	`goto ZL1;`
		4070	`}`
		4071	`{`
		4072
		4073	`(ZI465) = no_side_effects - (ZI462) ;`
		4074	`}`
		4075	`{`
		4076
		4077	`(ZI466) = no_type_defns - (ZI463) ;`
		4078	`}`
		4079	`{`
		4080
		4081	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		4082	`}`
		4083	`{`
		4084
		4085	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		4086	`}`
		4087	`}`
		4088	`break;`
		4089	`case 62:`
		4090	`{`
		4091	`EXP ZI1065;`
		4092	`EXP ZI416;`
		4093	`int ZI465;`
		4094	`int ZI466;`
		4095	`TYPE ZI395;`
		4096
		4097	`{`
		4098	`{`
		4099	`switch (CURRENT_TERMINAL) {`
		4100	`case 62:`
		4101	`break;`
		4102	`default:`
		4103	`goto ZL1;`
		4104	`}`
		4105	`ADVANCE_LEXER;`
		4106	`}`
		4107	`}`
		4108	`ZR459 (&ZI1065);`
		4109	`if ((CURRENT_TERMINAL) == 354) {`
		4110	`RESTORE_LEXER;`
		4111	`goto ZL1;`
		4112	`}`
		4113	`{`
		4114
		4115	`(ZI416) = make_not_exp ( (ZI1065) ) ;`
		4116	`}`
		4117	`{`
		4118
		4119	`(ZI465) = no_side_effects - (ZI462) ;`
		4120	`}`
		4121	`{`
		4122
		4123	`(ZI466) = no_type_defns - (ZI463) ;`
		4124	`}`
		4125	`{`
		4126
		4127	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		4128	`}`
		4129	`{`
		4130
		4131	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		4132	`}`
		4133	`}`
		4134	`break;`
		4135	`case 43: case 59: case 69: case 85:`
		4136	`{`
		4137	`int ZI1066;`
		4138	`EXP ZI1067;`
		4139	`EXP ZI416;`
		4140	`int ZI465;`
		4141	`int ZI466;`
		4142	`TYPE ZI395;`
		4143
		4144	`{`
		4145	`(ZI1066) = crt_lex_token ;`
		4146	`}`
		4147	`ZR469 ();`
		4148	`ZR459 (&ZI1067);`
		4149	`if ((CURRENT_TERMINAL) == 354) {`
		4150	`RESTORE_LEXER;`
		4151	`goto ZL1;`
		4152	`}`
		4153	`{`
		4154
		4155	`(ZI416) = make_uminus_exp ( (ZI1066), (ZI1067) ) ;`
		4156	`}`
		4157	`{`
		4158
		4159	`(ZI465) = no_side_effects - (ZI462) ;`
		4160	`}`
		4161	`{`
		4162
		4163	`(ZI466) = no_type_defns - (ZI463) ;`
		4164	`}`
		4165	`{`
		4166
		4167	`(ZI395) = typeof_exp ( &(ZI416), (ZI465), (ZI460) ) ;`
		4168	`}`
		4169	`{`
		4170
		4171	`(ZI467) = make_sizeof_exp ( (ZI395), (ZI416), (ZI466), (ZI460) ) ;`
		4172	`}`
		4173	`}`
		4174	`break;`
		4175	`default:`
		4176	`goto ZL1;`
		4177	`}`
		4178	`}`
		4179	`{`
		4180
		4181	`suppress_usage-- ;`
		4182	`}`
		4183	`ZI404 = ZI467;`
		4184	`}`
		4185	`goto ZL0;`
		4186	`ZL1:;`
		4187	`SAVE_LEXER (354);`
		4188	`return;`
		4189	`ZL0:;`
		4190	`*ZO404 = ZI404;`
		4191	`}`
		4192
		4193	`void`
		4194	`ZR918 PROTO_N ((ZI916, ZO917))`
		4195	`PROTO_T (EXP ZI916 X EXP *ZO917)`
		4196	`{`
		4197	`EXP ZI917;`
		4198
		4199	`ZL2_918:;`
		4200	`switch (CURRENT_TERMINAL) {`
		4201	`case 44:`
		4202	`{`
		4203	`EXP ZI448;`
		4204	`EXP ZI404;`
		4205
		4206	`ADVANCE_LEXER;`
		4207	`ZR459 (&ZI448);`
		4208	`if ((CURRENT_TERMINAL) == 354) {`
		4209	`RESTORE_LEXER;`
		4210	`goto ZL1;`
		4211	`}`
		4212	`{`
		4213
		4214	`(ZI404) = make_mult_exp ( lex_div, (ZI916), (ZI448) ) ;`
		4215	`}`
		4216	`ZI916 = ZI404;`
		4217	`goto ZL2_918;`
		4218	`}`
		4219	`/UNREACHED/`
		4220	`case 73:`
		4221	`{`
		4222	`EXP ZI448;`
		4223	`EXP ZI404;`
		4224
		4225	`ADVANCE_LEXER;`
		4226	`ZR459 (&ZI448);`
		4227	`if ((CURRENT_TERMINAL) == 354) {`
		4228	`RESTORE_LEXER;`
		4229	`goto ZL1;`
		4230	`}`
		4231	`{`
		4232
		4233	`(ZI404) = make_rem_exp ( (ZI916), (ZI448) ) ;`
		4234	`}`
		4235	`ZI916 = ZI404;`
		4236	`goto ZL2_918;`
		4237	`}`
		4238	`/UNREACHED/`
		4239	`case 78:`
		4240	`{`
		4241	`EXP ZI448;`
		4242	`EXP ZI404;`
		4243
		4244	`ADVANCE_LEXER;`
		4245	`ZR459 (&ZI448);`
		4246	`if ((CURRENT_TERMINAL) == 354) {`
		4247	`RESTORE_LEXER;`
		4248	`goto ZL1;`
		4249	`}`
		4250	`{`
		4251
		4252	`(ZI404) = make_mult_exp ( lex_star, (ZI916), (ZI448) ) ;`
		4253	`}`
		4254	`ZI916 = ZI404;`
		4255	`goto ZL2_918;`
		4256	`}`
		4257	`/UNREACHED/`
		4258	`default:`
		4259	`{`
		4260	`ZI917 = ZI916;`
		4261	`}`
		4262	`break;`
		4263	`case 354:`
		4264	`return;`
		4265	`}`
		4266	`goto ZL0;`
		4267	`ZL1:;`
		4268	`SAVE_LEXER (354);`
		4269	`return;`
		4270	`ZL0:;`
		4271	`*ZO917 = ZI917;`
		4272	`}`
		4273
		4274	`void`
		4275	`ZR1046 PROTO_N ((ZO854, ZO855))`
		4276	`PROTO_T (TYPE ZO854 X IDENTIFIER ZO855)`
		4277	`{`
		4278	`TYPE ZI854;`
		4279	`IDENTIFIER ZI855;`
		4280
		4281	`if ((CURRENT_TERMINAL) == 354) {`
		4282	`return;`
		4283	`}`
		4284	`{`
		4285	`IDENTIFIER ZI1047;`
		4286	`TYPE ZI1048;`
		4287	`TYPE ZI395;`
		4288	`IDENTIFIER ZI399;`
		4289
		4290	`{`
		4291
		4292	`/* Resolve parameter declarators from type names */`
		4293	`(ZI0) = predict_param () ;`
		4294	`}`
		4295	`if (!ZI0)`
		4296	`goto ZL2;`
		4297	`{`
		4298	`switch (CURRENT_TERMINAL) {`
		4299	`case 1:`
		4300	`{`
		4301	`{`
		4302
		4303	`ZI1047 = crt_token->pp_data.id.use ;`
		4304	`}`
		4305	`ADVANCE_LEXER;`
		4306	`}`
		4307	`break;`
		4308	`case 4:`
		4309	`{`
		4310	`{`
		4311
		4312	`ZI1047 = crt_token->pp_data.id.use ;`
		4313	`}`
		4314	`ADVANCE_LEXER;`
		4315	`}`
		4316	`break;`
		4317	`case 2:`
		4318	`{`
		4319	`{`
		4320
		4321	`ZI1047 = crt_token->pp_data.id.use ;`
		4322	`}`
		4323	`ADVANCE_LEXER;`
		4324	`}`
		4325	`break;`
		4326	`default:`
		4327	`goto ZL1;`
		4328	`}`
		4329	`}`
		4330	`{`
		4331
		4332	`(ZI1048) = NULL_type ;`
		4333	`}`
		4334	`{`
		4335
		4336	`IDENTIFIER pid = underlying_id ( (ZI1047) ) ;`
		4337	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		4338	`}`
		4339	`ZR856 (ZI1048, ZI1047, &ZI395, &ZI399);`
		4340	`if ((CURRENT_TERMINAL) == 354) {`
		4341	`RESTORE_LEXER;`
		4342	`goto ZL1;`
		4343	`}`
		4344	`{`
		4345
		4346	`if ( IS_NULL_type ( (ZI395) ) ) {`
		4347	`report ( crt_loc, ERR_dcl_meaning_paren () ) ;`
		4348	`}`
		4349	`}`
		4350	`switch (CURRENT_TERMINAL) {`
		4351	`case 39:`
		4352	`break;`
		4353	`default:`
		4354	`goto ZL1;`
		4355	`}`
		4356	`ADVANCE_LEXER;`
		4357	`ZR856 (ZI395, ZI399, &ZI854, &ZI855);`
		4358	`if ((CURRENT_TERMINAL) == 354) {`
		4359	`RESTORE_LEXER;`
		4360	`goto ZL1;`
		4361	`}`
		4362	`goto ZL0;`
		4363	`}`
		4364	`/UNREACHED/`
		4365	`ZL2:;`
		4366	`switch (CURRENT_TERMINAL) {`
		4367	`case 65:`
		4368	`{`
		4369	`TYPE ZI395;`
		4370	`IDENTIFIER ZI399;`
		4371
		4372	`ADVANCE_LEXER;`
		4373	`ZR1046 (&ZI395, &ZI399);`
		4374	`if ((CURRENT_TERMINAL) == 354) {`
		4375	`RESTORE_LEXER;`
		4376	`goto ZL1;`
		4377	`}`
		4378	`{`
		4379
		4380	`if ( IS_NULL_type ( (ZI395) ) ) {`
		4381	`report ( crt_loc, ERR_dcl_meaning_paren () ) ;`
		4382	`}`
		4383	`}`
		4384	`switch (CURRENT_TERMINAL) {`
		4385	`case 39:`
		4386	`break;`
		4387	`default:`
		4388	`goto ZL1;`
		4389	`}`
		4390	`ADVANCE_LEXER;`
		4391	`ZR856 (ZI395, ZI399, &ZI854, &ZI855);`
		4392	`if ((CURRENT_TERMINAL) == 354) {`
		4393	`RESTORE_LEXER;`
		4394	`goto ZL1;`
		4395	`}`
		4396	`}`
		4397	`break;`
		4398	`case 331:`
		4399	`{`
		4400	`IDENTIFIER ZI1045;`
		4401	`int ZI747;`
		4402	`TYPE ZI1051;`
		4403	`IDENTIFIER ZI1052;`
		4404	`TYPE ZI395;`
		4405	`IDENTIFIER ZI399;`
		4406
		4407	`ADVANCE_LEXER;`
		4408	`switch (CURRENT_TERMINAL) {`
		4409	`case 65:`
		4410	`break;`
		4411	`default:`
		4412	`goto ZL1;`
		4413	`}`
		4414	`ADVANCE_LEXER;`
		4415	`{`
		4416
		4417	`(ZI1045) = NULL_id ;`
		4418	`}`
		4419	`{`
		4420
		4421	`func_type_defn ( 0 ) ;`
		4422	`begin_param ( (ZI1045) ) ;`
		4423	`have_type_declaration = TYPE_DECL_NONE ;`
		4424	`have_func_declarator = 0 ;`
		4425	`}`
		4426	`ZR758 (&ZI747);`
		4427	`if ((CURRENT_TERMINAL) == 354) {`
		4428	`RESTORE_LEXER;`
		4429	`goto ZL1;`
		4430	`}`
		4431	`{`
		4432
		4433	`(ZI1051) = make_func_type ( NULL_type, ( (ZI747) \| FUNC_WEAK ), cv_c, empty_type_set ) ;`
		4434	`}`
		4435	`switch (CURRENT_TERMINAL) {`
		4436	`case 39:`
		4437	`break;`
		4438	`default:`
		4439	`goto ZL1;`
		4440	`}`
		4441	`ADVANCE_LEXER;`
		4442	`{`
		4443
		4444	`end_param () ;`
		4445	`have_type_declaration = TYPE_DECL_NONE ;`
		4446	`have_func_declarator = 1 ;`
		4447	`}`
		4448	`{`
		4449
		4450	`HASHID nm = lookup_anon () ;`
		4451	`(ZI1052) = DEREF_id ( hashid_id ( nm ) ) ;`
		4452	`}`
		4453	`{`
		4454
		4455	`IDENTIFIER pid = underlying_id ( (ZI1052) ) ;`
		4456	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		4457	`}`
		4458	`ZR856 (ZI1051, ZI1052, &ZI395, &ZI399);`
		4459	`if ((CURRENT_TERMINAL) == 354) {`
		4460	`RESTORE_LEXER;`
		4461	`goto ZL1;`
		4462	`}`
		4463	`{`
		4464
		4465	`if ( IS_NULL_type ( (ZI395) ) ) {`
		4466	`report ( crt_loc, ERR_dcl_meaning_paren () ) ;`
		4467	`}`
		4468	`}`
		4469	`switch (CURRENT_TERMINAL) {`
		4470	`case 39:`
		4471	`break;`
		4472	`default:`
		4473	`goto ZL1;`
		4474	`}`
		4475	`ADVANCE_LEXER;`
		4476	`ZR856 (ZI395, ZI399, &ZI854, &ZI855);`
		4477	`if ((CURRENT_TERMINAL) == 354) {`
		4478	`RESTORE_LEXER;`
		4479	`goto ZL1;`
		4480	`}`
		4481	`}`
		4482	`break;`
		4483	`case 66:`
		4484	`{`
		4485	`EXP ZI404;`
		4486	`TYPE ZI1049;`
		4487	`IDENTIFIER ZI1050;`
		4488	`TYPE ZI395;`
		4489	`IDENTIFIER ZI399;`
		4490
		4491	`{`
		4492	`{`
		4493	`switch (CURRENT_TERMINAL) {`
		4494	`case 66:`
		4495	`break;`
		4496	`default:`
		4497	`goto ZL1;`
		4498	`}`
		4499	`ADVANCE_LEXER;`
		4500	`}`
		4501	`}`
		4502	`ZR757 (&ZI404);`
		4503	`if ((CURRENT_TERMINAL) == 354) {`
		4504	`RESTORE_LEXER;`
		4505	`goto ZL1;`
		4506	`}`
		4507	`{`
		4508
		4509	`NAT n = make_array_dim ( (ZI404) ) ;`
		4510	`MAKE_type_array ( cv_none, NULL_type, n, (ZI1049) ) ;`
		4511	`}`
		4512	`{`
		4513	`{`
		4514	`switch (CURRENT_TERMINAL) {`
		4515	`case 40:`
		4516	`break;`
		4517	`default:`
		4518	`goto ZL1;`
		4519	`}`
		4520	`ADVANCE_LEXER;`
		4521	`}`
		4522	`}`
		4523	`{`
		4524
		4525	`HASHID nm = lookup_anon () ;`
		4526	`(ZI1050) = DEREF_id ( hashid_id ( nm ) ) ;`
		4527	`}`
		4528	`{`
		4529
		4530	`IDENTIFIER pid = underlying_id ( (ZI1050) ) ;`
		4531	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		4532	`}`
		4533	`ZR856 (ZI1049, ZI1050, &ZI395, &ZI399);`
		4534	`if ((CURRENT_TERMINAL) == 354) {`
		4535	`RESTORE_LEXER;`
		4536	`goto ZL1;`
		4537	`}`
		4538	`{`
		4539
		4540	`if ( IS_NULL_type ( (ZI395) ) ) {`
		4541	`report ( crt_loc, ERR_dcl_meaning_paren () ) ;`
		4542	`}`
		4543	`}`
		4544	`switch (CURRENT_TERMINAL) {`
		4545	`case 39:`
		4546	`break;`
		4547	`default:`
		4548	`goto ZL1;`
		4549	`}`
		4550	`ADVANCE_LEXER;`
		4551	`ZR856 (ZI395, ZI399, &ZI854, &ZI855);`
		4552	`if ((CURRENT_TERMINAL) == 354) {`
		4553	`RESTORE_LEXER;`
		4554	`goto ZL1;`
		4555	`}`
		4556	`}`
		4557	`break;`
		4558	`case 78:`
		4559	`{`
		4560	`TYPE ZI420;`
		4561	`TYPE ZI423;`
		4562	`IDENTIFIER ZI399;`
		4563	`TYPE ZI395;`
		4564
		4565	`ZR731 (&ZI420);`
		4566	`ZR764 (&ZI423, &ZI399);`
		4567	`if ((CURRENT_TERMINAL) == 354) {`
		4568	`RESTORE_LEXER;`
		4569	`goto ZL1;`
		4570	`}`
		4571	`{`
		4572
		4573	`(ZI395) = ( IS_NULL_type ( (ZI423) ) ? (ZI420) : inject_pre_type ( (ZI423), (ZI420), 0 ) ) ;`
		4574	`}`
		4575	`{`
		4576
		4577	`if ( IS_NULL_type ( (ZI395) ) ) {`
		4578	`report ( crt_loc, ERR_dcl_meaning_paren () ) ;`
		4579	`}`
		4580	`}`
		4581	`switch (CURRENT_TERMINAL) {`
		4582	`case 39:`
		4583	`break;`
		4584	`default:`
		4585	`goto ZL1;`
		4586	`}`
		4587	`ADVANCE_LEXER;`
		4588	`ZR856 (ZI395, ZI399, &ZI854, &ZI855);`
		4589	`if ((CURRENT_TERMINAL) == 354) {`
		4590	`RESTORE_LEXER;`
		4591	`goto ZL1;`
		4592	`}`
		4593	`}`
		4594	`break;`
		4595	`case 2: case 25: case 39: case 47: case 94:`
		4596	`case 97: case 98: case 102: case 104: case 105:`
		4597	`case 106: case 110: case 111: case 112: case 114:`
		4598	`case 115: case 117: case 118: case 120: case 121:`
		4599	`case 122: case 123: case 124: case 137: case 156:`
		4600	`case 184: case 285: case 298:`
		4601	`{`
		4602	`IDENTIFIER ZI1044;`
		4603	`TYPE ZI568;`
		4604	`TYPE ZI395;`
		4605	`IDENTIFIER ZI399;`
		4606
		4607	`{`
		4608
		4609	`(ZI1044) = NULL_id ;`
		4610	`}`
		4611	`{`
		4612
		4613	`func_type_defn ( 0 ) ;`
		4614	`begin_param ( (ZI1044) ) ;`
		4615	`have_type_declaration = TYPE_DECL_NONE ;`
		4616	`have_func_declarator = 0 ;`
		4617	`}`
		4618	`ZR755 (&ZI568);`
		4619	`switch (CURRENT_TERMINAL) {`
		4620	`case 39:`
		4621	`break;`
		4622	`case 354:`
		4623	`RESTORE_LEXER;`
		4624	`goto ZL1;`
		4625	`default:`
		4626	`goto ZL1;`
		4627	`}`
		4628	`ADVANCE_LEXER;`
		4629	`ZI395 = ZI568;`
		4630	`{`
		4631
		4632	`end_param () ;`
		4633	`have_type_declaration = TYPE_DECL_NONE ;`
		4634	`have_func_declarator = 1 ;`
		4635	`}`
		4636	`{`
		4637
		4638	`HASHID nm = lookup_anon () ;`
		4639	`(ZI399) = DEREF_id ( hashid_id ( nm ) ) ;`
		4640	`}`
		4641	`{`
		4642
		4643	`IDENTIFIER pid = underlying_id ( (ZI399) ) ;`
		4644	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		4645	`}`
		4646	`ZR856 (ZI395, ZI399, &ZI854, &ZI855);`
		4647	`if ((CURRENT_TERMINAL) == 354) {`
		4648	`RESTORE_LEXER;`
		4649	`goto ZL1;`
		4650	`}`
		4651	`}`
		4652	`break;`
		4653	`default:`
		4654	`goto ZL1;`
		4655	`}`
		4656	`goto ZL0;`
		4657	`ZL1:;`
		4658	`SAVE_LEXER (354);`
		4659	`return;`
		4660	`ZL0:;`
		4661	`*ZO854 = ZI854;`
		4662	`*ZO855 = ZI855;`
		4663	`}`
		4664
		4665	`void`
		4666	`ZR778 PROTO_Z ()`
		4667	`{`
		4668	`ZL2_778:;`
		4669	`switch (CURRENT_TERMINAL) {`
		4670	`case 42:`
		4671	`{`
		4672	`IDENTIFIER ZI399;`
		4673
		4674	`ADVANCE_LEXER;`
		4675	`ZR777 (&ZI399);`
		4676	`if ((CURRENT_TERMINAL) == 354) {`
		4677	`RESTORE_LEXER;`
		4678	`goto ZL1;`
		4679	`}`
		4680	`{`
		4681
		4682	`IDENTIFIER pid = underlying_id ( (ZI399) ) ;`
		4683	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		4684	`}`
		4685	`{`
		4686
		4687	`IGNORE weak_param_decl ( (ZI399) ) ;`
		4688	`have_type_declaration = TYPE_DECL_NONE ;`
		4689	`have_func_declarator = 0 ;`
		4690	`}`
		4691	`goto ZL2_778;`
		4692	`}`
		4693	`/UNREACHED/`
		4694	`case 354:`
		4695	`return;`
		4696	`default:`
		4697	`break;`
		4698	`}`
		4699	`return;`
		4700	`ZL1:;`
		4701	`SAVE_LEXER (354);`
		4702	`return;`
		4703	`}`
		4704
		4705	`void`
		4706	`ZR764 PROTO_N ((ZO395, ZO399))`
		4707	`PROTO_T (TYPE ZO395 X IDENTIFIER ZO399)`
		4708	`{`
		4709	`TYPE ZI395;`
		4710	`IDENTIFIER ZI399;`
		4711
		4712	`if ((CURRENT_TERMINAL) == 354) {`
		4713	`return;`
		4714	`}`
		4715	`{`
		4716	`IDENTIFIER ZI1047;`
		4717	`TYPE ZI1048;`
		4718
		4719	`{`
		4720
		4721	`/* Resolve parameter declarators from type names */`
		4722	`(ZI0) = predict_param () ;`
		4723	`}`
		4724	`if (!ZI0)`
		4725	`goto ZL2;`
		4726	`{`
		4727	`switch (CURRENT_TERMINAL) {`
		4728	`case 1:`
		4729	`{`
		4730	`{`
		4731
		4732	`ZI1047 = crt_token->pp_data.id.use ;`
		4733	`}`
		4734	`ADVANCE_LEXER;`
		4735	`}`
		4736	`break;`
		4737	`case 4:`
		4738	`{`
		4739	`{`
		4740
		4741	`ZI1047 = crt_token->pp_data.id.use ;`
		4742	`}`
		4743	`ADVANCE_LEXER;`
		4744	`}`
		4745	`break;`
		4746	`case 2:`
		4747	`{`
		4748	`{`
		4749
		4750	`ZI1047 = crt_token->pp_data.id.use ;`
		4751	`}`
		4752	`ADVANCE_LEXER;`
		4753	`}`
		4754	`break;`
		4755	`default:`
		4756	`goto ZL1;`
		4757	`}`
		4758	`}`
		4759	`{`
		4760
		4761	`(ZI1048) = NULL_type ;`
		4762	`}`
		4763	`{`
		4764
		4765	`IDENTIFIER pid = underlying_id ( (ZI1047) ) ;`
		4766	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		4767	`}`
		4768	`ZR856 (ZI1048, ZI1047, &ZI395, &ZI399);`
		4769	`if ((CURRENT_TERMINAL) == 354) {`
		4770	`RESTORE_LEXER;`
		4771	`goto ZL1;`
		4772	`}`
		4773	`goto ZL0;`
		4774	`}`
		4775	`/UNREACHED/`
		4776	`ZL2:;`
		4777	`switch (CURRENT_TERMINAL) {`
		4778	`case 65:`
		4779	`{`
		4780	`ADVANCE_LEXER;`
		4781	`ZR1046 (&ZI395, &ZI399);`
		4782	`if ((CURRENT_TERMINAL) == 354) {`
		4783	`RESTORE_LEXER;`
		4784	`goto ZL1;`
		4785	`}`
		4786	`}`
		4787	`break;`
		4788	`case 331:`
		4789	`{`
		4790	`IDENTIFIER ZI1045;`
		4791	`int ZI747;`
		4792	`TYPE ZI1051;`
		4793	`IDENTIFIER ZI1052;`
		4794
		4795	`ADVANCE_LEXER;`
		4796	`switch (CURRENT_TERMINAL) {`
		4797	`case 65:`
		4798	`break;`
		4799	`default:`
		4800	`goto ZL1;`
		4801	`}`
		4802	`ADVANCE_LEXER;`
		4803	`{`
		4804
		4805	`(ZI1045) = NULL_id ;`
		4806	`}`
		4807	`{`
		4808
		4809	`func_type_defn ( 0 ) ;`
		4810	`begin_param ( (ZI1045) ) ;`
		4811	`have_type_declaration = TYPE_DECL_NONE ;`
		4812	`have_func_declarator = 0 ;`
		4813	`}`
		4814	`ZR758 (&ZI747);`
		4815	`if ((CURRENT_TERMINAL) == 354) {`
		4816	`RESTORE_LEXER;`
		4817	`goto ZL1;`
		4818	`}`
		4819	`{`
		4820
		4821	`(ZI1051) = make_func_type ( NULL_type, ( (ZI747) \| FUNC_WEAK ), cv_c, empty_type_set ) ;`
		4822	`}`
		4823	`switch (CURRENT_TERMINAL) {`
		4824	`case 39:`
		4825	`break;`
		4826	`default:`
		4827	`goto ZL1;`
		4828	`}`
		4829	`ADVANCE_LEXER;`
		4830	`{`
		4831
		4832	`end_param () ;`
		4833	`have_type_declaration = TYPE_DECL_NONE ;`
		4834	`have_func_declarator = 1 ;`
		4835	`}`
		4836	`{`
		4837
		4838	`HASHID nm = lookup_anon () ;`
		4839	`(ZI1052) = DEREF_id ( hashid_id ( nm ) ) ;`
		4840	`}`
		4841	`{`
		4842
		4843	`IDENTIFIER pid = underlying_id ( (ZI1052) ) ;`
		4844	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		4845	`}`
		4846	`ZR856 (ZI1051, ZI1052, &ZI395, &ZI399);`
		4847	`if ((CURRENT_TERMINAL) == 354) {`
		4848	`RESTORE_LEXER;`
		4849	`goto ZL1;`
		4850	`}`
		4851	`}`
		4852	`break;`
		4853	`case 66:`
		4854	`{`
		4855	`EXP ZI404;`
		4856	`TYPE ZI1049;`
		4857	`IDENTIFIER ZI1050;`
		4858
		4859	`{`
		4860	`{`
		4861	`switch (CURRENT_TERMINAL) {`
		4862	`case 66:`
		4863	`break;`
		4864	`default:`
		4865	`goto ZL1;`
		4866	`}`
		4867	`ADVANCE_LEXER;`
		4868	`}`
		4869	`}`
		4870	`ZR757 (&ZI404);`
		4871	`if ((CURRENT_TERMINAL) == 354) {`
		4872	`RESTORE_LEXER;`
		4873	`goto ZL1;`
		4874	`}`
		4875	`{`
		4876
		4877	`NAT n = make_array_dim ( (ZI404) ) ;`
		4878	`MAKE_type_array ( cv_none, NULL_type, n, (ZI1049) ) ;`
		4879	`}`
		4880	`{`
		4881	`{`
		4882	`switch (CURRENT_TERMINAL) {`
		4883	`case 40:`
		4884	`break;`
		4885	`default:`
		4886	`goto ZL1;`
		4887	`}`
		4888	`ADVANCE_LEXER;`
		4889	`}`
		4890	`}`
		4891	`{`
		4892
		4893	`HASHID nm = lookup_anon () ;`
		4894	`(ZI1050) = DEREF_id ( hashid_id ( nm ) ) ;`
		4895	`}`
		4896	`{`
		4897
		4898	`IDENTIFIER pid = underlying_id ( (ZI1050) ) ;`
		4899	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		4900	`}`
		4901	`ZR856 (ZI1049, ZI1050, &ZI395, &ZI399);`
		4902	`if ((CURRENT_TERMINAL) == 354) {`
		4903	`RESTORE_LEXER;`
		4904	`goto ZL1;`
		4905	`}`
		4906	`}`
		4907	`break;`
		4908	`case 78:`
		4909	`{`
		4910	`TYPE ZI420;`
		4911	`TYPE ZI423;`
		4912
		4913	`ZR731 (&ZI420);`
		4914	`ZR764 (&ZI423, &ZI399);`
		4915	`if ((CURRENT_TERMINAL) == 354) {`
		4916	`RESTORE_LEXER;`
		4917	`goto ZL1;`
		4918	`}`
		4919	`{`
		4920
		4921	`(ZI395) = ( IS_NULL_type ( (ZI423) ) ? (ZI420) : inject_pre_type ( (ZI423), (ZI420), 0 ) ) ;`
		4922	`}`
		4923	`}`
		4924	`break;`
		4925	`default:`
		4926	`{`
		4927	`{`
		4928
		4929	`(ZI395) = NULL_type ;`
		4930	`}`
		4931	`{`
		4932
		4933	`HASHID nm = lookup_anon () ;`
		4934	`(ZI399) = DEREF_id ( hashid_id ( nm ) ) ;`
		4935	`}`
		4936	`{`
		4937
		4938	`IDENTIFIER pid = underlying_id ( (ZI399) ) ;`
		4939	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		4940	`}`
		4941	`}`
		4942	`break;`
		4943	`}`
		4944	`goto ZL0;`
		4945	`ZL1:;`
		4946	`SAVE_LEXER (354);`
		4947	`return;`
		4948	`ZL0:;`
		4949	`*ZO395 = ZI395;`
		4950	`*ZO399 = ZI399;`
		4951	`}`
		4952
		4953	`void`
		4954	`ZR922 PROTO_N ((ZI920, ZO921))`
		4955	`PROTO_T (EXP ZI920 X EXP *ZO921)`
		4956	`{`
		4957	`EXP ZI921;`
		4958
		4959	`ZL2_922:;`
		4960	`switch (CURRENT_TERMINAL) {`
		4961	`case 61:`
		4962	`{`
		4963	`EXP ZI404;`
		4964
		4965	`ADVANCE_LEXER;`
		4966	`{`
		4967
		4968	`(ZI404) = make_postfix_exp ( lex_minus_Hminus, (ZI920) ) ;`
		4969	`}`
		4970	`ZI920 = ZI404;`
		4971	`goto ZL2_922;`
		4972	`}`
		4973	`/UNREACHED/`
		4974	`case 65:`
		4975	`{`
		4976	`SID_LIST_EXP ZI420;`
		4977	`EXP ZI404;`
		4978
		4979	`ADVANCE_LEXER;`
		4980	`ZR424 (&ZI420);`
		4981	`if ((CURRENT_TERMINAL) == 354) {`
		4982	`RESTORE_LEXER;`
		4983	`goto ZL1;`
		4984	`}`
		4985	`{`
		4986
		4987	`(ZI404) = make_func_exp ( (ZI920), (ZI420), 0 ) ;`
		4988	`}`
		4989	`switch (CURRENT_TERMINAL) {`
		4990	`case 39:`
		4991	`break;`
		4992	`default:`
		4993	`goto ZL1;`
		4994	`}`
		4995	`ADVANCE_LEXER;`
		4996	`ZI920 = ZI404;`
		4997	`goto ZL2_922;`
		4998	`}`
		4999	`/UNREACHED/`
		5000	`case 71:`
		5001	`{`
		5002	`EXP ZI404;`
		5003
		5004	`ADVANCE_LEXER;`
		5005	`{`
		5006
		5007	`(ZI404) = make_postfix_exp ( lex_plus_Hplus, (ZI920) ) ;`
		5008	`}`
		5009	`ZI920 = ZI404;`
		5010	`goto ZL2_922;`
		5011	`}`
		5012	`/UNREACHED/`
		5013	`case 66:`
		5014	`{`
		5015	`EXP ZI448;`
		5016	`EXP ZI404;`
		5017
		5018	`{`
		5019	`{`
		5020	`switch (CURRENT_TERMINAL) {`
		5021	`case 66:`
		5022	`break;`
		5023	`default:`
		5024	`goto ZL1;`
		5025	`}`
		5026	`ADVANCE_LEXER;`
		5027	`}`
		5028	`}`
		5029	`ZR414 (&ZI448);`
		5030	`{`
		5031	`if ((CURRENT_TERMINAL) == 354) {`
		5032	`RESTORE_LEXER;`
		5033	`goto ZL1;`
		5034	`}`
		5035	`{`
		5036	`switch (CURRENT_TERMINAL) {`
		5037	`case 40:`
		5038	`break;`
		5039	`default:`
		5040	`goto ZL1;`
		5041	`}`
		5042	`ADVANCE_LEXER;`
		5043	`}`
		5044	`}`
		5045	`{`
		5046
		5047	`(ZI404) = make_index_exp ( (ZI920), (ZI448) ) ;`
		5048	`}`
		5049	`ZI920 = ZI404;`
		5050	`goto ZL2_922;`
		5051	`}`
		5052	`/UNREACHED/`
		5053	`case 35:`
		5054	`{`
		5055	`EXP ZI448;`
		5056	`TYPE ZI395;`
		5057	`NAMESPACE ZI426;`
		5058	`IDENTIFIER ZI399;`
		5059	`EXP ZI404;`
		5060
		5061	`{`
		5062
		5063	`(ZI448) = begin_field_exp ( lex_arrow, (ZI920), &(ZI395), &(ZI426) ) ;`
		5064	`}`
		5065	`ADVANCE_LEXER;`
		5066	`ZR427 (ZI426, &ZI399);`
		5067	`if ((CURRENT_TERMINAL) == 354) {`
		5068	`RESTORE_LEXER;`
		5069	`goto ZL1;`
		5070	`}`
		5071	`{`
		5072
		5073	`(ZI404) = end_field_exp ( lex_arrow, (ZI448), (ZI395), (ZI426), (ZI399), 0 ) ;`
		5074	`}`
		5075	`{`
		5076
		5077	`RESCAN_LEXER ;`
		5078	`}`
		5079	`ZI920 = ZI404;`
		5080	`goto ZL2_922;`
		5081	`}`
		5082	`/UNREACHED/`
		5083	`case 46:`
		5084	`{`
		5085	`EXP ZI448;`
		5086	`TYPE ZI395;`
		5087	`NAMESPACE ZI426;`
		5088	`IDENTIFIER ZI399;`
		5089	`EXP ZI404;`
		5090
		5091	`{`
		5092
		5093	`(ZI448) = begin_field_exp ( lex_dot, (ZI920), &(ZI395), &(ZI426) ) ;`
		5094	`}`
		5095	`ADVANCE_LEXER;`
		5096	`ZR427 (ZI426, &ZI399);`
		5097	`if ((CURRENT_TERMINAL) == 354) {`
		5098	`RESTORE_LEXER;`
		5099	`goto ZL1;`
		5100	`}`
		5101	`{`
		5102
		5103	`(ZI404) = end_field_exp ( lex_dot, (ZI448), (ZI395), (ZI426), (ZI399), 0 ) ;`
		5104	`}`
		5105	`{`
		5106
		5107	`RESCAN_LEXER ;`
		5108	`}`
		5109	`ZI920 = ZI404;`
		5110	`goto ZL2_922;`
		5111	`}`
		5112	`/UNREACHED/`
		5113	`default:`
		5114	`{`
		5115	`ZI921 = ZI920;`
		5116	`}`
		5117	`break;`
		5118	`case 354:`
		5119	`return;`
		5120	`}`
		5121	`goto ZL0;`
		5122	`ZL1:;`
		5123	`SAVE_LEXER (354);`
		5124	`return;`
		5125	`ZL0:;`
		5126	`*ZO921 = ZI921;`
		5127	`}`
		5128
		5129	`/* END OF FILE */`

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/producers/c/syntax/syntax1.c – Rev 5