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

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

Subversion Repositories tendra.SVN

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