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

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

Subversion Repositories tendra.SVN

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