WebSVN – tendra.SVN – Blame – /trunk/src/producers/c/syntax/syntax3.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	`void`
		131	`ZR1092 PROTO_N ((ZI1091, ZO404))`
		132	`PROTO_T (EXP ZI1091 X EXP ZO404)`
		133	`{`
		134	`EXP ZI404;`
		135
		136	`switch (CURRENT_TERMINAL) {`
		137	`case 346:`
		138	`{`
		139	`SID_LIST_EXP ZI423;`
		140	`SID_LIST_EXP ZI420;`
		141	`EXP ZI416;`
		142	`int ZI537;`
		143
		144	`ADVANCE_LEXER;`
		145	`ZR515 (&ZI423);`
		146	`if ((CURRENT_TERMINAL) == 354) {`
		147	`RESTORE_LEXER;`
		148	`goto ZL1;`
		149	`}`
		150	`{`
		151
		152	`CONS_exp ( (*ZI1091), (ZI423), (ZI420) ) ;`
		153	`}`
		154	`{`
		155
		156	`(ZI416) = make_comma_exp ( (ZI420) ) ;`
		157	`}`
		158	`{`
		159
		160	`(ZI537) = unreached_code ;`
		161	`if ( (ZI537) ) {`
		162	`if ( !unreached_last ) {`
		163	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		164	`unreached_last = 1 ;`
		165	`}`
		166	`} else {`
		167	`unreached_last = 0 ;`
		168	`}`
		169	`}`
		170	`{`
		171
		172	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		173	`}`
		174	`{`
		175
		176	`unreached_fall = 1 ;`
		177	`}`
		178	`switch (CURRENT_TERMINAL) {`
		179	`case 77:`
		180	`break;`
		181	`default:`
		182	`goto ZL1;`
		183	`}`
		184	`ADVANCE_LEXER;`
		185	`}`
		186	`break;`
		187	`case 77:`
		188	`{`
		189	`int ZI537;`
		190
		191	`ADVANCE_LEXER;`
		192	`switch (CURRENT_TERMINAL) {`
		193	`case 346:`
		194	`break;`
		195	`default:`
		196	`goto ZL1;`
		197	`}`
		198	`ADVANCE_LEXER;`
		199	`{`
		200
		201	`(ZI537) = unreached_code ;`
		202	`if ( (ZI537) ) {`
		203	`if ( !unreached_last ) {`
		204	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		205	`unreached_last = 1 ;`
		206	`}`
		207	`} else {`
		208	`unreached_last = 0 ;`
		209	`}`
		210	`}`
		211	`{`
		212
		213	`(ZI404) = make_exp_stmt ( (*ZI1091) ) ;`
		214	`}`
		215	`{`
		216
		217	`unreached_fall = 1 ;`
		218	`}`
		219	`}`
		220	`break;`
		221	`case 354:`
		222	`return;`
		223	`default:`
		224	`goto ZL1;`
		225	`}`
		226	`goto ZL0;`
		227	`ZL1:;`
		228	`SAVE_LEXER (354);`
		229	`return;`
		230	`ZL0:;`
		231	`*ZO404 = ZI404;`
		232	`}`
		233
		234	`void`
		235	`ZR1093 PROTO_Z ()`
		236	`{`
		237	`switch (CURRENT_TERMINAL) {`
		238	`case 77:`
		239	`{`
		240	`ADVANCE_LEXER;`
		241	`{`
		242
		243	`unreached_fall = 0 ;`
		244	`}`
		245	`}`
		246	`break;`
		247	`default:`
		248	`{`
		249	`{`
		250
		251	`unreached_fall = 0 ;`
		252	`}`
		253	`}`
		254	`break;`
		255	`case 354:`
		256	`return;`
		257	`}`
		258	`}`
		259
		260	`void`
		261	`ZR635 PROTO_N ((ZO630))`
		262	`PROTO_T (CV_SPEC *ZO630)`
		263	`{`
		264	`CV_SPEC ZI630;`
		265
		266	`switch (CURRENT_TERMINAL) {`
		267	`case 98: case 124:`
		268	`{`
		269	`ZR632 (&ZI630);`
		270	`if ((CURRENT_TERMINAL) == 354) {`
		271	`RESTORE_LEXER;`
		272	`goto ZL1;`
		273	`}`
		274	`}`
		275	`break;`
		276	`default:`
		277	`{`
		278	`{`
		279	`(ZI630) = cv_none ;`
		280	`}`
		281	`}`
		282	`break;`
		283	`case 354:`
		284	`return;`
		285	`}`
		286	`goto ZL0;`
		287	`ZL1:;`
		288	`SAVE_LEXER (354);`
		289	`return;`
		290	`ZL0:;`
		291	`*ZO630 = ZI630;`
		292	`}`
		293
		294	`void`
		295	`ZR529 PROTO_Z ()`
		296	`{`
		297	`switch (CURRENT_TERMINAL) {`
		298	`case 222:`
		299	`{`
		300	`ADVANCE_LEXER;`
		301	`ZR1093 ();`
		302	`if ((CURRENT_TERMINAL) == 354) {`
		303	`RESTORE_LEXER;`
		304	`goto ZL1;`
		305	`}`
		306	`}`
		307	`break;`
		308	`case 354:`
		309	`return;`
		310	`default:`
		311	`break;`
		312	`}`
		313	`return;`
		314	`ZL1:;`
		315	`SAVE_LEXER (354);`
		316	`return;`
		317	`}`
		318
		319	`void`
		320	`ZR631 PROTO_N ((ZO630))`
		321	`PROTO_T (CV_SPEC *ZO630)`
		322	`{`
		323	`CV_SPEC ZI630;`
		324
		325	`switch (CURRENT_TERMINAL) {`
		326	`case 98:`
		327	`{`
		328	`ADVANCE_LEXER;`
		329	`{`
		330	`(ZI630) = cv_const ;`
		331	`}`
		332	`}`
		333	`break;`
		334	`case 124:`
		335	`{`
		336	`ADVANCE_LEXER;`
		337	`{`
		338	`(ZI630) = cv_volatile ;`
		339	`}`
		340	`}`
		341	`break;`
		342	`case 354:`
		343	`return;`
		344	`default:`
		345	`goto ZL1;`
		346	`}`
		347	`goto ZL0;`
		348	`ZL1:;`
		349	`SAVE_LEXER (354);`
		350	`return;`
		351	`ZL0:;`
		352	`*ZO630 = ZI630;`
		353	`}`
		354
		355	`void`
		356	`ZR469 PROTO_Z ()`
		357	`{`
		358	`switch (CURRENT_TERMINAL) {`
		359	`case 85:`
		360	`{`
		361	`ADVANCE_LEXER;`
		362	`}`
		363	`break;`
		364	`case 59:`
		365	`{`
		366	`ADVANCE_LEXER;`
		367	`}`
		368	`break;`
		369	`case 69:`
		370	`{`
		371	`ADVANCE_LEXER;`
		372	`}`
		373	`break;`
		374	`case 43:`
		375	`{`
		376	`{`
		377	`{`
		378	`switch (CURRENT_TERMINAL) {`
		379	`case 43:`
		380	`break;`
		381	`default:`
		382	`goto ZL1;`
		383	`}`
		384	`ADVANCE_LEXER;`
		385	`}`
		386	`}`
		387	`}`
		388	`break;`
		389	`case 354:`
		390	`return;`
		391	`default:`
		392	`goto ZL1;`
		393	`}`
		394	`return;`
		395	`ZL1:;`
		396	`SAVE_LEXER (354);`
		397	`return;`
		398	`}`
		399
		400	`void`
		401	`ZR824 PROTO_N ((ZI420, ZI423))`
		402	`PROTO_T (TYPE ZI420 X BASE_TYPE ZI423)`
		403	`{`
		404	`switch (CURRENT_TERMINAL) {`
		405	`case 65:`
		406	`{`
		407	`TYPE ZI1038;`
		408	`IDENTIFIER ZI1039;`
		409	`TYPE ZI1035;`
		410	`IDENTIFIER ZI399;`
		411	`TYPE ZI395;`
		412
		413	`ADVANCE_LEXER;`
		414	`ZR742 (&ZI1038, &ZI1039);`
		415	`if ((CURRENT_TERMINAL) == 354) {`
		416	`RESTORE_LEXER;`
		417	`goto ZL1;`
		418	`}`
		419	`{`
		420
		421	`if ( IS_NULL_type ( (ZI1038) ) ) {`
		422	`report ( crt_loc, ERR_dcl_meaning_paren () ) ;`
		423	`}`
		424	`}`
		425	`switch (CURRENT_TERMINAL) {`
		426	`case 39:`
		427	`break;`
		428	`default:`
		429	`goto ZL1;`
		430	`}`
		431	`ADVANCE_LEXER;`
		432	`ZR868 (ZI1038, ZI1039, &ZI1035, &ZI399);`
		433	`if ((CURRENT_TERMINAL) == 354) {`
		434	`RESTORE_LEXER;`
		435	`goto ZL1;`
		436	`}`
		437	`{`
		438
		439	`(ZI395) = ( IS_NULL_type ( (ZI1035) ) ? (ZI420) : inject_pre_type ( (ZI1035), (ZI420), 1 ) ) ;`
		440	`}`
		441	`{`
		442
		443	`IDENTIFIER id = make_member_decl ( dspec_none, (ZI395), (ZI399), 0 ) ;`
		444	`if ( do_dump ) dump_declare ( id, &decl_loc, 0 ) ;`
		445	`have_type_declaration = TYPE_DECL_NONE ;`
		446	`have_func_declarator = 0 ;`
		447	`}`
		448	`}`
		449	`break;`
		450	`case 1: case 2: case 4:`
		451	`{`
		452	`IDENTIFIER ZI1042;`
		453
		454	`{`
		455	`switch (CURRENT_TERMINAL) {`
		456	`case 1:`
		457	`{`
		458	`{`
		459
		460	`ZI1042 = crt_token->pp_data.id.use ;`
		461	`}`
		462	`ADVANCE_LEXER;`
		463	`}`
		464	`break;`
		465	`case 4:`
		466	`{`
		467	`{`
		468
		469	`ZI1042 = crt_token->pp_data.id.use ;`
		470	`}`
		471	`ADVANCE_LEXER;`
		472	`}`
		473	`break;`
		474	`case 2:`
		475	`{`
		476	`{`
		477
		478	`ZI1042 = crt_token->pp_data.id.use ;`
		479	`}`
		480	`ADVANCE_LEXER;`
		481	`}`
		482	`break;`
		483	`default:`
		484	`goto ZL1;`
		485	`}`
		486	`}`
		487	`ZR1043 (&ZI420, &ZI423, &ZI1042);`
		488	`if ((CURRENT_TERMINAL) == 354) {`
		489	`RESTORE_LEXER;`
		490	`goto ZL1;`
		491	`}`
		492	`}`
		493	`break;`
		494	`case 78:`
		495	`{`
		496	`TYPE ZI1036;`
		497	`TYPE ZI1037;`
		498	`IDENTIFIER ZI399;`
		499	`TYPE ZI1035;`
		500	`TYPE ZI395;`
		501
		502	`ZR731 (&ZI1036);`
		503	`ZR742 (&ZI1037, &ZI399);`
		504	`if ((CURRENT_TERMINAL) == 354) {`
		505	`RESTORE_LEXER;`
		506	`goto ZL1;`
		507	`}`
		508	`{`
		509
		510	`(ZI1035) = ( IS_NULL_type ( (ZI1037) ) ? (ZI1036) : inject_pre_type ( (ZI1037), (ZI1036), 0 ) ) ;`
		511	`}`
		512	`{`
		513
		514	`(ZI395) = ( IS_NULL_type ( (ZI1035) ) ? (ZI420) : inject_pre_type ( (ZI1035), (ZI420), 1 ) ) ;`
		515	`}`
		516	`{`
		517
		518	`IDENTIFIER id = make_member_decl ( dspec_none, (ZI395), (ZI399), 0 ) ;`
		519	`if ( do_dump ) dump_declare ( id, &decl_loc, 0 ) ;`
		520	`have_type_declaration = TYPE_DECL_NONE ;`
		521	`have_func_declarator = 0 ;`
		522	`}`
		523	`}`
		524	`break;`
		525	`case 41:`
		526	`{`
		527	`IDENTIFIER ZI399;`
		528	`EXP ZI467;`
		529	`TYPE ZI395;`
		530
		531	`{`
		532
		533	`HASHID nm = lookup_anon () ;`
		534	`(ZI399) = DEREF_id ( hashid_id ( nm ) ) ;`
		535	`}`
		536	`{`
		537
		538	`IDENTIFIER pid = underlying_id ( (ZI399) ) ;`
		539	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		540	`}`
		541	`ADVANCE_LEXER;`
		542	`ZR518 (&ZI467);`
		543	`if ((CURRENT_TERMINAL) == 354) {`
		544	`RESTORE_LEXER;`
		545	`goto ZL1;`
		546	`}`
		547	`{`
		548
		549	`/* Check for anonymous bitfields */`
		550	`HASHID nm = DEREF_hashid ( id_name ( (ZI399) ) ) ;`
		551	`int z = IS_hashid_anon ( nm ) ;`
		552	`(ZI395) = make_bitfield_type ( (ZI420), (ZI423), (ZI467), z ) ;`
		553	`}`
		554	`{`
		555
		556	`IDENTIFIER id = make_member_decl ( dspec_none, (ZI395), (ZI399), 0 ) ;`
		557	`if ( do_dump ) dump_declare ( id, &decl_loc, 0 ) ;`
		558	`have_type_declaration = TYPE_DECL_NONE ;`
		559	`have_func_declarator = 0 ;`
		560	`}`
		561	`}`
		562	`break;`
		563	`case 354:`
		564	`return;`
		565	`default:`
		566	`goto ZL1;`
		567	`}`
		568	`return;`
		569	`ZL1:;`
		570	`SAVE_LEXER (354);`
		571	`return;`
		572	`}`
		573
		574	`void`
		575	`ZR788 PROTO_N ((ZI547, ZO404))`
		576	`PROTO_T (IDENTIFIER ZI547 X EXP *ZO404)`
		577	`{`
		578	`EXP ZI404;`
		579
		580	`switch (CURRENT_TERMINAL) {`
		581	`case 1: case 17: case 18: case 19: case 20:`
		582	`case 21: case 22: case 23: case 33: case 43:`
		583	`case 59: case 61: case 62: case 65: case 69:`
		584	`case 71: case 78: case 85: case 116: case 170:`
		585	`case 205: case 209:`
		586	`{`
		587	`ZR516 (&ZI404);`
		588	`if ((CURRENT_TERMINAL) == 354) {`
		589	`RESTORE_LEXER;`
		590	`goto ZL1;`
		591	`}`
		592	`}`
		593	`break;`
		594	`case 64:`
		595	`{`
		596	`SID_LIST_EXP ZI420;`
		597
		598	`{`
		599	`{`
		600	`switch (CURRENT_TERMINAL) {`
		601	`case 64:`
		602	`break;`
		603	`default:`
		604	`goto ZL1;`
		605	`}`
		606	`ADVANCE_LEXER;`
		607	`}`
		608	`}`
		609	`ZR1072 (&ZI547, &ZI420);`
		610	`{`
		611	`if ((CURRENT_TERMINAL) == 354) {`
		612	`RESTORE_LEXER;`
		613	`goto ZL1;`
		614	`}`
		615	`{`
		616	`switch (CURRENT_TERMINAL) {`
		617	`case 38:`
		618	`break;`
		619	`default:`
		620	`goto ZL1;`
		621	`}`
		622	`ADVANCE_LEXER;`
		623	`}`
		624	`}`
		625	`{`
		626
		627	`/* The expression type is a dummy */`
		628	`MAKE_exp_aggregate ( type_void, (ZI420), NULL_list ( OFFSET ), (ZI404) ) ;`
		629	`}`
		630	`}`
		631	`break;`
		632	`case 354:`
		633	`return;`
		634	`default:`
		635	`goto ZL1;`
		636	`}`
		637	`goto ZL0;`
		638	`ZL1:;`
		639	`SAVE_LEXER (354);`
		640	`return;`
		641	`ZL0:;`
		642	`*ZO404 = ZI404;`
		643	`}`
		644
		645	`void`
		646	`ZR479 PROTO_N ((ZO913))`
		647	`PROTO_T (EXP *ZO913)`
		648	`{`
		649	`EXP ZI913;`
		650
		651	`if ((CURRENT_TERMINAL) == 354) {`
		652	`return;`
		653	`}`
		654	`{`
		655	`EXP ZI404;`
		656
		657	`ZR476 (&ZI404);`
		658	`ZR914 (ZI404, &ZI913);`
		659	`if ((CURRENT_TERMINAL) == 354) {`
		660	`RESTORE_LEXER;`
		661	`goto ZL1;`
		662	`}`
		663	`}`
		664	`goto ZL0;`
		665	`ZL1:;`
		666	`SAVE_LEXER (354);`
		667	`return;`
		668	`ZL0:;`
		669	`*ZO913 = ZI913;`
		670	`}`
		671
		672	`void`
		673	`ZR751 PROTO_N ((ZO866, ZO867))`
		674	`PROTO_T (TYPE ZO866 X IDENTIFIER ZO867)`
		675	`{`
		676	`TYPE ZI866;`
		677	`IDENTIFIER ZI867;`
		678
		679	`switch (CURRENT_TERMINAL) {`
		680	`case 65:`
		681	`{`
		682	`TYPE ZI395;`
		683	`IDENTIFIER ZI399;`
		684
		685	`ADVANCE_LEXER;`
		686	`ZR742 (&ZI395, &ZI399);`
		687	`if ((CURRENT_TERMINAL) == 354) {`
		688	`RESTORE_LEXER;`
		689	`goto ZL1;`
		690	`}`
		691	`{`
		692
		693	`if ( IS_NULL_type ( (ZI395) ) ) {`
		694	`report ( crt_loc, ERR_dcl_meaning_paren () ) ;`
		695	`}`
		696	`}`
		697	`switch (CURRENT_TERMINAL) {`
		698	`case 39:`
		699	`break;`
		700	`default:`
		701	`goto ZL1;`
		702	`}`
		703	`ADVANCE_LEXER;`
		704	`ZR868 (ZI395, ZI399, &ZI866, &ZI867);`
		705	`if ((CURRENT_TERMINAL) == 354) {`
		706	`RESTORE_LEXER;`
		707	`goto ZL1;`
		708	`}`
		709	`}`
		710	`break;`
		711	`case 1: case 2: case 4:`
		712	`{`
		713	`IDENTIFIER ZI399;`
		714	`TYPE ZI395;`
		715
		716	`{`
		717	`switch (CURRENT_TERMINAL) {`
		718	`case 1:`
		719	`{`
		720	`{`
		721
		722	`ZI399 = crt_token->pp_data.id.use ;`
		723	`}`
		724	`ADVANCE_LEXER;`
		725	`}`
		726	`break;`
		727	`case 4:`
		728	`{`
		729	`{`
		730
		731	`ZI399 = crt_token->pp_data.id.use ;`
		732	`}`
		733	`ADVANCE_LEXER;`
		734	`}`
		735	`break;`
		736	`case 2:`
		737	`{`
		738	`{`
		739
		740	`ZI399 = crt_token->pp_data.id.use ;`
		741	`}`
		742	`ADVANCE_LEXER;`
		743	`}`
		744	`break;`
		745	`default:`
		746	`goto ZL1;`
		747	`}`
		748	`}`
		749	`{`
		750
		751	`(ZI395) = NULL_type ;`
		752	`}`
		753	`{`
		754
		755	`IDENTIFIER pid = underlying_id ( (ZI399) ) ;`
		756	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		757	`}`
		758	`ZR868 (ZI395, ZI399, &ZI866, &ZI867);`
		759	`if ((CURRENT_TERMINAL) == 354) {`
		760	`RESTORE_LEXER;`
		761	`goto ZL1;`
		762	`}`
		763	`}`
		764	`break;`
		765	`case 354:`
		766	`return;`
		767	`default:`
		768	`goto ZL1;`
		769	`}`
		770	`goto ZL0;`
		771	`ZL1:;`
		772	`SAVE_LEXER (354);`
		773	`return;`
		774	`ZL0:;`
		775	`*ZO866 = ZI866;`
		776	`*ZO867 = ZI867;`
		777	`}`
		778
		779	`void`
		780	`ZR580 PROTO_N ((ZO404))`
		781	`PROTO_T (EXP *ZO404)`
		782	`{`
		783	`EXP ZI404;`
		784
		785	`switch (CURRENT_TERMINAL) {`
		786	`case 109:`
		787	`{`
		788	`unsigned ZI581;`
		789	`int ZI537;`
		790	`EXP ZI467;`
		791	`EXP ZI416;`
		792	`EXP ZI582;`
		793	`EXP ZI448;`
		794	`EXP ZI547;`
		795	`EXP ZI585;`
		796
		797	`ADVANCE_LEXER;`
		798	`{`
		799	`(ZI581) = crt_condition ;`
		800	`}`
		801	`{`
		802
		803	`(ZI537) = unreached_code ;`
		804	`if ( (ZI537) ) {`
		805	`if ( !unreached_last ) {`
		806	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		807	`unreached_last = 1 ;`
		808	`}`
		809	`} else {`
		810	`unreached_last = 0 ;`
		811	`}`
		812	`}`
		813	`ZR394 ();`
		814	`ZR414 (&ZI467);`
		815	`if ((CURRENT_TERMINAL) == 354) {`
		816	`RESTORE_LEXER;`
		817	`goto ZL1;`
		818	`}`
		819	`{`
		820
		821	`(ZI416) = begin_if_stmt ( (ZI467) ) ;`
		822	`}`
		823	`switch (CURRENT_TERMINAL) {`
		824	`case 39:`
		825	`break;`
		826	`default:`
		827	`goto ZL1;`
		828	`}`
		829	`ADVANCE_LEXER;`
		830	`{`
		831
		832	`(ZI582) = begin_compound_stmt ( 1 ) ;`
		833	`}`
		834	`ZR556 (ZI582, &ZI448);`
		835	`if ((CURRENT_TERMINAL) == 354) {`
		836	`RESTORE_LEXER;`
		837	`goto ZL1;`
		838	`}`
		839	`{`
		840	`unreached_prev = (ZI537) ;`
		841	`}`
		842	`{`
		843
		844	`(ZI547) = cont_if_stmt ( (ZI416), (ZI448) ) ;`
		845	`}`
		846	`{`
		847	`{`
		848	`EXP ZI584;`
		849
		850	`switch (CURRENT_TERMINAL) {`
		851	`case 103:`
		852	`break;`
		853	`default:`
		854	`goto ZL3;`
		855	`}`
		856	`ADVANCE_LEXER;`
		857	`{`
		858
		859	`check_empty_stmt ( lex_else ) ;`
		860	`}`
		861	`{`
		862
		863	`(ZI584) = begin_compound_stmt ( 1 ) ;`
		864	`}`
		865	`ZR556 (ZI584, &ZI585);`
		866	`if ((CURRENT_TERMINAL) == 354) {`
		867	`RESTORE_LEXER;`
		868	`goto ZL3;`
		869	`}`
		870	`}`
		871	`goto ZL2;`
		872	`ZL3:;`
		873	`{`
		874	`{`
		875
		876	`report ( crt_loc, ERR_stmt_if_no_else () ) ;`
		877	`(ZI585) = NULL_exp ;`
		878	`}`
		879	`}`
		880	`ZL2:;`
		881	`}`
		882	`{`
		883	`unreached_prev = (ZI537) ;`
		884	`}`
		885	`{`
		886
		887	`(ZI404) = end_if_stmt ( (ZI547), (ZI585) ) ;`
		888	`}`
		889	`{`
		890	`crt_condition = (ZI581) ;`
		891	`}`
		892	`{`
		893
		894	`unreached_fall = 1 ;`
		895	`}`
		896	`}`
		897	`break;`
		898	`case 119:`
		899	`{`
		900	`int ZI537;`
		901	`EXP ZI467;`
		902	`EXP ZI416;`
		903	`int ZI587;`
		904	`EXP ZI582;`
		905	`EXP ZI448;`
		906
		907	`ADVANCE_LEXER;`
		908	`{`
		909
		910	`(ZI537) = unreached_code ;`
		911	`if ( (ZI537) ) {`
		912	`if ( !unreached_last ) {`
		913	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		914	`unreached_last = 1 ;`
		915	`}`
		916	`} else {`
		917	`unreached_last = 0 ;`
		918	`}`
		919	`}`
		920	`switch (CURRENT_TERMINAL) {`
		921	`case 65:`
		922	`break;`
		923	`default:`
		924	`goto ZL1;`
		925	`}`
		926	`ADVANCE_LEXER;`
		927	`ZR414 (&ZI467);`
		928	`if ((CURRENT_TERMINAL) == 354) {`
		929	`RESTORE_LEXER;`
		930	`goto ZL1;`
		931	`}`
		932	`{`
		933
		934	`(ZI416) = begin_switch_stmt ( (ZI467) ) ;`
		935	`}`
		936	`switch (CURRENT_TERMINAL) {`
		937	`case 39:`
		938	`break;`
		939	`default:`
		940	`goto ZL1;`
		941	`}`
		942	`ADVANCE_LEXER;`
		943	`{`
		944	`switch (CURRENT_TERMINAL) {`
		945	`case 216:`
		946	`{`
		947	`ADVANCE_LEXER;`
		948	`{`
		949	`(ZI587) = 1 ;`
		950	`}`
		951	`}`
		952	`break;`
		953	`default:`
		954	`{`
		955	`{`
		956	`(ZI587) = 0 ;`
		957	`}`
		958	`}`
		959	`break;`
		960	`}`
		961	`}`
		962	`{`
		963
		964	`(ZI582) = begin_compound_stmt ( 1 ) ;`
		965	`}`
		966	`ZR556 (ZI582, &ZI448);`
		967	`if ((CURRENT_TERMINAL) == 354) {`
		968	`RESTORE_LEXER;`
		969	`goto ZL1;`
		970	`}`
		971	`{`
		972	`unreached_prev = (ZI537) ;`
		973	`}`
		974	`{`
		975
		976	`(ZI404) = end_switch_stmt ( (ZI416), (ZI448), (ZI587) ) ;`
		977	`}`
		978	`{`
		979
		980	`unreached_fall = 1 ;`
		981	`}`
		982	`}`
		983	`break;`
		984	`case 26:`
		985	`{`
		986	`ZR569 (&ZI404);`
		987	`if ((CURRENT_TERMINAL) == 354) {`
		988	`RESTORE_LEXER;`
		989	`goto ZL1;`
		990	`}`
		991	`{`
		992
		993	`unreached_fall = 1 ;`
		994	`}`
		995	`}`
		996	`break;`
		997	`case 354:`
		998	`return;`
		999	`default:`
		1000	`goto ZL1;`
		1001	`}`
		1002	`goto ZL0;`
		1003	`ZL1:;`
		1004	`SAVE_LEXER (354);`
		1005	`return;`
		1006	`ZL0:;`
		1007	`*ZO404 = ZI404;`
		1008	`}`
		1009
		1010	`void`
		1011	`ZR414 PROTO_N ((ZO404))`
		1012	`PROTO_T (EXP *ZO404)`
		1013	`{`
		1014	`EXP ZI404;`
		1015
		1016	`switch (CURRENT_TERMINAL) {`
		1017	`case 1: case 17: case 18: case 19: case 20:`
		1018	`case 21: case 22: case 23: case 33: case 43:`
		1019	`case 59: case 61: case 62: case 65: case 69:`
		1020	`case 71: case 78: case 85: case 116: case 170:`
		1021	`case 205: case 209:`
		1022	`{`
		1023	`EXP ZI1025;`
		1024
		1025	`ZR419 (&ZI1025);`
		1026	`ZR1027 (&ZI1025, &ZI404);`
		1027	`if ((CURRENT_TERMINAL) == 354) {`
		1028	`RESTORE_LEXER;`
		1029	`goto ZL1;`
		1030	`}`
		1031	`}`
		1032	`break;`
		1033	`case 297: case 323:`
		1034	`{`
		1035	`EXP ZI416;`
		1036	`SID_LIST_EXP ZI423;`
		1037	`SID_LIST_EXP ZI420;`
		1038
		1039	`ZR510 (&ZI416);`
		1040	`ZR515 (&ZI423);`
		1041	`if ((CURRENT_TERMINAL) == 354) {`
		1042	`RESTORE_LEXER;`
		1043	`goto ZL1;`
		1044	`}`
		1045	`{`
		1046
		1047	`CONS_exp ( (ZI416), (ZI423), (ZI420) ) ;`
		1048	`}`
		1049	`{`
		1050
		1051	`(ZI404) = make_comma_exp ( (ZI420) ) ;`
		1052	`}`
		1053	`}`
		1054	`break;`
		1055	`case 345:`
		1056	`{`
		1057	`EXP ZI416;`
		1058	`SID_LIST_EXP ZI423;`
		1059	`SID_LIST_EXP ZI420;`
		1060
		1061	`ZR511 (&ZI416);`
		1062	`ZR515 (&ZI423);`
		1063	`if ((CURRENT_TERMINAL) == 354) {`
		1064	`RESTORE_LEXER;`
		1065	`goto ZL1;`
		1066	`}`
		1067	`{`
		1068
		1069	`CONS_exp ( (ZI416), (ZI423), (ZI420) ) ;`
		1070	`}`
		1071	`{`
		1072
		1073	`(ZI404) = make_comma_exp ( (ZI420) ) ;`
		1074	`}`
		1075	`}`
		1076	`break;`
		1077	`case 354:`
		1078	`return;`
		1079	`default:`
		1080	`goto ZL1;`
		1081	`}`
		1082	`goto ZL0;`
		1083	`ZL1:;`
		1084	`SAVE_LEXER (354);`
		1085	`return;`
		1086	`ZL0:;`
		1087	`*ZO404 = ZI404;`
		1088	`}`
		1089
		1090	`void`
		1091	`ZR548 PROTO_N ((ZI467, ZI547, ZO404))`
		1092	`PROTO_T (EXP ZI467 X int ZI547 X EXP *ZO404)`
		1093	`{`
		1094	`EXP ZI404;`
		1095
		1096	`if ((CURRENT_TERMINAL) == 354) {`
		1097	`return;`
		1098	`}`
		1099	`ZL2_548:;`
		1100	`{`
		1101	`EXP ZI416;`
		1102	`EXP ZI448;`
		1103
		1104	`{`
		1105
		1106	`/* Resolve declaration-statements from expression-statements */`
		1107	`int b = predict_decl () ;`
		1108	`if ( b ) {`
		1109	`if ( !(ZI547) ) report ( crt_loc, ERR_stmt_dcl_start () ) ;`
		1110	`in_declaration++ ;`
		1111	`}`
		1112	`(ZI0) = b ;`
		1113	`}`
		1114	`if (!ZI0)`
		1115	`goto ZL3;`
		1116	`ZR559 ();`
		1117	`if ((CURRENT_TERMINAL) == 354) {`
		1118	`RESTORE_LEXER;`
		1119	`goto ZL1;`
		1120	`}`
		1121	`{`
		1122
		1123	`in_declaration-- ;`
		1124	`(ZI416) = NULL_exp ;`
		1125	`}`
		1126	`{`
		1127
		1128	`unreached_fall = 1 ;`
		1129	`}`
		1130	`{`
		1131
		1132	`(ZI448) = add_compound_stmt ( (ZI467), (ZI416) ) ;`
		1133	`}`
		1134	`ZI467 = ZI448;`
		1135	`goto ZL2_548;`
		1136	`}`
		1137	`/UNREACHED/`
		1138	`ZL3:;`
		1139	`switch (CURRENT_TERMINAL) {`
		1140	`case 1: case 2: case 4: case 17: case 18:`
		1141	`case 19: case 20: case 21: case 22: case 23:`
		1142	`case 24: case 26: case 33: case 43: case 59:`
		1143	`case 61: case 62: case 64: case 65: case 69:`
		1144	`case 71: case 77: case 78: case 85: case 95:`
		1145	`case 96: case 99: case 100: case 101: case 107:`
		1146	`case 108: case 109: case 113: case 116: case 119:`
		1147	`case 125: case 126: case 170: case 205: case 209:`
		1148	`case 222: case 288: case 297: case 322: case 323:`
		1149	`case 345:`
		1150	`{`
		1151	`EXP ZI416;`
		1152	`EXP ZI448;`
		1153	`int ZI549;`
		1154
		1155	`ZR528 (&ZI416);`
		1156	`if ((CURRENT_TERMINAL) == 354) {`
		1157	`RESTORE_LEXER;`
		1158	`goto ZL1;`
		1159	`}`
		1160	`{`
		1161
		1162	`(ZI448) = add_compound_stmt ( (ZI467), (ZI416) ) ;`
		1163	`}`
		1164	`{`
		1165	`(ZI549) = 0 ;`
		1166	`}`
		1167	`ZI467 = ZI448;`
		1168	`ZI547 = ZI549;`
		1169	`goto ZL2_548;`
		1170	`}`
		1171	`/UNREACHED/`
		1172	`default:`
		1173	`{`
		1174	`ZI404 = ZI467;`
		1175	`}`
		1176	`break;`
		1177	`}`
		1178	`goto ZL0;`
		1179	`ZL1:;`
		1180	`SAVE_LEXER (354);`
		1181	`return;`
		1182	`ZL0:;`
		1183	`*ZO404 = ZI404;`
		1184	`}`
		1185
		1186	`void`
		1187	`ZR724 PROTO_N ((ZI688, ZI689, ZI690, ZI716, ZO658, ZO395, ZO630, ZO605))`
		1188	`PROTO_T (BASE_TYPE ZI688 X TYPE ZI689 X CV_SPEC ZI690 X DECL_SPEC ZI716 X BASE_TYPE ZO658 X TYPE ZO395 X CV_SPEC ZO630 X DECL_SPEC ZO605)`
		1189	`{`
		1190	`BASE_TYPE ZI658;`
		1191	`TYPE ZI395;`
		1192	`CV_SPEC ZI630;`
		1193	`DECL_SPEC ZI605;`
		1194
		1195	`if ((CURRENT_TERMINAL) == 354) {`
		1196	`return;`
		1197	`}`
		1198	`{`
		1199	`BASE_TYPE ZI1096;`
		1200	`TYPE ZI1097;`
		1201	`CV_SPEC ZI1098;`
		1202	`DECL_SPEC ZI1099;`
		1203	`BASE_TYPE ZI692;`
		1204	`TYPE ZI693;`
		1205	`CV_SPEC ZI694;`
		1206	`DECL_SPEC ZI718;`
		1207
		1208	`{`
		1209
		1210	`/* Resolve declaration-specifiers from other declarators */`
		1211	`(ZI0) = predict_dspec ( 0 ) ;`
		1212	`}`
		1213	`if (!ZI0)`
		1214	`goto ZL2;`
		1215	`ZR714 (&ZI1096, &ZI1097, &ZI1098, &ZI1099);`
		1216	`if ((CURRENT_TERMINAL) == 354) {`
		1217	`RESTORE_LEXER;`
		1218	`goto ZL1;`
		1219	`}`
		1220	`{`
		1221
		1222	`/* A type-name can be a declarator-id */`
		1223	`if ( have_type_specifier && crt_lex_token == lex_type_Hname ) {`
		1224	`crt_lex_token = lex_identifier ;`
		1225	`}`
		1226	`}`
		1227	`ZR724 (&ZI1096, &ZI1097, &ZI1098, &ZI1099, &ZI692, &ZI693, &ZI694, &ZI718);`
		1228	`if ((CURRENT_TERMINAL) == 354) {`
		1229	`RESTORE_LEXER;`
		1230	`goto ZL1;`
		1231	`}`
		1232	`{`
		1233
		1234	`if ( (*ZI688) & (ZI692) ) {`
		1235	`(ZI658) = join_pre_types ( (*ZI688), (ZI692) ) ;`
		1236	`} else {`
		1237	`(ZI658) = ( (*ZI688) \| (ZI692) ) ;`
		1238	`}`
		1239	`}`
		1240	`{`
		1241
		1242	`/* Join two partial types */`
		1243	`if ( IS_NULL_type ( (*ZI689) ) ) {`
		1244	`(ZI395) = (ZI693) ;`
		1245	`} else if ( IS_NULL_type ( (ZI693) ) ) {`
		1246	`(ZI395) = (*ZI689) ;`
		1247	`} else {`
		1248	`report ( crt_loc, ERR_dcl_type_simple_many ( (*ZI689), (ZI693) ) ) ;`
		1249	`(ZI395) = (ZI693) ;`
		1250	`}`
		1251	`}`
		1252	`{`
		1253
		1254	`CV_SPEC c = ( (*ZI690) & (ZI694) ) ;`
		1255	`if ( c ) report ( crt_loc, ERR_dcl_type_cv_dup ( c ) ) ;`
		1256	`(ZI630) = ( (*ZI690) \| (ZI694) ) ;`
		1257	`}`
		1258	`{`
		1259
		1260	`/* Combine two declaration specifiers */`
		1261	`DECL_SPEC d = ( ( (*ZI716) & (ZI718) ) & dspec_duplicate ) ;`
		1262	`if ( d ) report ( crt_loc, ERR_dcl_spec_dup ( d ) ) ;`
		1263	`(ZI605) = ( (*ZI716) \| (ZI718) ) ;`
		1264	`}`
		1265	`goto ZL0;`
		1266	`}`
		1267	`/UNREACHED/`
		1268	`ZL2:;`
		1269	`switch (CURRENT_TERMINAL) {`
		1270	`default:`
		1271	`{`
		1272	`ZI658 = *ZI688;`
		1273	`ZI395 = *ZI689;`
		1274	`ZI630 = *ZI690;`
		1275	`ZI605 = *ZI716;`
		1276	`}`
		1277	`break;`
		1278	`}`
		1279	`goto ZL0;`
		1280	`ZL1:;`
		1281	`SAVE_LEXER (354);`
		1282	`return;`
		1283	`ZL0:;`
		1284	`*ZO658 = ZI658;`
		1285	`*ZO395 = ZI395;`
		1286	`*ZO630 = ZI630;`
		1287	`*ZO605 = ZI605;`
		1288	`}`
		1289
		1290	`void`
		1291	`ZR555 PROTO_N ((ZI467, ZO404))`
		1292	`PROTO_T (EXP ZI467 X EXP *ZO404)`
		1293	`{`
		1294	`EXP ZI404;`
		1295
		1296	`switch (CURRENT_TERMINAL) {`
		1297	`case 64:`
		1298	`{`
		1299	`int ZI547;`
		1300
		1301	`{`
		1302	`{`
		1303	`switch (CURRENT_TERMINAL) {`
		1304	`case 64:`
		1305	`break;`
		1306	`default:`
		1307	`goto ZL1;`
		1308	`}`
		1309	`ADVANCE_LEXER;`
		1310	`}`
		1311	`}`
		1312	`{`
		1313
		1314	`COPY_int ( exp_sequence_block ( (ZI467) ), 2 ) ;`
		1315	`(ZI547) = 1 ;`
		1316	`}`
		1317	`ZR548 (ZI467, ZI547, &ZI404);`
		1318	`{`
		1319	`if ((CURRENT_TERMINAL) == 354) {`
		1320	`RESTORE_LEXER;`
		1321	`goto ZL1;`
		1322	`}`
		1323	`{`
		1324	`switch (CURRENT_TERMINAL) {`
		1325	`case 38:`
		1326	`break;`
		1327	`default:`
		1328	`goto ZL1;`
		1329	`}`
		1330	`ADVANCE_LEXER;`
		1331	`}`
		1332	`}`
		1333	`}`
		1334	`break;`
		1335	`case 1: case 2: case 4: case 17: case 18:`
		1336	`case 19: case 20: case 21: case 22: case 23:`
		1337	`case 24: case 26: case 33: case 43: case 59:`
		1338	`case 61: case 62: case 65: case 69: case 71:`
		1339	`case 77: case 78: case 85: case 95: case 96:`
		1340	`case 99: case 100: case 101: case 107: case 108:`
		1341	`case 109: case 113: case 116: case 119: case 125:`
		1342	`case 126: case 170: case 205: case 209: case 222:`
		1343	`case 288: case 297: case 322: case 323: case 345:`
		1344	`{`
		1345	`EXP ZI416;`
		1346
		1347	`ZR554 (&ZI416);`
		1348	`if ((CURRENT_TERMINAL) == 354) {`
		1349	`RESTORE_LEXER;`
		1350	`goto ZL1;`
		1351	`}`
		1352	`{`
		1353
		1354	`(ZI404) = add_compound_stmt ( (ZI467), (ZI416) ) ;`
		1355	`}`
		1356	`}`
		1357	`break;`
		1358	`case 354:`
		1359	`return;`
		1360	`default:`
		1361	`goto ZL1;`
		1362	`}`
		1363	`goto ZL0;`
		1364	`ZL1:;`
		1365	`SAVE_LEXER (354);`
		1366	`return;`
		1367	`ZL0:;`
		1368	`*ZO404 = ZI404;`
		1369	`}`
		1370
		1371	`void`
		1372	`ZR528 PROTO_N ((ZO404))`
		1373	`PROTO_T (EXP *ZO404)`
		1374	`{`
		1375	`EXP ZI404;`
		1376
		1377	`switch (CURRENT_TERMINAL) {`
		1378	`case 64:`
		1379	`{`
		1380	`ZR551 (&ZI404);`
		1381	`if ((CURRENT_TERMINAL) == 354) {`
		1382	`RESTORE_LEXER;`
		1383	`goto ZL1;`
		1384	`}`
		1385	`}`
		1386	`break;`
		1387	`case 1: case 2: case 4: case 17: case 18:`
		1388	`case 19: case 20: case 21: case 22: case 23:`
		1389	`case 24: case 26: case 33: case 43: case 59:`
		1390	`case 61: case 62: case 65: case 69: case 71:`
		1391	`case 77: case 78: case 85: case 95: case 96:`
		1392	`case 99: case 100: case 101: case 107: case 108:`
		1393	`case 109: case 113: case 116: case 119: case 125:`
		1394	`case 126: case 170: case 205: case 209: case 222:`
		1395	`case 288: case 297: case 322: case 323: case 345:`
		1396	`{`
		1397	`ZR554 (&ZI404);`
		1398	`if ((CURRENT_TERMINAL) == 354) {`
		1399	`RESTORE_LEXER;`
		1400	`goto ZL1;`
		1401	`}`
		1402	`}`
		1403	`break;`
		1404	`case 354:`
		1405	`return;`
		1406	`default:`
		1407	`goto ZL1;`
		1408	`}`
		1409	`goto ZL0;`
		1410	`ZL1:;`
		1411	`SAVE_LEXER (354);`
		1412	`return;`
		1413	`ZL0:;`
		1414	`*ZO404 = ZI404;`
		1415	`}`
		1416
		1417	`void`
		1418	`ZR983 PROTO_N ((ZO404))`
		1419	`PROTO_T (EXP *ZO404)`
		1420	`{`
		1421	`EXP ZI404;`
		1422
		1423	`if ((CURRENT_TERMINAL) == 354) {`
		1424	`return;`
		1425	`}`
		1426	`{`
		1427	`TYPE ZI395;`
		1428	`int ZI472;`
		1429	`EXP ZI416;`
		1430	`EXP ZI961;`
		1431	`EXP ZI960;`
		1432	`EXP ZI959;`
		1433	`EXP ZI958;`
		1434	`EXP ZI957;`
		1435	`EXP ZI956;`
		1436	`EXP ZI955;`
		1437	`EXP ZI954;`
		1438	`EXP ZI953;`
		1439	`EXP ZI952;`
		1440	`EXP ZI951;`
		1441	`EXP ZI948;`
		1442
		1443	`{`
		1444
		1445	`/* Resolve type-ids from expressions */`
		1446	`(ZI0) = predict_typeid ( 0 ) ;`
		1447	`}`
		1448	`if (!ZI0)`
		1449	`goto ZL2;`
		1450	`ZR444 (&ZI395, &ZI472);`
		1451	`switch (CURRENT_TERMINAL) {`
		1452	`case 39:`
		1453	`break;`
		1454	`case 354:`
		1455	`RESTORE_LEXER;`
		1456	`goto ZL1;`
		1457	`default:`
		1458	`goto ZL1;`
		1459	`}`
		1460	`ADVANCE_LEXER;`
		1461	`ZR459 (&ZI416);`
		1462	`if ((CURRENT_TERMINAL) == 354) {`
		1463	`RESTORE_LEXER;`
		1464	`goto ZL1;`
		1465	`}`
		1466	`{`
		1467
		1468	`/* n is the number of type definitions in t */`
		1469	`(ZI961) = make_cast_exp ( (ZI395), (ZI416), (ZI472) ) ;`
		1470	`}`
		1471	`ZR918 (ZI961, &ZI960);`
		1472	`ZR914 (ZI960, &ZI959);`
		1473	`ZR910 (ZI959, &ZI958);`
		1474	`ZR906 (ZI958, &ZI957);`
		1475	`ZR902 (ZI957, &ZI956);`
		1476	`ZR898 (ZI956, &ZI955);`
		1477	`ZR894 (ZI955, &ZI954);`
		1478	`ZR890 (ZI954, &ZI953);`
		1479	`ZR886 (ZI953, &ZI952);`
		1480	`ZR882 (ZI952, &ZI951);`
		1481	`ZR878 (ZI951, &ZI948);`
		1482	`ZR950 (&ZI948, &ZI404);`
		1483	`if ((CURRENT_TERMINAL) == 354) {`
		1484	`RESTORE_LEXER;`
		1485	`goto ZL1;`
		1486	`}`
		1487	`goto ZL0;`
		1488	`}`
		1489	`/UNREACHED/`
		1490	`ZL2:;`
		1491	`switch (CURRENT_TERMINAL) {`
		1492	`case 1: case 17: case 18: case 19: case 20:`
		1493	`case 21: case 22: case 23: case 33: case 43:`
		1494	`case 59: case 61: case 62: case 65: case 69:`
		1495	`case 71: case 78: case 85: case 116: case 170:`
		1496	`case 205: case 209: case 297: case 323: case 345:`
		1497	`{`
		1498	`EXP ZI1021;`
		1499	`EXP ZI1022;`
		1500	`EXP ZI1023;`
		1501
		1502	`{`
		1503
		1504	`IGNORE incr_value ( OPT_VAL_paren_depth ) ;`
		1505	`}`
		1506	`ZR414 (&ZI1021);`
		1507	`if ((CURRENT_TERMINAL) == 354) {`
		1508	`RESTORE_LEXER;`
		1509	`goto ZL1;`
		1510	`}`
		1511	`{`
		1512
		1513	`(ZI1022) = make_paren_exp ( (ZI1021) ) ;`
		1514	`decr_value ( OPT_VAL_paren_depth ) ;`
		1515	`}`
		1516	`switch (CURRENT_TERMINAL) {`
		1517	`case 39:`
		1518	`break;`
		1519	`default:`
		1520	`goto ZL1;`
		1521	`}`
		1522	`ADVANCE_LEXER;`
		1523	`ZR922 (ZI1022, &ZI1023);`
		1524	`ZR1014 (&ZI1023, &ZI404);`
		1525	`if ((CURRENT_TERMINAL) == 354) {`
		1526	`RESTORE_LEXER;`
		1527	`goto ZL1;`
		1528	`}`
		1529	`}`
		1530	`break;`
		1531	`default:`
		1532	`goto ZL1;`
		1533	`}`
		1534	`goto ZL0;`
		1535	`ZL1:;`
		1536	`SAVE_LEXER (354);`
		1537	`return;`
		1538	`ZL0:;`
		1539	`*ZO404 = ZI404;`
		1540	`}`
		1541
		1542	`void`
		1543	`ZR856 PROTO_N ((ZI852, ZI853, ZO854, ZO855))`
		1544	`PROTO_T (TYPE ZI852 X IDENTIFIER ZI853 X TYPE ZO854 X IDENTIFIER ZO855)`
		1545	`{`
		1546	`TYPE ZI854;`
		1547	`IDENTIFIER ZI855;`
		1548
		1549	`ZL2_856:;`
		1550	`switch (CURRENT_TERMINAL) {`
		1551	`case 65: case 66: case 331:`
		1552	`{`
		1553	`IDENTIFIER ZI399;`
		1554	`TYPE ZI423;`
		1555	`TYPE ZI395;`
		1556
		1557	`ZI399 = ZI853;`
		1558	`ZR754 (&ZI423);`
		1559	`if ((CURRENT_TERMINAL) == 354) {`
		1560	`RESTORE_LEXER;`
		1561	`goto ZL1;`
		1562	`}`
		1563	`{`
		1564
		1565	`(ZI395) = ( IS_NULL_type ( (ZI852) ) ? (ZI423) : inject_pre_type ( (ZI852), (ZI423), 0 ) ) ;`
		1566	`}`
		1567	`ZI852 = ZI395;`
		1568	`ZI853 = ZI399;`
		1569	`goto ZL2_856;`
		1570	`}`
		1571	`/UNREACHED/`
		1572	`default:`
		1573	`{`
		1574	`ZI854 = ZI852;`
		1575	`ZI855 = ZI853;`
		1576	`}`
		1577	`break;`
		1578	`case 354:`
		1579	`return;`
		1580	`}`
		1581	`goto ZL0;`
		1582	`ZL1:;`
		1583	`SAVE_LEXER (354);`
		1584	`return;`
		1585	`ZL0:;`
		1586	`*ZO854 = ZI854;`
		1587	`*ZO855 = ZI855;`
		1588	`}`
		1589
		1590	`void`
		1591	`ZR759 PROTO_N ((ZO859))`
		1592	`PROTO_T (TYPE *ZO859)`
		1593	`{`
		1594	`TYPE ZI859;`
		1595
		1596	`switch (CURRENT_TERMINAL) {`
		1597	`case 65:`
		1598	`{`
		1599	`ADVANCE_LEXER;`
		1600	`ZR1060 (&ZI859);`
		1601	`if ((CURRENT_TERMINAL) == 354) {`
		1602	`RESTORE_LEXER;`
		1603	`goto ZL1;`
		1604	`}`
		1605	`}`
		1606	`break;`
		1607	`case 331:`
		1608	`{`
		1609	`IDENTIFIER ZI399;`
		1610	`int ZI747;`
		1611	`TYPE ZI395;`
		1612
		1613	`ADVANCE_LEXER;`
		1614	`switch (CURRENT_TERMINAL) {`
		1615	`case 65:`
		1616	`break;`
		1617	`default:`
		1618	`goto ZL1;`
		1619	`}`
		1620	`ADVANCE_LEXER;`
		1621	`{`
		1622
		1623	`(ZI399) = NULL_id ;`
		1624	`}`
		1625	`{`
		1626
		1627	`func_type_defn ( 0 ) ;`
		1628	`begin_param ( (ZI399) ) ;`
		1629	`have_type_declaration = TYPE_DECL_NONE ;`
		1630	`have_func_declarator = 0 ;`
		1631	`}`
		1632	`ZR758 (&ZI747);`
		1633	`if ((CURRENT_TERMINAL) == 354) {`
		1634	`RESTORE_LEXER;`
		1635	`goto ZL1;`
		1636	`}`
		1637	`{`
		1638
		1639	`(ZI395) = make_func_type ( NULL_type, ( (ZI747) \| FUNC_WEAK ), cv_c, empty_type_set ) ;`
		1640	`}`
		1641	`switch (CURRENT_TERMINAL) {`
		1642	`case 39:`
		1643	`break;`
		1644	`default:`
		1645	`goto ZL1;`
		1646	`}`
		1647	`ADVANCE_LEXER;`
		1648	`{`
		1649
		1650	`end_param () ;`
		1651	`have_type_declaration = TYPE_DECL_NONE ;`
		1652	`have_func_declarator = 1 ;`
		1653	`}`
		1654	`ZR860 (ZI395, &ZI859);`
		1655	`if ((CURRENT_TERMINAL) == 354) {`
		1656	`RESTORE_LEXER;`
		1657	`goto ZL1;`
		1658	`}`
		1659	`}`
		1660	`break;`
		1661	`case 66:`
		1662	`{`
		1663	`EXP ZI404;`
		1664	`TYPE ZI395;`
		1665
		1666	`{`
		1667	`{`
		1668	`switch (CURRENT_TERMINAL) {`
		1669	`case 66:`
		1670	`break;`
		1671	`default:`
		1672	`goto ZL1;`
		1673	`}`
		1674	`ADVANCE_LEXER;`
		1675	`}`
		1676	`}`
		1677	`ZR757 (&ZI404);`
		1678	`if ((CURRENT_TERMINAL) == 354) {`
		1679	`RESTORE_LEXER;`
		1680	`goto ZL1;`
		1681	`}`
		1682	`{`
		1683
		1684	`NAT n = make_array_dim ( (ZI404) ) ;`
		1685	`MAKE_type_array ( cv_none, NULL_type, n, (ZI395) ) ;`
		1686	`}`
		1687	`{`
		1688	`{`
		1689	`switch (CURRENT_TERMINAL) {`
		1690	`case 40:`
		1691	`break;`
		1692	`default:`
		1693	`goto ZL1;`
		1694	`}`
		1695	`ADVANCE_LEXER;`
		1696	`}`
		1697	`}`
		1698	`ZR860 (ZI395, &ZI859);`
		1699	`if ((CURRENT_TERMINAL) == 354) {`
		1700	`RESTORE_LEXER;`
		1701	`goto ZL1;`
		1702	`}`
		1703	`}`
		1704	`break;`
		1705	`case 354:`
		1706	`return;`
		1707	`default:`
		1708	`goto ZL1;`
		1709	`}`
		1710	`goto ZL0;`
		1711	`ZL1:;`
		1712	`SAVE_LEXER (354);`
		1713	`return;`
		1714	`ZL0:;`
		1715	`*ZO859 = ZI859;`
		1716	`}`
		1717
		1718	`void`
		1719	`ZR602 PROTO_N ((ZO404))`
		1720	`PROTO_T (EXP *ZO404)`
		1721	`{`
		1722	`EXP ZI404;`
		1723
		1724	`switch (CURRENT_TERMINAL) {`
		1725	`case 101:`
		1726	`{`
		1727	`unsigned ZI581;`
		1728	`int ZI537;`
		1729	`EXP ZI416;`
		1730	`EXP ZI582;`
		1731	`EXP ZI448;`
		1732	`EXP ZI603;`
		1733	`EXP ZI467;`
		1734
		1735	`ADVANCE_LEXER;`
		1736	`{`
		1737	`(ZI581) = crt_condition ;`
		1738	`}`
		1739	`{`
		1740
		1741	`(ZI537) = unreached_code ;`
		1742	`if ( (ZI537) ) {`
		1743	`if ( !unreached_last ) {`
		1744	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		1745	`unreached_last = 1 ;`
		1746	`}`
		1747	`} else {`
		1748	`unreached_last = 0 ;`
		1749	`}`
		1750	`}`
		1751	`{`
		1752
		1753	`(ZI416) = begin_do_stmt () ;`
		1754	`}`
		1755	`{`
		1756
		1757	`(ZI582) = begin_compound_stmt ( 1 ) ;`
		1758	`}`
		1759	`ZR556 (ZI582, &ZI448);`
		1760	`switch (CURRENT_TERMINAL) {`
		1761	`case 125:`
		1762	`break;`
		1763	`case 354:`
		1764	`RESTORE_LEXER;`
		1765	`goto ZL1;`
		1766	`default:`
		1767	`goto ZL1;`
		1768	`}`
		1769	`ADVANCE_LEXER;`
		1770	`switch (CURRENT_TERMINAL) {`
		1771	`case 65:`
		1772	`break;`
		1773	`default:`
		1774	`goto ZL1;`
		1775	`}`
		1776	`ADVANCE_LEXER;`
		1777	`ZR414 (&ZI603);`
		1778	`if ((CURRENT_TERMINAL) == 354) {`
		1779	`RESTORE_LEXER;`
		1780	`goto ZL1;`
		1781	`}`
		1782	`{`
		1783
		1784	`(ZI467) = bind_temporary ( (ZI603) ) ;`
		1785	`}`
		1786	`{`
		1787	`unreached_prev = (ZI537) ;`
		1788	`}`
		1789	`{`
		1790
		1791	`(ZI404) = end_do_stmt ( (ZI416), (ZI448), (ZI467) ) ;`
		1792	`}`
		1793	`switch (CURRENT_TERMINAL) {`
		1794	`case 39:`
		1795	`break;`
		1796	`default:`
		1797	`goto ZL1;`
		1798	`}`
		1799	`ADVANCE_LEXER;`
		1800	`{`
		1801	`crt_condition = (ZI581) ;`
		1802	`}`
		1803	`{`
		1804
		1805	`unreached_fall = 1 ;`
		1806	`}`
		1807	`ZR396 ();`
		1808	`if ((CURRENT_TERMINAL) == 354) {`
		1809	`RESTORE_LEXER;`
		1810	`goto ZL1;`
		1811	`}`
		1812	`}`
		1813	`break;`
		1814	`case 107:`
		1815	`{`
		1816	`unsigned ZI581;`
		1817	`int ZI537;`
		1818	`EXP ZI585;`
		1819	`EXP ZI416;`
		1820	`EXP ZI604;`
		1821	`EXP ZI467;`
		1822	`EXP ZI605;`
		1823	`EXP ZI448;`
		1824	`EXP ZI606;`
		1825	`EXP ZI547;`
		1826
		1827	`ADVANCE_LEXER;`
		1828	`{`
		1829	`(ZI581) = crt_condition ;`
		1830	`}`
		1831	`{`
		1832
		1833	`(ZI537) = unreached_code ;`
		1834	`if ( (ZI537) ) {`
		1835	`if ( !unreached_last ) {`
		1836	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		1837	`unreached_last = 1 ;`
		1838	`}`
		1839	`} else {`
		1840	`unreached_last = 0 ;`
		1841	`}`
		1842	`}`
		1843	`switch (CURRENT_TERMINAL) {`
		1844	`case 65:`
		1845	`break;`
		1846	`default:`
		1847	`goto ZL1;`
		1848	`}`
		1849	`ADVANCE_LEXER;`
		1850	`{`
		1851
		1852	`(ZI585) = begin_for_stmt () ;`
		1853	`}`
		1854	`ZR598 (&ZI416);`
		1855	`if ((CURRENT_TERMINAL) == 354) {`
		1856	`RESTORE_LEXER;`
		1857	`goto ZL1;`
		1858	`}`
		1859	`{`
		1860
		1861	`(ZI604) = init_for_stmt ( (ZI585), &(ZI416) ) ;`
		1862	`}`
		1863	`ZR599 (&ZI467);`
		1864	`if ((CURRENT_TERMINAL) == 354) {`
		1865	`RESTORE_LEXER;`
		1866	`goto ZL1;`
		1867	`}`
		1868	`{`
		1869
		1870	`(ZI605) = begin_compound_stmt ( 1 ) ;`
		1871	`}`
		1872	`ZR601 (&ZI448);`
		1873	`if ((CURRENT_TERMINAL) == 354) {`
		1874	`RESTORE_LEXER;`
		1875	`goto ZL1;`
		1876	`}`
		1877	`{`
		1878
		1879	`(ZI606) = cond_for_stmt ( (ZI604), (ZI467), (ZI448) ) ;`
		1880	`}`
		1881	`switch (CURRENT_TERMINAL) {`
		1882	`case 39:`
		1883	`break;`
		1884	`default:`
		1885	`goto ZL1;`
		1886	`}`
		1887	`ADVANCE_LEXER;`
		1888	`{`
		1889
		1890	`mark_compound_stmt ( (ZI605) ) ;`
		1891	`}`
		1892	`ZR556 (ZI605, &ZI547);`
		1893	`if ((CURRENT_TERMINAL) == 354) {`
		1894	`RESTORE_LEXER;`
		1895	`goto ZL1;`
		1896	`}`
		1897	`{`
		1898	`unreached_prev = (ZI537) ;`
		1899	`}`
		1900	`{`
		1901
		1902	`(ZI404) = end_for_stmt ( (ZI606), (ZI547) ) ;`
		1903	`}`
		1904	`{`
		1905	`crt_condition = (ZI581) ;`
		1906	`}`
		1907	`{`
		1908
		1909	`unreached_fall = 1 ;`
		1910	`}`
		1911	`{`
		1912
		1913	`RESCAN_LEXER ;`
		1914	`}`
		1915	`}`
		1916	`break;`
		1917	`case 125:`
		1918	`{`
		1919	`unsigned ZI581;`
		1920	`int ZI537;`
		1921	`EXP ZI603;`
		1922	`EXP ZI467;`
		1923	`EXP ZI416;`
		1924	`EXP ZI582;`
		1925	`EXP ZI448;`
		1926
		1927	`ADVANCE_LEXER;`
		1928	`{`
		1929	`(ZI581) = crt_condition ;`
		1930	`}`
		1931	`{`
		1932
		1933	`(ZI537) = unreached_code ;`
		1934	`if ( (ZI537) ) {`
		1935	`if ( !unreached_last ) {`
		1936	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		1937	`unreached_last = 1 ;`
		1938	`}`
		1939	`} else {`
		1940	`unreached_last = 0 ;`
		1941	`}`
		1942	`}`
		1943	`switch (CURRENT_TERMINAL) {`
		1944	`case 65:`
		1945	`break;`
		1946	`default:`
		1947	`goto ZL1;`
		1948	`}`
		1949	`ADVANCE_LEXER;`
		1950	`ZR414 (&ZI603);`
		1951	`if ((CURRENT_TERMINAL) == 354) {`
		1952	`RESTORE_LEXER;`
		1953	`goto ZL1;`
		1954	`}`
		1955	`{`
		1956
		1957	`(ZI467) = bind_temporary ( (ZI603) ) ;`
		1958	`}`
		1959	`{`
		1960
		1961	`(ZI416) = begin_while_stmt ( (ZI467) ) ;`
		1962	`}`
		1963	`switch (CURRENT_TERMINAL) {`
		1964	`case 39:`
		1965	`break;`
		1966	`default:`
		1967	`goto ZL1;`
		1968	`}`
		1969	`ADVANCE_LEXER;`
		1970	`{`
		1971
		1972	`(ZI582) = begin_compound_stmt ( 1 ) ;`
		1973	`}`
		1974	`ZR556 (ZI582, &ZI448);`
		1975	`if ((CURRENT_TERMINAL) == 354) {`
		1976	`RESTORE_LEXER;`
		1977	`goto ZL1;`
		1978	`}`
		1979	`{`
		1980	`unreached_prev = (ZI537) ;`
		1981	`}`
		1982	`{`
		1983
		1984	`(ZI404) = end_while_stmt ( (ZI416), (ZI448) ) ;`
		1985	`}`
		1986	`{`
		1987	`crt_condition = (ZI581) ;`
		1988	`}`
		1989	`{`
		1990
		1991	`unreached_fall = 1 ;`
		1992	`}`
		1993	`}`
		1994	`break;`
		1995	`case 354:`
		1996	`return;`
		1997	`default:`
		1998	`goto ZL1;`
		1999	`}`
		2000	`goto ZL0;`
		2001	`ZL1:;`
		2002	`SAVE_LEXER (354);`
		2003	`return;`
		2004	`ZL0:;`
		2005	`*ZO404 = ZI404;`
		2006	`}`
		2007
		2008	`void`
		2009	`ZR506 PROTO_Z ()`
		2010	`{`
		2011	`switch (CURRENT_TERMINAL) {`
		2012	`case 45:`
		2013	`{`
		2014	`ADVANCE_LEXER;`
		2015	`}`
		2016	`break;`
		2017	`case 58:`
		2018	`{`
		2019	`ADVANCE_LEXER;`
		2020	`}`
		2021	`break;`
		2022	`case 60:`
		2023	`{`
		2024	`ADVANCE_LEXER;`
		2025	`}`
		2026	`break;`
		2027	`case 70:`
		2028	`{`
		2029	`ADVANCE_LEXER;`
		2030	`}`
		2031	`break;`
		2032	`case 74:`
		2033	`{`
		2034	`ADVANCE_LEXER;`
		2035	`}`
		2036	`break;`
		2037	`case 76:`
		2038	`{`
		2039	`ADVANCE_LEXER;`
		2040	`}`
		2041	`break;`
		2042	`case 79:`
		2043	`{`
		2044	`ADVANCE_LEXER;`
		2045	`}`
		2046	`break;`
		2047	`case 34:`
		2048	`{`
		2049	`{`
		2050	`{`
		2051	`switch (CURRENT_TERMINAL) {`
		2052	`case 34:`
		2053	`break;`
		2054	`default:`
		2055	`goto ZL1;`
		2056	`}`
		2057	`ADVANCE_LEXER;`
		2058	`}`
		2059	`}`
		2060	`}`
		2061	`break;`
		2062	`case 68:`
		2063	`{`
		2064	`{`
		2065	`{`
		2066	`switch (CURRENT_TERMINAL) {`
		2067	`case 68:`
		2068	`break;`
		2069	`default:`
		2070	`goto ZL1;`
		2071	`}`
		2072	`ADVANCE_LEXER;`
		2073	`}`
		2074	`}`
		2075	`}`
		2076	`break;`
		2077	`case 81:`
		2078	`{`
		2079	`{`
		2080	`{`
		2081	`switch (CURRENT_TERMINAL) {`
		2082	`case 81:`
		2083	`break;`
		2084	`default:`
		2085	`goto ZL1;`
		2086	`}`
		2087	`ADVANCE_LEXER;`
		2088	`}`
		2089	`}`
		2090	`}`
		2091	`break;`
		2092	`case 354:`
		2093	`return;`
		2094	`default:`
		2095	`goto ZL1;`
		2096	`}`
		2097	`return;`
		2098	`ZL1:;`
		2099	`SAVE_LEXER (354);`
		2100	`return;`
		2101	`}`
		2102
		2103	`void`
		2104	`ZR860 PROTO_N ((ZI858, ZO859))`
		2105	`PROTO_T (TYPE ZI858 X TYPE *ZO859)`
		2106	`{`
		2107	`TYPE ZI859;`
		2108
		2109	`ZL2_860:;`
		2110	`switch (CURRENT_TERMINAL) {`
		2111	`case 65: case 66: case 331:`
		2112	`{`
		2113	`TYPE ZI423;`
		2114	`TYPE ZI395;`
		2115
		2116	`ZR754 (&ZI423);`
		2117	`if ((CURRENT_TERMINAL) == 354) {`
		2118	`RESTORE_LEXER;`
		2119	`goto ZL1;`
		2120	`}`
		2121	`{`
		2122
		2123	`(ZI395) = ( IS_NULL_type ( (ZI858) ) ? (ZI423) : inject_pre_type ( (ZI858), (ZI423), 0 ) ) ;`
		2124	`}`
		2125	`ZI858 = ZI395;`
		2126	`goto ZL2_860;`
		2127	`}`
		2128	`/UNREACHED/`
		2129	`default:`
		2130	`{`
		2131	`ZI859 = ZI858;`
		2132	`}`
		2133	`break;`
		2134	`case 354:`
		2135	`return;`
		2136	`}`
		2137	`goto ZL0;`
		2138	`ZL1:;`
		2139	`SAVE_LEXER (354);`
		2140	`return;`
		2141	`ZL0:;`
		2142	`*ZO859 = ZI859;`
		2143	`}`
		2144
		2145	`void`
		2146	`ZR536 PROTO_N ((ZO404))`
		2147	`PROTO_T (EXP *ZO404)`
		2148	`{`
		2149	`EXP ZI404;`
		2150
		2151	`switch (CURRENT_TERMINAL) {`
		2152	`case 345:`
		2153	`{`
		2154	`ADVANCE_LEXER;`
		2155	`ZR1078 (&ZI404);`
		2156	`if ((CURRENT_TERMINAL) == 354) {`
		2157	`RESTORE_LEXER;`
		2158	`goto ZL1;`
		2159	`}`
		2160	`}`
		2161	`break;`
		2162	`case 77:`
		2163	`{`
		2164	`ADVANCE_LEXER;`
		2165	`{`
		2166
		2167	`(ZI404) = NULL_exp ;`
		2168	`}`
		2169	`}`
		2170	`break;`
		2171	`case 1: case 17: case 18: case 19: case 20:`
		2172	`case 21: case 22: case 23: case 33: case 43:`
		2173	`case 59: case 61: case 62: case 65: case 69:`
		2174	`case 71: case 78: case 85: case 116: case 170:`
		2175	`case 205: case 209:`
		2176	`{`
		2177	`EXP ZI1025;`
		2178	`EXP ZI416;`
		2179	`int ZI537;`
		2180
		2181	`ZR419 (&ZI1025);`
		2182	`ZR1027 (&ZI1025, &ZI416);`
		2183	`if ((CURRENT_TERMINAL) == 354) {`
		2184	`RESTORE_LEXER;`
		2185	`goto ZL1;`
		2186	`}`
		2187	`{`
		2188
		2189	`(ZI537) = unreached_code ;`
		2190	`if ( (ZI537) ) {`
		2191	`if ( !unreached_last ) {`
		2192	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		2193	`unreached_last = 1 ;`
		2194	`}`
		2195	`} else {`
		2196	`unreached_last = 0 ;`
		2197	`}`
		2198	`}`
		2199	`{`
		2200
		2201	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		2202	`}`
		2203	`{`
		2204
		2205	`unreached_fall = 1 ;`
		2206	`}`
		2207	`switch (CURRENT_TERMINAL) {`
		2208	`case 77:`
		2209	`break;`
		2210	`default:`
		2211	`goto ZL1;`
		2212	`}`
		2213	`ADVANCE_LEXER;`
		2214	`}`
		2215	`break;`
		2216	`case 297: case 323:`
		2217	`{`
		2218	`EXP ZI1073;`
		2219	`EXP ZI416;`
		2220	`int ZI537;`
		2221
		2222	`ZR510 (&ZI1073);`
		2223	`ZR1075 (&ZI1073, &ZI416);`
		2224	`if ((CURRENT_TERMINAL) == 354) {`
		2225	`RESTORE_LEXER;`
		2226	`goto ZL1;`
		2227	`}`
		2228	`{`
		2229
		2230	`(ZI537) = unreached_code ;`
		2231	`if ( (ZI537) ) {`
		2232	`if ( !unreached_last ) {`
		2233	`report ( crt_loc, ERR_stmt_stmt_unreach () ) ;`
		2234	`unreached_last = 1 ;`
		2235	`}`
		2236	`} else {`
		2237	`unreached_last = 0 ;`
		2238	`}`
		2239	`}`
		2240	`{`
		2241
		2242	`(ZI404) = make_exp_stmt ( (ZI416) ) ;`
		2243	`}`
		2244	`{`
		2245
		2246	`unreached_fall = 1 ;`
		2247	`}`
		2248	`switch (CURRENT_TERMINAL) {`
		2249	`case 77:`
		2250	`break;`
		2251	`default:`
		2252	`goto ZL1;`
		2253	`}`
		2254	`ADVANCE_LEXER;`
		2255	`}`
		2256	`break;`
		2257	`case 354:`
		2258	`return;`
		2259	`default:`
		2260	`goto ZL1;`
		2261	`}`
		2262	`goto ZL0;`
		2263	`ZL1:;`
		2264	`SAVE_LEXER (354);`
		2265	`return;`
		2266	`ZL0:;`
		2267	`*ZO404 = ZI404;`
		2268	`}`
		2269
		2270	`void`
		2271	`ZR834 PROTO_N ((ZI448, ZI568, ZO416, ZO395))`
		2272	`PROTO_T (OFFSET ZI448 X TYPE ZI568 X OFFSET ZO416 X TYPE ZO395)`
		2273	`{`
		2274	`OFFSET ZI416;`
		2275	`TYPE ZI395;`
		2276
		2277	`if ((CURRENT_TERMINAL) == 354) {`
		2278	`return;`
		2279	`}`
		2280	`{`
		2281	`NAMESPACE ZI426;`
		2282	`IDENTIFIER ZI399;`
		2283
		2284	`{`
		2285
		2286	`(ZI426) = offset_nspace ( (ZI568) ) ;`
		2287	`}`
		2288	`{`
		2289
		2290	`RESCAN_LEXER ;`
		2291	`}`
		2292	`ZR427 (ZI426, &ZI399);`
		2293	`if ((CURRENT_TERMINAL) == 354) {`
		2294	`RESTORE_LEXER;`
		2295	`goto ZL1;`
		2296	`}`
		2297	`{`
		2298
		2299	`OFFSET off = offset_member ( (ZI568), (ZI399), &(ZI395), (ZI426), 1 ) ;`
		2300	`(ZI416) = offset_add ( (ZI448), off ) ;`
		2301	`}`
		2302	`{`
		2303
		2304	`RESCAN_LEXER ;`
		2305	`}`
		2306	`}`
		2307	`goto ZL0;`
		2308	`ZL1:;`
		2309	`SAVE_LEXER (354);`
		2310	`return;`
		2311	`ZL0:;`
		2312	`*ZO416 = ZI416;`
		2313	`*ZO395 = ZI395;`
		2314	`}`
		2315
		2316	`void`
		2317	`ZR806 PROTO_Z ()`
		2318	`{`
		2319	`switch (CURRENT_TERMINAL) {`
		2320	`case 30:`
		2321	`{`
		2322	`ADVANCE_LEXER;`
		2323	`}`
		2324	`break;`
		2325	`case 26:`
		2326	`{`
		2327	`EXP ZI420;`
		2328
		2329	`ZR805 (&ZI420);`
		2330	`{`
		2331	`switch (CURRENT_TERMINAL) {`
		2332	`case 28:`
		2333	`{`
		2334	`ADVANCE_LEXER;`
		2335	`{`
		2336
		2337	`crt_hash_cond = make_else_cond ( crt_hash_cond ) ;`
		2338	`}`
		2339	`{`
		2340
		2341	`target_decl ( lex_else, NULL_exp ) ;`
		2342	`}`
		2343	`ZR804 ();`
		2344	`if ((CURRENT_TERMINAL) == 354) {`
		2345	`RESTORE_LEXER;`
		2346	`goto ZL1;`
		2347	`}`
		2348	`}`
		2349	`break;`
		2350	`case 354:`
		2351	`RESTORE_LEXER;`
		2352	`goto ZL1;`
		2353	`default:`
		2354	`break;`
		2355	`}`
		2356	`}`
		2357	`{`
		2358
		2359	`crt_hash_cond = (ZI420) ;`
		2360	`}`
		2361	`switch (CURRENT_TERMINAL) {`
		2362	`case 29:`
		2363	`break;`
		2364	`default:`
		2365	`goto ZL1;`
		2366	`}`
		2367	`ADVANCE_LEXER;`
		2368	`{`
		2369
		2370	`target_decl ( lex_endif, NULL_exp ) ;`
		2371	`}`
		2372	`}`
		2373	`break;`
		2374	`case 354:`
		2375	`return;`
		2376	`default:`
		2377	`goto ZL1;`
		2378	`}`
		2379	`return;`
		2380	`ZL1:;`
		2381	`SAVE_LEXER (354);`
		2382	`return;`
		2383	`}`
		2384
		2385	`void`
		2386	`ZR868 PROTO_N ((ZI864, ZI865, ZO866, ZO867))`
		2387	`PROTO_T (TYPE ZI864 X IDENTIFIER ZI865 X TYPE ZO866 X IDENTIFIER ZO867)`
		2388	`{`
		2389	`TYPE ZI866;`
		2390	`IDENTIFIER ZI867;`
		2391
		2392	`ZL2_868:;`
		2393	`switch (CURRENT_TERMINAL) {`
		2394	`case 65: case 66: case 331:`
		2395	`{`
		2396	`IDENTIFIER ZI399;`
		2397	`TYPE ZI423;`
		2398	`TYPE ZI395;`
		2399
		2400	`ZI399 = ZI865;`
		2401	`ZR745 (ZI399, &ZI423);`
		2402	`if ((CURRENT_TERMINAL) == 354) {`
		2403	`RESTORE_LEXER;`
		2404	`goto ZL1;`
		2405	`}`
		2406	`{`
		2407
		2408	`(ZI395) = ( IS_NULL_type ( (ZI864) ) ? (ZI423) : inject_pre_type ( (ZI864), (ZI423), 0 ) ) ;`
		2409	`}`
		2410	`ZI864 = ZI395;`
		2411	`ZI865 = ZI399;`
		2412	`goto ZL2_868;`
		2413	`}`
		2414	`/UNREACHED/`
		2415	`default:`
		2416	`{`
		2417	`ZI866 = ZI864;`
		2418	`ZI867 = ZI865;`
		2419	`}`
		2420	`break;`
		2421	`case 354:`
		2422	`return;`
		2423	`}`
		2424	`goto ZL0;`
		2425	`ZL1:;`
		2426	`SAVE_LEXER (354);`
		2427	`return;`
		2428	`ZL0:;`
		2429	`*ZO866 = ZI866;`
		2430	`*ZO867 = ZI867;`
		2431	`}`
		2432
		2433	`void`
		2434	`ZR615 PROTO_N ((ZO416))`
		2435	`PROTO_T (EXP *ZO416)`
		2436	`{`
		2437	`EXP ZI416;`
		2438
		2439	`switch (CURRENT_TERMINAL) {`
		2440	`case 1: case 17: case 18: case 19: case 20:`
		2441	`case 21: case 22: case 23: case 33: case 43:`
		2442	`case 59: case 61: case 62: case 65: case 69:`
		2443	`case 71: case 78: case 85: case 116: case 170:`
		2444	`case 205: case 209: case 297: case 323: case 345:`
		2445	`{`
		2446	`ZR414 (&ZI416);`
		2447	`if ((CURRENT_TERMINAL) == 354) {`
		2448	`RESTORE_LEXER;`
		2449	`goto ZL1;`
		2450	`}`
		2451	`}`
		2452	`break;`
		2453	`default:`
		2454	`{`
		2455	`{`
		2456
		2457	`(ZI416) = NULL_exp ;`
		2458	`}`
		2459	`}`
		2460	`break;`
		2461	`case 354:`
		2462	`return;`
		2463	`}`
		2464	`goto ZL0;`
		2465	`ZL1:;`
		2466	`SAVE_LEXER (354);`
		2467	`return;`
		2468	`ZL0:;`
		2469	`*ZO416 = ZI416;`
		2470	`}`
		2471
		2472	`void`
		2473	`parse_mem_type PROTO_N ((ZO395))`
		2474	`PROTO_T (TYPE *ZO395)`
		2475	`{`
		2476	`TYPE ZI395;`
		2477
		2478	`if ((CURRENT_TERMINAL) == 354) {`
		2479	`return;`
		2480	`}`
		2481	`{`
		2482	`BASE_TYPE ZI658;`
		2483	`TYPE ZI420;`
		2484	`CV_SPEC ZI630;`
		2485	`TYPE ZI423;`
		2486
		2487	`ZR687 (&ZI658, &ZI420, &ZI630);`
		2488	`if ((CURRENT_TERMINAL) == 354) {`
		2489	`RESTORE_LEXER;`
		2490	`goto ZL1;`
		2491	`}`
		2492	`{`
		2493
		2494	`(ZI423) = complete_pre_type ( (ZI658), (ZI420), (ZI630), 1 ) ;`
		2495	`have_type_specifier = 0 ;`
		2496	`}`
		2497	`{`
		2498	`switch (CURRENT_TERMINAL) {`
		2499	`case 73:`
		2500	`{`
		2501	`EXP ZI467;`
		2502
		2503	`ADVANCE_LEXER;`
		2504	`ZR518 (&ZI467);`
		2505	`if ((CURRENT_TERMINAL) == 354) {`
		2506	`RESTORE_LEXER;`
		2507	`goto ZL1;`
		2508	`}`
		2509	`{`
		2510
		2511	`(ZI395) = make_bitfield_type ( (ZI423), (ZI658), (ZI467), 0 ) ;`
		2512	`}`
		2513	`}`
		2514	`break;`
		2515	`default:`
		2516	`{`
		2517	`ZR760 (ZI423, &ZI395);`
		2518	`if ((CURRENT_TERMINAL) == 354) {`
		2519	`RESTORE_LEXER;`
		2520	`goto ZL1;`
		2521	`}`
		2522	`}`
		2523	`break;`
		2524	`}`
		2525	`}`
		2526	`}`
		2527	`goto ZL0;`
		2528	`ZL1:;`
		2529	`SAVE_LEXER (354);`
		2530	`return;`
		2531	`ZL0:;`
		2532	`*ZO395 = ZI395;`
		2533	`}`
		2534
		2535	`void`
		2536	`parse_operator PROTO_N ((ZO399))`
		2537	`PROTO_T (IDENTIFIER *ZO399)`
		2538	`{`
		2539	`IDENTIFIER ZI399;`
		2540
		2541	`if ((CURRENT_TERMINAL) == 354) {`
		2542	`return;`
		2543	`}`
		2544	`{`
		2545	`{`
		2546
		2547	`/* Syntax errors */`
		2548	`ERROR err = ERR_lex_parse ( crt_token ) ;`
		2549	`report ( crt_loc, err ) ;`
		2550	`have_syntax_error = 1 ;`
		2551	`}`
		2552	`{`
		2553
		2554	`(ZI399) = NULL_id ;`
		2555	`}`
		2556	`}`
		2557	`*ZO399 = ZI399;`
		2558	`}`
		2559
		2560	`void`
		2561	`ZR497 PROTO_N ((ZO885))`
		2562	`PROTO_T (EXP *ZO885)`
		2563	`{`
		2564	`EXP ZI885;`
		2565
		2566	`if ((CURRENT_TERMINAL) == 354) {`
		2567	`return;`
		2568	`}`
		2569	`{`
		2570	`EXP ZI404;`
		2571
		2572	`ZR495 (&ZI404);`
		2573	`ZR886 (ZI404, &ZI885);`
		2574	`if ((CURRENT_TERMINAL) == 354) {`
		2575	`RESTORE_LEXER;`
		2576	`goto ZL1;`
		2577	`}`
		2578	`}`
		2579	`goto ZL0;`
		2580	`ZL1:;`
		2581	`SAVE_LEXER (354);`
		2582	`return;`
		2583	`ZL0:;`
		2584	`*ZO885 = ZI885;`
		2585	`}`
		2586
		2587	`void`
		2588	`ZR874 PROTO_N ((ZI872, ZO873))`
		2589	`PROTO_T (EXP ZI872 X EXP *ZO873)`
		2590	`{`
		2591	`EXP ZI873;`
		2592
		2593	`ZL2_874:;`
		2594	`switch (CURRENT_TERMINAL) {`
		2595	`case 27:`
		2596	`{`
		2597	`EXP ZI420;`
		2598	`EXP ZI467;`
		2599
		2600	`ZI420 = ZI872;`
		2601	`{`
		2602
		2603	`ZI467 = crt_token->pp_data.exp ;`
		2604	`}`
		2605	`ADVANCE_LEXER;`
		2606	`{`
		2607
		2608	`EXP c = make_else_cond ( crt_hash_cond ) ;`
		2609	`crt_hash_cond = make_if_cond ( (ZI467), c ) ;`
		2610	`}`
		2611	`{`
		2612
		2613	`target_decl ( lex_elif, (ZI467) ) ;`
		2614	`}`
		2615	`ZR804 ();`
		2616	`if ((CURRENT_TERMINAL) == 354) {`
		2617	`RESTORE_LEXER;`
		2618	`goto ZL1;`
		2619	`} else {`
		2620	`ZI872 = ZI420;`
		2621	`goto ZL2_874;`
		2622	`}`
		2623	`}`
		2624	`/UNREACHED/`
		2625	`default:`
		2626	`{`
		2627	`ZI873 = ZI872;`
		2628	`}`
		2629	`break;`
		2630	`case 354:`
		2631	`return;`
		2632	`}`
		2633	`goto ZL0;`
		2634	`ZL1:;`
		2635	`SAVE_LEXER (354);`
		2636	`return;`
		2637	`ZL0:;`
		2638	`*ZO873 = ZI873;`
		2639	`}`
		2640
		2641	`void`
		2642	`ZR613 PROTO_N ((ZO404))`
		2643	`PROTO_T (EXP *ZO404)`
		2644	`{`
		2645	`EXP ZI404;`
		2646
		2647	`switch (CURRENT_TERMINAL) {`
		2648	`case 96:`
		2649	`{`
		2650	`EXP ZI467;`
		2651
		2652	`ADVANCE_LEXER;`
		2653	`ZR518 (&ZI467);`
		2654	`if ((CURRENT_TERMINAL) == 354) {`
		2655	`RESTORE_LEXER;`
		2656	`goto ZL1;`
		2657	`}`
		2658	`{`
		2659
		2660	`report ( crt_loc, ERR_stmt_goto_case ( lex_case ) ) ;`
		2661	`(ZI404) = begin_case_stmt ( (ZI467), 1 ) ;`
		2662	`}`
		2663	`}`
		2664	`break;`
		2665	`case 100:`
		2666	`{`
		2667	`ADVANCE_LEXER;`
		2668	`{`
		2669
		2670	`report ( crt_loc, ERR_stmt_goto_case ( lex_default ) ) ;`
		2671	`(ZI404) = begin_default_stmt ( 1 ) ;`
		2672	`}`
		2673	`}`
		2674	`break;`
		2675	`case 1: case 2: case 4:`
		2676	`{`
		2677	`IDENTIFIER ZI399;`
		2678
		2679	`{`
		2680	`switch (CURRENT_TERMINAL) {`
		2681	`case 1:`
		2682	`{`
		2683	`{`
		2684
		2685	`ZI399 = crt_token->pp_data.id.use ;`
		2686	`}`
		2687	`ADVANCE_LEXER;`
		2688	`}`
		2689	`break;`
		2690	`case 4:`
		2691	`{`
		2692	`{`
		2693
		2694	`ZI399 = crt_token->pp_data.id.use ;`
		2695	`}`
		2696	`ADVANCE_LEXER;`
		2697	`}`
		2698	`break;`
		2699	`case 2:`
		2700	`{`
		2701	`{`
		2702
		2703	`ZI399 = crt_token->pp_data.id.use ;`
		2704	`}`
		2705	`ADVANCE_LEXER;`
		2706	`}`
		2707	`break;`
		2708	`default:`
		2709	`goto ZL1;`
		2710	`}`
		2711	`}`
		2712	`{`
		2713
		2714	`(ZI404) = make_goto_stmt ( (ZI399) ) ;`
		2715	`}`
		2716	`}`
		2717	`break;`
		2718	`case 354:`
		2719	`return;`
		2720	`default:`
		2721	`goto ZL1;`
		2722	`}`
		2723	`goto ZL0;`
		2724	`ZL1:;`
		2725	`SAVE_LEXER (354);`
		2726	`return;`
		2727	`ZL0:;`
		2728	`*ZO404 = ZI404;`
		2729	`}`
		2730
		2731	`void`
		2732	`ZR515 PROTO_N ((ZO420))`
		2733	`PROTO_T (SID_LIST_EXP *ZO420)`
		2734	`{`
		2735	`SID_LIST_EXP ZI420;`
		2736
		2737	`switch (CURRENT_TERMINAL) {`
		2738	`case 1: case 17: case 18: case 19: case 20:`
		2739	`case 21: case 22: case 23: case 33: case 43:`
		2740	`case 59: case 61: case 62: case 65: case 69:`
		2741	`case 71: case 78: case 85: case 116: case 170:`
		2742	`case 205: case 209:`
		2743	`{`
		2744	`EXP ZI416;`
		2745
		2746	`ZR419 (&ZI416);`
		2747	`ZR1028 (&ZI416, &ZI420);`
		2748	`if ((CURRENT_TERMINAL) == 354) {`
		2749	`RESTORE_LEXER;`
		2750	`goto ZL1;`
		2751	`}`
		2752	`}`
		2753	`break;`
		2754	`case 297: case 323:`
		2755	`{`
		2756	`EXP ZI416;`
		2757	`SID_LIST_EXP ZI423;`
		2758
		2759	`ZR510 (&ZI416);`
		2760	`ZR515 (&ZI423);`
		2761	`if ((CURRENT_TERMINAL) == 354) {`
		2762	`RESTORE_LEXER;`
		2763	`goto ZL1;`
		2764	`}`
		2765	`{`
		2766
		2767	`CONS_exp ( (ZI416), (ZI423), (ZI420) ) ;`
		2768	`}`
		2769	`}`
		2770	`break;`
		2771	`case 345:`
		2772	`{`
		2773	`EXP ZI416;`
		2774	`SID_LIST_EXP ZI423;`
		2775
		2776	`ZR511 (&ZI416);`
		2777	`ZR515 (&ZI423);`
		2778	`if ((CURRENT_TERMINAL) == 354) {`
		2779	`RESTORE_LEXER;`
		2780	`goto ZL1;`
		2781	`}`
		2782	`{`
		2783
		2784	`CONS_exp ( (ZI416), (ZI423), (ZI420) ) ;`
		2785	`}`
		2786	`}`
		2787	`break;`
		2788	`case 354:`
		2789	`return;`
		2790	`default:`
		2791	`goto ZL1;`
		2792	`}`
		2793	`goto ZL0;`
		2794	`ZL1:;`
		2795	`SAVE_LEXER (354);`
		2796	`return;`
		2797	`ZL0:;`
		2798	`*ZO420 = ZI420;`
		2799	`}`
		2800
		2801	`void`
		2802	`ZR743 PROTO_N ((ZO747))`
		2803	`PROTO_T (int *ZO747)`
		2804	`{`
		2805	`int ZI747;`
		2806
		2807	`ZL2_743:;`
		2808	`switch (CURRENT_TERMINAL) {`
		2809	`case 47:`
		2810	`{`
		2811	`ADVANCE_LEXER;`
		2812	`{`
		2813	`(ZI747) = 1 ;`
		2814	`}`
		2815	`}`
		2816	`break;`
		2817	`case 2: case 25: case 94: case 97: case 98:`
		2818	`case 102: case 104: case 105: case 106: case 110:`
		2819	`case 111: case 112: case 114: case 115: case 117:`
		2820	`case 118: case 120: case 121: case 122: case 123:`
		2821	`case 124: case 137: case 156: case 184: case 285:`
		2822	`case 298:`
		2823	`{`
		2824	`IDENTIFIER ZI547;`
		2825
		2826	`ZR770 (&ZI547);`
		2827	`{`
		2828	`switch (CURRENT_TERMINAL) {`
		2829	`case 42:`
		2830	`{`
		2831	`ADVANCE_LEXER;`
		2832	`goto ZL2_743;`
		2833	`}`
		2834	`/UNREACHED/`
		2835	`default:`
		2836	`{`
		2837	`{`
		2838	`(ZI747) = 0 ;`
		2839	`}`
		2840	`}`
		2841	`break;`
		2842	`case 354:`
		2843	`RESTORE_LEXER;`
		2844	`goto ZL1;`
		2845	`}`
		2846	`}`
		2847	`}`
		2848	`break;`
		2849	`case 354:`
		2850	`return;`
		2851	`default:`
		2852	`goto ZL1;`
		2853	`}`
		2854	`goto ZL0;`
		2855	`ZL1:;`
		2856	`SAVE_LEXER (354);`
		2857	`return;`
		2858	`ZL0:;`
		2859	`*ZO747 = ZI747;`
		2860	`}`
		2861
		2862	`void`
		2863	`ZR409 PROTO_N ((ZO404))`
		2864	`PROTO_T (EXP *ZO404)`
		2865	`{`
		2866	`EXP ZI404;`
		2867
		2868	`switch (CURRENT_TERMINAL) {`
		2869	`case 17: case 18:`
		2870	`{`
		2871	`{`
		2872	`switch (CURRENT_TERMINAL) {`
		2873	`case 17:`
		2874	`{`
		2875	`{`
		2876
		2877	`ZI404 = crt_token->pp_data.exp ;`
		2878	`}`
		2879	`ADVANCE_LEXER;`
		2880	`}`
		2881	`break;`
		2882	`case 18:`
		2883	`{`
		2884	`{`
		2885
		2886	`ZI404 = crt_token->pp_data.exp ;`
		2887	`}`
		2888	`ADVANCE_LEXER;`
		2889	`}`
		2890	`break;`
		2891	`default:`
		2892	`goto ZL1;`
		2893	`}`
		2894	`}`
		2895	`}`
		2896	`break;`
		2897	`case 22:`
		2898	`{`
		2899	`{`
		2900	`{`
		2901	`switch (CURRENT_TERMINAL) {`
		2902	`case 22:`
		2903	`{`
		2904
		2905	`ZI404 = crt_token->pp_data.exp ;`
		2906	`}`
		2907	`break;`
		2908	`default:`
		2909	`goto ZL1;`
		2910	`}`
		2911	`ADVANCE_LEXER;`
		2912	`}`
		2913	`}`
		2914	`}`
		2915	`break;`
		2916	`case 21:`
		2917	`{`
		2918	`{`
		2919	`{`
		2920	`switch (CURRENT_TERMINAL) {`
		2921	`case 21:`
		2922	`{`
		2923
		2924	`ZI404 = crt_token->pp_data.exp ;`
		2925	`}`
		2926	`break;`
		2927	`default:`
		2928	`goto ZL1;`
		2929	`}`
		2930	`ADVANCE_LEXER;`
		2931	`}`
		2932	`}`
		2933	`}`
		2934	`break;`
		2935	`case 19: case 20:`
		2936	`{`
		2937	`{`
		2938	`switch (CURRENT_TERMINAL) {`
		2939	`case 19:`
		2940	`{`
		2941	`{`
		2942
		2943	`ZI404 = crt_token->pp_data.exp ;`
		2944	`}`
		2945	`ADVANCE_LEXER;`
		2946	`}`
		2947	`break;`
		2948	`case 20:`
		2949	`{`
		2950	`{`
		2951
		2952	`ZI404 = crt_token->pp_data.exp ;`
		2953	`}`
		2954	`ADVANCE_LEXER;`
		2955	`}`
		2956	`break;`
		2957	`default:`
		2958	`goto ZL1;`
		2959	`}`
		2960	`}`
		2961	`}`
		2962	`break;`
		2963	`case 354:`
		2964	`return;`
		2965	`default:`
		2966	`goto ZL1;`
		2967	`}`
		2968	`goto ZL0;`
		2969	`ZL1:;`
		2970	`SAVE_LEXER (354);`
		2971	`return;`
		2972	`ZL0:;`
		2973	`*ZO404 = ZI404;`
		2974	`}`
		2975
		2976	`void`
		2977	`ZR777 PROTO_N ((ZO399))`
		2978	`PROTO_T (IDENTIFIER *ZO399)`
		2979	`{`
		2980	`IDENTIFIER ZI399;`
		2981
		2982	`switch (CURRENT_TERMINAL) {`
		2983	`case 2:`
		2984	`{`
		2985	`{`
		2986
		2987	`ZI399 = crt_token->pp_data.id.use ;`
		2988	`}`
		2989	`ADVANCE_LEXER;`
		2990	`{`
		2991
		2992	`report ( crt_loc, ERR_dcl_fct_par_typedef ( (ZI399) ) ) ;`
		2993	`}`
		2994	`}`
		2995	`break;`
		2996	`case 1: case 4:`
		2997	`{`
		2998	`{`
		2999	`switch (CURRENT_TERMINAL) {`
		3000	`case 1:`
		3001	`{`
		3002	`{`
		3003
		3004	`ZI399 = crt_token->pp_data.id.use ;`
		3005	`}`
		3006	`ADVANCE_LEXER;`
		3007	`}`
		3008	`break;`
		3009	`case 4:`
		3010	`{`
		3011	`{`
		3012
		3013	`ZI399 = crt_token->pp_data.id.use ;`
		3014	`}`
		3015	`ADVANCE_LEXER;`
		3016	`}`
		3017	`break;`
		3018	`default:`
		3019	`goto ZL1;`
		3020	`}`
		3021	`}`
		3022	`}`
		3023	`break;`
		3024	`case 354:`
		3025	`return;`
		3026	`default:`
		3027	`goto ZL1;`
		3028	`}`
		3029	`goto ZL0;`
		3030	`ZL1:;`
		3031	`SAVE_LEXER (354);`
		3032	`return;`
		3033	`ZL0:;`
		3034	`*ZO399 = ZI399;`
		3035	`}`
		3036
		3037	`void`
		3038	`parse_decl PROTO_N ((ZI395, ZI605))`
		3039	`PROTO_T (TYPE ZI395 X DECL_SPEC ZI605)`
		3040	`{`
		3041	`if ((CURRENT_TERMINAL) == 354) {`
		3042	`return;`
		3043	`}`
		3044	`{`
		3045	`BASE_TYPE ZI688;`
		3046	`TYPE ZI1094;`
		3047	`CV_SPEC ZI690;`
		3048	`DECL_SPEC ZI1095;`
		3049	`BASE_TYPE ZI658;`
		3050	`TYPE ZI689;`
		3051	`CV_SPEC ZI630;`
		3052	`DECL_SPEC ZI716;`
		3053
		3054	`{`
		3055
		3056	`/* Resolve declaration-specifiers from other declarators */`
		3057	`(ZI0) = predict_dspec ( 0 ) ;`
		3058	`}`
		3059	`if (!ZI0)`
		3060	`goto ZL1;`
		3061	`ZR714 (&ZI688, &ZI1094, &ZI690, &ZI1095);`
		3062	`if ((CURRENT_TERMINAL) == 354) {`
		3063	`RESTORE_LEXER;`
		3064	`goto ZL1;`
		3065	`}`
		3066	`{`
		3067
		3068	`/* A type-name can be a declarator-id */`
		3069	`if ( have_type_specifier && crt_lex_token == lex_type_Hname ) {`
		3070	`crt_lex_token = lex_identifier ;`
		3071	`}`
		3072	`}`
		3073	`ZR724 (&ZI688, &ZI1094, &ZI690, &ZI1095, &ZI658, &ZI689, &ZI630, &ZI716);`
		3074	`ZR813 (&ZI658, &ZI689, &ZI630, &ZI716);`
		3075	`switch (CURRENT_TERMINAL) {`
		3076	`case 77:`
		3077	`break;`
		3078	`case 354:`
		3079	`RESTORE_LEXER;`
		3080	`goto ZL1;`
		3081	`default:`
		3082	`goto ZL1;`
		3083	`}`
		3084	`ADVANCE_LEXER;`
		3085	`}`
		3086	`return;`
		3087	`ZL1:;`
		3088	`{`
		3089	`{`
		3090
		3091	`/* Syntax errors */`
		3092	`ERROR err = ERR_lex_parse ( crt_token ) ;`
		3093	`report ( crt_loc, err ) ;`
		3094	`have_syntax_error = 1 ;`
		3095	`}`
		3096	`}`
		3097	`}`
		3098
		3099	`void`
		3100	`ZR878 PROTO_N ((ZI876, ZO877))`
		3101	`PROTO_T (EXP ZI876 X EXP *ZO877)`
		3102	`{`
		3103	`EXP ZI877;`
		3104
		3105	`ZL2_878:;`
		3106	`switch (CURRENT_TERMINAL) {`
		3107	`case 56:`
		3108	`{`
		3109	`EXP ZI448;`
		3110	`EXP ZI404;`
		3111
		3112	`{`
		3113	`{`
		3114	`switch (CURRENT_TERMINAL) {`
		3115	`case 56:`
		3116	`break;`
		3117	`default:`
		3118	`goto ZL1;`
		3119	`}`
		3120	`ADVANCE_LEXER;`
		3121	`}`
		3122	`}`
		3123	`ZR499 (&ZI448);`
		3124	`if ((CURRENT_TERMINAL) == 354) {`
		3125	`RESTORE_LEXER;`
		3126	`goto ZL1;`
		3127	`}`
		3128	`{`
		3129
		3130	`(ZI404) = make_log_or_exp ( (ZI876), (ZI448) ) ;`
		3131	`}`
		3132	`ZI876 = ZI404;`
		3133	`goto ZL2_878;`
		3134	`}`
		3135	`/UNREACHED/`
		3136	`default:`
		3137	`{`
		3138	`ZI877 = ZI876;`
		3139	`}`
		3140	`break;`
		3141	`case 354:`
		3142	`return;`
		3143	`}`
		3144	`goto ZL0;`
		3145	`ZL1:;`
		3146	`SAVE_LEXER (354);`
		3147	`return;`
		3148	`ZL0:;`
		3149	`*ZO877 = ZI877;`
		3150	`}`
		3151
		3152	`void`
		3153	`ZR624 PROTO_N ((ZO420))`
		3154	`PROTO_T (SID_LIST_EXP *ZO420)`
		3155	`{`
		3156	`SID_LIST_EXP ZI420;`
		3157
		3158	`switch (CURRENT_TERMINAL) {`
		3159	`case 42:`
		3160	`{`
		3161	`ADVANCE_LEXER;`
		3162	`ZR421 (&ZI420);`
		3163	`if ((CURRENT_TERMINAL) == 354) {`
		3164	`RESTORE_LEXER;`
		3165	`goto ZL1;`
		3166	`}`
		3167	`}`
		3168	`break;`
		3169	`default:`
		3170	`{`
		3171	`{`
		3172
		3173	`(ZI420) = NULL_list ( EXP ) ;`
		3174	`}`
		3175	`}`
		3176	`break;`
		3177	`case 354:`
		3178	`return;`
		3179	`}`
		3180	`goto ZL0;`
		3181	`ZL1:;`
		3182	`SAVE_LEXER (354);`
		3183	`return;`
		3184	`ZL0:;`
		3185	`*ZO420 = ZI420;`
		3186	`}`
		3187
		3188	`void`
		3189	`ZR495 PROTO_N ((ZO889))`
		3190	`PROTO_T (EXP *ZO889)`
		3191	`{`
		3192	`EXP ZI889;`
		3193
		3194	`if ((CURRENT_TERMINAL) == 354) {`
		3195	`return;`
		3196	`}`
		3197	`{`
		3198	`EXP ZI404;`
		3199
		3200	`ZR493 (&ZI404);`
		3201	`ZR890 (ZI404, &ZI889);`
		3202	`if ((CURRENT_TERMINAL) == 354) {`
		3203	`RESTORE_LEXER;`
		3204	`goto ZL1;`
		3205	`}`
		3206	`}`
		3207	`goto ZL0;`
		3208	`ZL1:;`
		3209	`SAVE_LEXER (354);`
		3210	`return;`
		3211	`ZL0:;`
		3212	`*ZO889 = ZI889;`
		3213	`}`
		3214
		3215	`void`
		3216	`ZR551 PROTO_N ((ZO404))`
		3217	`PROTO_T (EXP *ZO404)`
		3218	`{`
		3219	`EXP ZI404;`
		3220
		3221	`if ((CURRENT_TERMINAL) == 354) {`
		3222	`return;`
		3223	`}`
		3224	`{`
		3225	`EXP ZI467;`
		3226	`int ZI547;`
		3227	`EXP ZI416;`
		3228
		3229	`{`
		3230
		3231	`(ZI467) = begin_compound_stmt ( 1 ) ;`
		3232	`}`
		3233	`{`
		3234	`{`
		3235	`switch (CURRENT_TERMINAL) {`
		3236	`case 64:`
		3237	`break;`
		3238	`default:`
		3239	`goto ZL1;`
		3240	`}`
		3241	`ADVANCE_LEXER;`
		3242	`}`
		3243	`}`
		3244	`{`
		3245
		3246	`COPY_int ( exp_sequence_block ( (ZI467) ), 2 ) ;`
		3247	`(ZI547) = 1 ;`
		3248	`}`
		3249	`ZR548 (ZI467, ZI547, &ZI416);`
		3250	`{`
		3251	`if ((CURRENT_TERMINAL) == 354) {`
		3252	`RESTORE_LEXER;`
		3253	`goto ZL1;`
		3254	`}`
		3255	`{`
		3256	`switch (CURRENT_TERMINAL) {`
		3257	`case 38:`
		3258	`break;`
		3259	`default:`
		3260	`goto ZL1;`
		3261	`}`
		3262	`ADVANCE_LEXER;`
		3263	`}`
		3264	`}`
		3265	`{`
		3266
		3267	`(ZI404) = end_compound_stmt ( (ZI416) ) ;`
		3268	`}`
		3269	`{`
		3270
		3271	`RESCAN_LEXER ;`
		3272	`}`
		3273	`}`
		3274	`goto ZL0;`
		3275	`ZL1:;`
		3276	`SAVE_LEXER (354);`
		3277	`return;`
		3278	`ZL0:;`
		3279	`*ZO404 = ZI404;`
		3280	`}`
		3281
		3282	`void`
		3283	`ZR396 PROTO_Z ()`
		3284	`{`
		3285	`if ((CURRENT_TERMINAL) == 354) {`
		3286	`return;`
		3287	`}`
		3288	`{`
		3289	`switch (CURRENT_TERMINAL) {`
		3290	`case 77:`
		3291	`break;`
		3292	`default:`
		3293	`goto ZL1;`
		3294	`}`
		3295	`ADVANCE_LEXER;`
		3296	`}`
		3297	`return;`
		3298	`ZL1:;`
		3299	`{`
		3300	`int ZI395;`
		3301
		3302	`{`
		3303	`(ZI395) = lex_semicolon ;`
		3304	`}`
		3305	`{`
		3306
		3307	`/* Expected symbol */`
		3308	`int p = primary_form ( crt_lex_token ) ;`
		3309	`if ( p != (ZI395) ) report ( crt_loc, ERR_lex_expect ( (ZI395) ) ) ;`
		3310	`}`
		3311	`}`
		3312	`}`
		3313
		3314	`void`
		3315	`ZR501 PROTO_N ((ZO877))`
		3316	`PROTO_T (EXP *ZO877)`
		3317	`{`
		3318	`EXP ZI877;`
		3319
		3320	`if ((CURRENT_TERMINAL) == 354) {`
		3321	`return;`
		3322	`}`
		3323	`{`
		3324	`EXP ZI404;`
		3325
		3326	`ZR499 (&ZI404);`
		3327	`ZR878 (ZI404, &ZI877);`
		3328	`if ((CURRENT_TERMINAL) == 354) {`
		3329	`RESTORE_LEXER;`
		3330	`goto ZL1;`
		3331	`}`
		3332	`}`
		3333	`goto ZL0;`
		3334	`ZL1:;`
		3335	`SAVE_LEXER (354);`
		3336	`return;`
		3337	`ZL0:;`
		3338	`*ZO877 = ZI877;`
		3339	`}`
		3340
		3341	`void`
		3342	`ZR518 PROTO_N ((ZO404))`
		3343	`PROTO_T (EXP *ZO404)`
		3344	`{`
		3345	`EXP ZI404;`
		3346
		3347	`if ((CURRENT_TERMINAL) == 354) {`
		3348	`return;`
		3349	`}`
		3350	`{`
		3351	`EXP ZI416;`
		3352
		3353	`ZR503 (&ZI416);`
		3354	`if ((CURRENT_TERMINAL) == 354) {`
		3355	`RESTORE_LEXER;`
		3356	`goto ZL1;`
		3357	`}`
		3358	`{`
		3359
		3360	`(ZI404) = convert_reference ( (ZI416), REF_NORMAL ) ;`
		3361	`(ZI404) = convert_lvalue ( (ZI404) ) ;`
		3362	`}`
		3363	`}`
		3364	`goto ZL0;`
		3365	`ZL1:;`
		3366	`SAVE_LEXER (354);`
		3367	`return;`
		3368	`ZL0:;`
		3369	`*ZO404 = ZI404;`
		3370	`}`
		3371
		3372	`void`
		3373	`ZR882 PROTO_N ((ZI880, ZO881))`
		3374	`PROTO_T (EXP ZI880 X EXP *ZO881)`
		3375	`{`
		3376	`EXP ZI881;`
		3377
		3378	`ZL2_882:;`
		3379	`switch (CURRENT_TERMINAL) {`
		3380	`case 55:`
		3381	`{`
		3382	`EXP ZI448;`
		3383	`EXP ZI404;`
		3384
		3385	`{`
		3386	`{`
		3387	`switch (CURRENT_TERMINAL) {`
		3388	`case 55:`
		3389	`break;`
		3390	`default:`
		3391	`goto ZL1;`
		3392	`}`
		3393	`ADVANCE_LEXER;`
		3394	`}`
		3395	`}`
		3396	`ZR497 (&ZI448);`
		3397	`if ((CURRENT_TERMINAL) == 354) {`
		3398	`RESTORE_LEXER;`
		3399	`goto ZL1;`
		3400	`}`
		3401	`{`
		3402
		3403	`(ZI404) = make_log_and_exp ( (ZI880), (ZI448) ) ;`
		3404	`}`
		3405	`ZI880 = ZI404;`
		3406	`goto ZL2_882;`
		3407	`}`
		3408	`/UNREACHED/`
		3409	`default:`
		3410	`{`
		3411	`ZI881 = ZI880;`
		3412	`}`
		3413	`break;`
		3414	`case 354:`
		3415	`return;`
		3416	`}`
		3417	`goto ZL0;`
		3418	`ZL1:;`
		3419	`SAVE_LEXER (354);`
		3420	`return;`
		3421	`ZL0:;`
		3422	`*ZO881 = ZI881;`
		3423	`}`
		3424
		3425	`void`
		3426	`ZR755 PROTO_N ((ZO568))`
		3427	`PROTO_T (TYPE *ZO568)`
		3428	`{`
		3429	`TYPE ZI568;`
		3430
		3431	`switch (CURRENT_TERMINAL) {`
		3432	`case 2: case 25: case 47: case 94: case 97:`
		3433	`case 98: case 102: case 104: case 105: case 106:`
		3434	`case 110: case 111: case 112: case 114: case 115:`
		3435	`case 117: case 118: case 120: case 121: case 122:`
		3436	`case 123: case 124: case 137: case 156: case 184:`
		3437	`case 285: case 298:`
		3438	`{`
		3439	`int ZI747;`
		3440
		3441	`ZR743 (&ZI747);`
		3442	`if ((CURRENT_TERMINAL) == 354) {`
		3443	`RESTORE_LEXER;`
		3444	`goto ZL1;`
		3445	`}`
		3446	`{`
		3447
		3448	`(ZI568) = make_func_type ( NULL_type, (ZI747), cv_c, empty_type_set ) ;`
		3449	`}`
		3450	`}`
		3451	`break;`
		3452	`default:`
		3453	`{`
		3454	`{`
		3455
		3456	`(ZI568) = make_func_type ( NULL_type, FUNC_NO_PARAMS, cv_c, empty_type_set ) ;`
		3457	`}`
		3458	`}`
		3459	`break;`
		3460	`case 354:`
		3461	`return;`
		3462	`}`
		3463	`goto ZL0;`
		3464	`ZL1:;`
		3465	`SAVE_LEXER (354);`
		3466	`return;`
		3467	`ZL0:;`
		3468	`*ZO568 = ZI568;`
		3469	`}`
		3470
		3471	`void`
		3472	`ZR731 PROTO_N ((ZO420))`
		3473	`PROTO_T (TYPE *ZO420)`
		3474	`{`
		3475	`TYPE ZI420;`
		3476
		3477	`if ((CURRENT_TERMINAL) == 354) {`
		3478	`return;`
		3479	`}`
		3480	`{`
		3481	`CV_SPEC ZI630;`
		3482
		3483	`switch (CURRENT_TERMINAL) {`
		3484	`case 78:`
		3485	`break;`
		3486	`default:`
		3487	`goto ZL1;`
		3488	`}`
		3489	`ADVANCE_LEXER;`
		3490	`ZR635 (&ZI630);`
		3491	`if ((CURRENT_TERMINAL) == 354) {`
		3492	`RESTORE_LEXER;`
		3493	`goto ZL1;`
		3494	`}`
		3495	`{`
		3496
		3497	`MAKE_type_ptr ( (ZI630), NULL_type, (ZI420) ) ;`
		3498	`}`
		3499	`}`
		3500	`goto ZL0;`
		3501	`ZL1:;`
		3502	`SAVE_LEXER (354);`
		3503	`return;`
		3504	`ZL0:;`
		3505	`*ZO420 = ZI420;`
		3506	`}`
		3507
		3508	`void`
		3509	`ZR757 PROTO_N ((ZO404))`
		3510	`PROTO_T (EXP *ZO404)`
		3511	`{`
		3512	`EXP ZI404;`
		3513
		3514	`switch (CURRENT_TERMINAL) {`
		3515	`case 1: case 17: case 18: case 19: case 20:`
		3516	`case 21: case 22: case 23: case 33: case 43:`
		3517	`case 59: case 61: case 62: case 65: case 69:`
		3518	`case 71: case 78: case 85: case 116: case 170:`
		3519	`case 205: case 209:`
		3520	`{`
		3521	`ZR518 (&ZI404);`
		3522	`if ((CURRENT_TERMINAL) == 354) {`
		3523	`RESTORE_LEXER;`
		3524	`goto ZL1;`
		3525	`}`
		3526	`}`
		3527	`break;`
		3528	`default:`
		3529	`{`
		3530	`{`
		3531
		3532	`(ZI404) = NULL_exp ;`
		3533	`}`
		3534	`}`
		3535	`break;`
		3536	`case 354:`
		3537	`return;`
		3538	`}`
		3539	`goto ZL0;`
		3540	`ZL1:;`
		3541	`SAVE_LEXER (354);`
		3542	`return;`
		3543	`ZL0:;`
		3544	`*ZO404 = ZI404;`
		3545	`}`
		3546
		3547	`void`
		3548	`ZR488 PROTO_N ((ZO901))`
		3549	`PROTO_T (EXP *ZO901)`
		3550	`{`
		3551	`EXP ZI901;`
		3552
		3553	`if ((CURRENT_TERMINAL) == 354) {`
		3554	`return;`
		3555	`}`
		3556	`{`
		3557	`EXP ZI404;`
		3558
		3559	`ZR485 (&ZI404);`
		3560	`ZR902 (ZI404, &ZI901);`
		3561	`if ((CURRENT_TERMINAL) == 354) {`
		3562	`RESTORE_LEXER;`
		3563	`goto ZL1;`
		3564	`}`
		3565	`}`
		3566	`goto ZL0;`
		3567	`ZL1:;`
		3568	`SAVE_LEXER (354);`
		3569	`return;`
		3570	`ZL0:;`
		3571	`*ZO901 = ZI901;`
		3572	`}`
		3573
		3574	`void`
		3575	`ZR797 PROTO_N ((ZI605, ZI658, ZI395))`
		3576	`PROTO_T (DECL_SPEC ZI605 X BASE_TYPE ZI658 X TYPE ZI395)`
		3577	`{`
		3578	`if ((CURRENT_TERMINAL) == 354) {`
		3579	`return;`
		3580	`}`
		3581	`ZL2_797:;`
		3582	`{`
		3583	`ZR796 (ZI605, ZI658, ZI395);`
		3584	`{`
		3585	`switch (CURRENT_TERMINAL) {`
		3586	`case 42:`
		3587	`{`
		3588	`ADVANCE_LEXER;`
		3589	`goto ZL2_797;`
		3590	`}`
		3591	`/UNREACHED/`
		3592	`case 354:`
		3593	`RESTORE_LEXER;`
		3594	`goto ZL1;`
		3595	`default:`
		3596	`break;`
		3597	`}`
		3598	`}`
		3599	`}`
		3600	`return;`
		3601	`ZL1:;`
		3602	`SAVE_LEXER (354);`
		3603	`return;`
		3604	`}`
		3605
		3606	`void`
		3607	`ZR758 PROTO_N ((ZO747))`
		3608	`PROTO_T (int *ZO747)`
		3609	`{`
		3610	`int ZI747;`
		3611
		3612	`switch (CURRENT_TERMINAL) {`
		3613	`case 2: case 25: case 47: case 94: case 97:`
		3614	`case 98: case 102: case 104: case 105: case 106:`
		3615	`case 110: case 111: case 112: case 114: case 115:`
		3616	`case 117: case 118: case 120: case 121: case 122:`
		3617	`case 123: case 124: case 137: case 156: case 184:`
		3618	`case 285: case 298:`
		3619	`{`
		3620	`ZR743 (&ZI747);`
		3621	`if ((CURRENT_TERMINAL) == 354) {`
		3622	`RESTORE_LEXER;`
		3623	`goto ZL1;`
		3624	`}`
		3625	`}`
		3626	`break;`
		3627	`default:`
		3628	`{`
		3629	`{`
		3630	`(ZI747) = 0 ;`
		3631	`}`
		3632	`}`
		3633	`break;`
		3634	`case 354:`
		3635	`return;`
		3636	`}`
		3637	`goto ZL0;`
		3638	`ZL1:;`
		3639	`SAVE_LEXER (354);`
		3640	`return;`
		3641	`ZL0:;`
		3642	`*ZO747 = ZI747;`
		3643	`}`
		3644
		3645	`void`
		3646	`ZR886 PROTO_N ((ZI884, ZO885))`
		3647	`PROTO_T (EXP ZI884 X EXP *ZO885)`
		3648	`{`
		3649	`EXP ZI885;`
		3650
		3651	`ZL2_886:;`
		3652	`switch (CURRENT_TERMINAL) {`
		3653	`case 67:`
		3654	`{`
		3655	`EXP ZI448;`
		3656	`EXP ZI404;`
		3657
		3658	`{`
		3659	`{`
		3660	`switch (CURRENT_TERMINAL) {`
		3661	`case 67:`
		3662	`break;`
		3663	`default:`
		3664	`goto ZL1;`
		3665	`}`
		3666	`ADVANCE_LEXER;`
		3667	`}`
		3668	`}`
		3669	`ZR495 (&ZI448);`
		3670	`if ((CURRENT_TERMINAL) == 354) {`
		3671	`RESTORE_LEXER;`
		3672	`goto ZL1;`
		3673	`}`
		3674	`{`
		3675
		3676	`(ZI404) = make_or_exp ( (ZI884), (ZI448) ) ;`
		3677	`}`
		3678	`ZI884 = ZI404;`
		3679	`goto ZL2_886;`
		3680	`}`
		3681	`/UNREACHED/`
		3682	`default:`
		3683	`{`
		3684	`ZI885 = ZI884;`
		3685	`}`
		3686	`break;`
		3687	`case 354:`
		3688	`return;`
		3689	`}`
		3690	`goto ZL0;`
		3691	`ZL1:;`
		3692	`SAVE_LEXER (354);`
		3693	`return;`
		3694	`ZL0:;`
		3695	`*ZO885 = ZI885;`
		3696	`}`
		3697
		3698	`void`
		3699	`ZR1014 PROTO_N ((ZI1013, ZO404))`
		3700	`PROTO_T (EXP ZI1013 X EXP ZO404)`
		3701	`{`
		3702	`EXP ZI404;`
		3703
		3704	`switch (CURRENT_TERMINAL) {`
		3705	`case 36:`
		3706	`{`
		3707	`EXP ZI448;`
		3708
		3709	`ADVANCE_LEXER;`
		3710	`ZR419 (&ZI448);`
		3711	`if ((CURRENT_TERMINAL) == 354) {`
		3712	`RESTORE_LEXER;`
		3713	`goto ZL1;`
		3714	`}`
		3715	`{`
		3716
		3717	`(ZI404) = make_assign_exp ( (*ZI1013), (ZI448), 1 ) ;`
		3718	`}`
		3719	`}`
		3720	`break;`
		3721	`default:`
		3722	`{`
		3723	`EXP ZI960;`
		3724	`EXP ZI959;`
		3725	`EXP ZI958;`
		3726	`EXP ZI957;`
		3727	`EXP ZI956;`
		3728	`EXP ZI955;`
		3729	`EXP ZI954;`
		3730	`EXP ZI953;`
		3731	`EXP ZI952;`
		3732	`EXP ZI951;`
		3733	`EXP ZI948;`
		3734
		3735	`ZR918 (*ZI1013, &ZI960);`
		3736	`ZR914 (ZI960, &ZI959);`
		3737	`ZR910 (ZI959, &ZI958);`
		3738	`ZR906 (ZI958, &ZI957);`
		3739	`ZR902 (ZI957, &ZI956);`
		3740	`ZR898 (ZI956, &ZI955);`
		3741	`ZR894 (ZI955, &ZI954);`
		3742	`ZR890 (ZI954, &ZI953);`
		3743	`ZR886 (ZI953, &ZI952);`
		3744	`ZR882 (ZI952, &ZI951);`
		3745	`ZR878 (ZI951, &ZI948);`
		3746	`ZR950 (&ZI948, &ZI404);`
		3747	`if ((CURRENT_TERMINAL) == 354) {`
		3748	`RESTORE_LEXER;`
		3749	`goto ZL1;`
		3750	`}`
		3751	`}`
		3752	`break;`
		3753	`case 34: case 45: case 58: case 60: case 68:`
		3754	`case 70: case 74: case 76: case 79: case 81:`
		3755	`{`
		3756	`int ZI460;`
		3757	`EXP ZI448;`
		3758
		3759	`{`
		3760	`(ZI460) = crt_lex_token ;`
		3761	`}`
		3762	`ZR506 ();`
		3763	`ZR419 (&ZI448);`
		3764	`if ((CURRENT_TERMINAL) == 354) {`
		3765	`RESTORE_LEXER;`
		3766	`goto ZL1;`
		3767	`}`
		3768	`{`
		3769
		3770	`/* op will be in its primary form */`
		3771	`(ZI404) = make_become_exp ( (ZI460), (*ZI1013), (ZI448) ) ;`
		3772	`}`
		3773	`}`
		3774	`break;`
		3775	`case 354:`
		3776	`return;`
		3777	`}`
		3778	`goto ZL0;`
		3779	`ZL1:;`
		3780	`SAVE_LEXER (354);`
		3781	`return;`
		3782	`ZL0:;`
		3783	`*ZO404 = ZI404;`
		3784	`}`
		3785
		3786	`void`
		3787	`ZR476 PROTO_N ((ZO917))`
		3788	`PROTO_T (EXP *ZO917)`
		3789	`{`
		3790	`EXP ZI917;`
		3791
		3792	`if ((CURRENT_TERMINAL) == 354) {`
		3793	`return;`
		3794	`}`
		3795	`{`
		3796	`EXP ZI404;`
		3797
		3798	`ZR459 (&ZI404);`
		3799	`ZR918 (ZI404, &ZI917);`
		3800	`if ((CURRENT_TERMINAL) == 354) {`
		3801	`RESTORE_LEXER;`
		3802	`goto ZL1;`
		3803	`}`
		3804	`}`
		3805	`goto ZL0;`
		3806	`ZL1:;`
		3807	`SAVE_LEXER (354);`
		3808	`return;`
		3809	`ZL0:;`
		3810	`*ZO917 = ZI917;`
		3811	`}`
		3812
		3813	`/* BEGINNING OF TRAILER */`
		3814
		3815
		3816
		3817	`/* END OF FILE */`

Subversion Repositories tendra.SVN

(root)/trunk/src/producers/c/syntax/syntax3.c – Rev 2