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

Subversion Repositories tendra.SVN

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