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

Subversion Repositories tendra.SVN

(root)/branches/tendra5-amd64/src/producers/cpp/syntax/syntax1.c – Rev 123