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

Subversion Repositories tendra.SVN

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