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

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/producers/c/syntax/syntax2.c – Rev 2