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

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

Subversion Repositories tendra.SVN

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