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

Subversion Repositories tendra.SVN

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