WebSVN – tendra.SVN – Blame – /trunk/src/producers/c/syntax/syntax2.c

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

Subversion Repositories tendra.SVN

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