WebSVN – tendra.SVN – Blame – /branches/tendra5/src/producers/cpp/syntax/syntax7.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	`ZR869 PROTO_N ((ZO419))`
		135	`PROTO_T (IDENTIFIER *ZO419)`
		136	`{`
		137	`IDENTIFIER ZI419;`
		138
		139	`switch (CURRENT_TERMINAL) {`
		140	`case 1: case 2: case 3: case 4: case 7:`
		141	`case 8: case 9: case 83:`
		142	`{`
		143	`NAMESPACE ZI425;`
		144	`IDENTIFIER ZI820;`
		145
		146	`ZR428 (&ZI425);`
		147	`ZR508 (&ZI820);`
		148	`if ((CURRENT_TERMINAL) == 354) {`
		149	`RESTORE_LEXER;`
		150	`goto ZL1;`
		151	`}`
		152	`{`
		153
		154	`(ZI419) = check_id ( (ZI425), (ZI820), 0 ) ;`
		155	`last_namespace = (ZI425) ;`
		156	`}`
		157	`}`
		158	`break;`
		159	`default:`
		160	`{`
		161	`{`
		162
		163	`HASHID nm = lookup_anon () ;`
		164	`(ZI419) = DEREF_id ( hashid_id ( nm ) ) ;`
		165	`crt_id_qualifier = qual_none ;`
		166	`qual_namespace = NULL_nspace ;`
		167	`}`
		168	`}`
		169	`break;`
		170	`case 354:`
		171	`return;`
		172	`}`
		173	`goto ZL0;`
		174	`ZL1:;`
		175	`SAVE_LEXER (354);`
		176	`return;`
		177	`ZL0:;`
		178	`*ZO419 = ZI419;`
		179	`}`
		180
		181	`void`
		182	`parse_mem_type PROTO_N ((ZO414))`
		183	`PROTO_T (TYPE *ZO414)`
		184	`{`
		185	`TYPE ZI414;`
		186
		187	`if ((CURRENT_TERMINAL) == 354) {`
		188	`return;`
		189	`}`
		190	`{`
		191	`BASE_TYPE ZI511;`
		192	`TYPE ZI497;`
		193	`CV_SPEC ZI783;`
		194	`TYPE ZI480;`
		195
		196	`ZR873 (&ZI511, &ZI497, &ZI783);`
		197	`if ((CURRENT_TERMINAL) == 354) {`
		198	`RESTORE_LEXER;`
		199	`goto ZL1;`
		200	`}`
		201	`{`
		202
		203	`(ZI480) = complete_pre_type ( (ZI511), (ZI497), (ZI783), 1 ) ;`
		204	`have_type_specifier = 0 ;`
		205	`}`
		206	`{`
		207	`switch (CURRENT_TERMINAL) {`
		208	`case 73:`
		209	`{`
		210	`QUALIFIER ZI455;`
		211	`int ZI456;`
		212	`EXP ZI558;`
		213
		214	`ADVANCE_LEXER;`
		215	`{`
		216
		217	`(ZI455) = crt_id_qualifier ;`
		218	`(ZI456) = crt_templ_qualifier ;`
		219	`}`
		220	`ZR651 (&ZI558);`
		221	`if ((CURRENT_TERMINAL) == 354) {`
		222	`RESTORE_LEXER;`
		223	`goto ZL1;`
		224	`}`
		225	`{`
		226
		227	`(ZI414) = make_bitfield_type ( (ZI480), (ZI511), (ZI558), 0 ) ;`
		228	`}`
		229	`{`
		230
		231	`crt_id_qualifier = (ZI455) ;`
		232	`crt_templ_qualifier = (ZI456) ;`
		233	`}`
		234	`}`
		235	`break;`
		236	`default:`
		237	`{`
		238	`ZR955 (ZI480, &ZI414);`
		239	`if ((CURRENT_TERMINAL) == 354) {`
		240	`RESTORE_LEXER;`
		241	`goto ZL1;`
		242	`}`
		243	`}`
		244	`break;`
		245	`}`
		246	`}`
		247	`}`
		248	`goto ZL0;`
		249	`ZL1:;`
		250	`SAVE_LEXER (354);`
		251	`return;`
		252	`ZL0:;`
		253	`*ZO414 = ZI414;`
		254	`}`
		255
		256	`void`
		257	`ZR1252 PROTO_N ((ZI414, ZI511, ZI875, ZI876, ZI911))`
		258	`PROTO_T (TYPE ZI414 X BASE_TYPE ZI511 X TYPE ZI875 X CV_SPEC ZI876 X DECL_SPEC *ZI911)`
		259	`{`
		260	`switch (CURRENT_TERMINAL) {`
		261	`case 77:`
		262	`{`
		263	`{`
		264
		265	`IGNORE empty_decl ( (ZI911), (ZI414), (ZI511), (ZI875), (*ZI876), last_lex_token, 0 ) ;`
		266	`have_type_declaration = TYPE_DECL_NONE ;`
		267	`have_func_declarator = 0 ;`
		268	`have_type_specifier = 0 ;`
		269	`}`
		270	`{`
		271
		272	`if ( crt_access_list.pending ) {`
		273	`IGNORE report_access ( crt_func_id ) ;`
		274	`}`
		275	`}`
		276	`ADVANCE_LEXER;`
		277	`}`
		278	`break;`
		279	`case 1: case 2: case 3: case 4: case 5:`
		280	`case 6: case 7: case 8: case 9: case 10:`
		281	`case 11: case 33: case 65: case 78: case 83:`
		282	`case 141:`
		283	`{`
		284	`TYPE ZI879;`
		285	`DECL_SPEC ZI1073;`
		286	`TYPE ZI1074;`
		287	`ACCESS_LIST ZI670;`
		288	`TYPE ZI574;`
		289	`IDENTIFIER ZI419;`
		290	`int ZI558;`
		291	`IDENTIFIER ZI459;`
		292
		293	`{`
		294
		295	`/* Complete a declaration specifier and a type */`
		296	`(ZI1073) = complete_dspec ( (ZI911), (ZI511), (ZI875), (ZI876) ) ;`
		297	`(ZI879) = complete_pre_type ( (ZI511), (ZI875), (*ZI876), 0 ) ;`
		298	`have_type_specifier = 0 ;`
		299	`}`
		300	`{`
		301
		302	`(ZI1074) = ( IS_NULL_type ( (ZI414) ) ? (ZI879) : inject_pre_type ( (ZI414), (ZI879), 1 ) ) ;`
		303	`}`
		304	`{`
		305
		306	`save_access ( &(ZI670) ) ;`
		307	`}`
		308	`{`
		309
		310	`crt_templ_qualifier = 0 ;`
		311	`}`
		312	`ZR950 (ZI1074, &ZI574, &ZI419, &ZI558);`
		313	`if ((CURRENT_TERMINAL) == 354) {`
		314	`RESTORE_LEXER;`
		315	`goto ZL1;`
		316	`}`
		317	`{`
		318
		319	`if ( type_tag ( (ZI574) ) == type_func_tag ) {`
		320	`/* Look ahead for function definitions */`
		321	`int def = predict_func_defn () ;`
		322	`if ( def & !have_func_declarator ) adjust_param ( (ZI574) ) ;`
		323	`(ZI459) = make_func_decl ( (ZI1073), (ZI574), (ZI419), def ) ;`
		324	`is_function_next = def ;`
		325	`} else {`
		326	`int def = predict_obj_defn () ;`
		327	`(ZI459) = make_object_decl ( (ZI1073), (ZI574), (ZI419), def ) ;`
		328	`is_function_next = 0 ;`
		329	`}`
		330	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		331	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		332	`bs \|= (*ZI511) ;`
		333	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		334	`}`
		335	`have_type_declaration = TYPE_DECL_NONE ;`
		336	`have_func_declarator = 0 ;`
		337	`}`
		338	`{`
		339
		340	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		341	`}`
		342	`{`
		343
		344	`if ( crt_access_list.pending ) {`
		345	`IGNORE report_access ( (ZI459) ) ;`
		346	`}`
		347	`}`
		348	`ZR1075 (ZI511, &ZI1073, &ZI1074, &ZI670, &ZI558, &ZI459);`
		349	`if ((CURRENT_TERMINAL) == 354) {`
		350	`RESTORE_LEXER;`
		351	`goto ZL1;`
		352	`}`
		353	`}`
		354	`break;`
		355	`case 354:`
		356	`return;`
		357	`default:`
		358	`goto ZL1;`
		359	`}`
		360	`return;`
		361	`ZL1:;`
		362	`SAVE_LEXER (354);`
		363	`return;`
		364	`}`
		365
		366	`void`
		367	`parse_operator PROTO_N ((ZO419))`
		368	`PROTO_T (IDENTIFIER *ZO419)`
		369	`{`
		370	`IDENTIFIER ZI419;`
		371
		372	`if ((CURRENT_TERMINAL) == 354) {`
		373	`return;`
		374	`}`
		375	`{`
		376	`QUALIFIER ZI455;`
		377	`int ZI456;`
		378	`int ZI457;`
		379	`IDENTIFIER ZI460;`
		380
		381	`switch (CURRENT_TERMINAL) {`
		382	`case 141:`
		383	`break;`
		384	`default:`
		385	`goto ZL1;`
		386	`}`
		387	`ADVANCE_LEXER;`
		388	`{`
		389
		390	`(ZI455) = crt_id_qualifier ;`
		391	`(ZI456) = crt_templ_qualifier ;`
		392	`}`
		393	`{`
		394
		395	`(ZI457) = have_type_declaration ;`
		396	`have_type_declaration = TYPE_DECL_NONE ;`
		397	`}`
		398	`{`
		399	`{`
		400	`TYPE ZI1318;`
		401	`BASE_TYPE ZI874;`
		402	`TYPE ZI875;`
		403	`CV_SPEC ZI876;`
		404	`BASE_TYPE ZI511;`
		405	`TYPE ZI497;`
		406	`CV_SPEC ZI783;`
		407	`TYPE ZI574;`
		408	`TYPE ZI480;`
		409	`TYPE ZI414;`
		410	`int ZI459;`
		411
		412	`{`
		413
		414	`/* Resolve type-specifiers from other declarators */`
		415	`(ZI0) = predict_tspec ( 0 ) ;`
		416	`}`
		417	`if (!ZI0)`
		418	`goto ZL3;`
		419	`{`
		420
		421	`(ZI1318) = NULL_type ;`
		422	`}`
		423	`ZR872 (ZI1318, &ZI874, &ZI875, &ZI876);`
		424	`ZR885 (&ZI874, &ZI875, &ZI876, &ZI511, &ZI497, &ZI783);`
		425	`if ((CURRENT_TERMINAL) == 354) {`
		426	`RESTORE_LEXER;`
		427	`goto ZL1;`
		428	`}`
		429	`{`
		430
		431	`(ZI574) = complete_pre_type ( (ZI511), (ZI497), (ZI783), 1 ) ;`
		432	`have_type_specifier = 0 ;`
		433	`}`
		434	`ZR987 (&ZI480);`
		435	`if ((CURRENT_TERMINAL) == 354) {`
		436	`RESTORE_LEXER;`
		437	`goto ZL1;`
		438	`}`
		439	`{`
		440
		441	`(ZI414) = ( IS_NULL_type ( (ZI480) ) ? (ZI574) : inject_pre_type ( (ZI480), (ZI574), 1 ) ) ;`
		442	`}`
		443	`{`
		444
		445	`int td = have_type_declaration ;`
		446	`(ZI459) = 0 ;`
		447	`if ( td != TYPE_DECL_NONE ) {`
		448	`if ( td == TYPE_DECL_ELABORATE && found_elaborate_type ) {`
		449	`/* This is allowed */`
		450	`/* EMPTY */`
		451	`} else {`
		452	`(ZI459) = 1 ;`
		453	`}`
		454	`}`
		455	`have_type_declaration = (ZI457) ;`
		456	`}`
		457	`{`
		458
		459	`HASHID nm = lookup_conv ( (ZI414) ) ;`
		460	`if ( (ZI459) ) report ( crt_loc, ERR_class_conv_fct_typedef ( nm ) ) ;`
		461	`(ZI460) = DEREF_id ( hashid_id ( nm ) ) ;`
		462	`set_hashid_loc ( (ZI460), underlying_op ) ;`
		463	`}`
		464	`goto ZL2;`
		465	`}`
		466	`/UNREACHED/`
		467	`ZL3:;`
		468	`switch (CURRENT_TERMINAL) {`
		469	`case 33: case 34: case 35: case 36: case 41:`
		470	`case 42: case 43: case 44: case 45: case 46:`
		471	`case 48: case 49: case 50: case 53: case 54:`
		472	`case 55: case 56: case 57: case 58: case 59:`
		473	`case 60: case 61: case 62: case 63: case 65:`
		474	`case 66: case 67: case 68: case 69: case 70:`
		475	`case 71: case 72: case 73: case 74: case 75:`
		476	`case 76: case 78: case 79: case 80: case 81:`
		477	`case 82: case 83: case 84: case 85: case 86:`
		478	`case 87: case 116: case 131: case 140: case 152:`
		479	`case 170: case 329:`
		480	`{`
		481	`int ZI450;`
		482
		483	`ZR451 (&ZI450);`
		484	`if ((CURRENT_TERMINAL) == 354) {`
		485	`RESTORE_LEXER;`
		486	`goto ZL1;`
		487	`}`
		488	`{`
		489
		490	`have_type_declaration = (ZI457) ;`
		491	`}`
		492	`{`
		493
		494	`/* op will be in its primary form */`
		495	`HASHID nm = lookup_op ( (ZI450) ) ;`
		496	`(ZI460) = DEREF_id ( hashid_id ( nm ) ) ;`
		497	`set_hashid_loc ( (ZI460), underlying_op ) ;`
		498	`}`
		499	`}`
		500	`break;`
		501	`default:`
		502	`goto ZL1;`
		503	`}`
		504	`ZL2:;`
		505	`}`
		506	`{`
		507
		508	`crt_id_qualifier = (ZI455) ;`
		509	`crt_templ_qualifier = (ZI456) ;`
		510	`}`
		511	`ZI419 = ZI460;`
		512	`}`
		513	`goto ZL0;`
		514	`ZL1:;`
		515	`SAVE_LEXER (354);`
		516	`return;`
		517	`ZL0:;`
		518	`*ZO419 = ZI419;`
		519	`}`
		520
		521	`void`
		522	`ZR1083 PROTO_N ((ZO431))`
		523	`PROTO_T (EXP *ZO431)`
		524	`{`
		525	`EXP ZI431;`
		526
		527	`switch (CURRENT_TERMINAL) {`
		528	`case 36:`
		529	`{`
		530	`ADVANCE_LEXER;`
		531	`ZR651 (&ZI431);`
		532	`if ((CURRENT_TERMINAL) == 354) {`
		533	`RESTORE_LEXER;`
		534	`goto ZL1;`
		535	`}`
		536	`}`
		537	`break;`
		538	`default:`
		539	`{`
		540	`{`
		541
		542	`(ZI431) = NULL_exp ;`
		543	`}`
		544	`}`
		545	`break;`
		546	`case 354:`
		547	`return;`
		548	`}`
		549	`goto ZL0;`
		550	`ZL1:;`
		551	`SAVE_LEXER (354);`
		552	`return;`
		553	`ZL0:;`
		554	`*ZO431 = ZI431;`
		555	`}`
		556
		557	`void`
		558	`ZR1254 PROTO_N ((ZI414, ZI689, ZI511, ZI875, ZI1253, ZO431))`
		559	`PROTO_T (TYPE ZI414 X DECL_SPEC ZI689 X BASE_TYPE ZI511 X TYPE ZI875 X CV_SPEC ZI1253 X EXP ZO431)`
		560	`{`
		561	`EXP ZI431;`
		562
		563	`switch (CURRENT_TERMINAL) {`
		564	`case 77:`
		565	`{`
		566	`{`
		567
		568	`IGNORE empty_decl ( (ZI689), (ZI414), (ZI511), (ZI875), (*ZI1253), last_lex_token, 0 ) ;`
		569	`have_type_declaration = TYPE_DECL_NONE ;`
		570	`have_func_declarator = 0 ;`
		571	`have_type_specifier = 0 ;`
		572	`}`
		573	`ADVANCE_LEXER;`
		574	`{`
		575
		576	`(ZI431) = NULL_exp ;`
		577	`}`
		578	`}`
		579	`break;`
		580	`case 1: case 2: case 3: case 4: case 5:`
		581	`case 6: case 7: case 8: case 9: case 10:`
		582	`case 11: case 33: case 65: case 78: case 83:`
		583	`case 141:`
		584	`{`
		585	`DECL_SPEC ZI909;`
		586	`DECL_SPEC ZI911;`
		587	`TYPE ZI879;`
		588	`DECL_SPEC ZI1073;`
		589	`TYPE ZI1074;`
		590	`ACCESS_LIST ZI670;`
		591	`TYPE ZI574;`
		592	`IDENTIFIER ZI419;`
		593	`int ZI558;`
		594	`IDENTIFIER ZI459;`
		595
		596	`{`
		597	`(ZI909) = dspec_none ;`
		598	`}`
		599	`{`
		600
		601	`/* Combine two declaration specifiers */`
		602	`DECL_SPEC d = ( ( (*ZI689) & (ZI909) ) & dspec_duplicate ) ;`
		603	`if ( d ) report ( crt_loc, ERR_dcl_spec_dup ( d ) ) ;`
		604	`(ZI911) = ( (*ZI689) \| (ZI909) ) ;`
		605	`}`
		606	`{`
		607
		608	`/* Complete a declaration specifier and a type */`
		609	`(ZI1073) = complete_dspec ( (ZI911), (ZI511), (ZI875), (*ZI1253) ) ;`
		610	`(ZI879) = complete_pre_type ( (ZI511), (ZI875), (*ZI1253), 0 ) ;`
		611	`have_type_specifier = 0 ;`
		612	`}`
		613	`{`
		614
		615	`(ZI1074) = ( IS_NULL_type ( (ZI414) ) ? (ZI879) : inject_pre_type ( (ZI414), (ZI879), 1 ) ) ;`
		616	`}`
		617	`{`
		618
		619	`save_access ( &(ZI670) ) ;`
		620	`}`
		621	`{`
		622
		623	`crt_templ_qualifier = 0 ;`
		624	`}`
		625	`ZR950 (ZI1074, &ZI574, &ZI419, &ZI558);`
		626	`if ((CURRENT_TERMINAL) == 354) {`
		627	`RESTORE_LEXER;`
		628	`goto ZL1;`
		629	`}`
		630	`{`
		631
		632	`if ( type_tag ( (ZI574) ) == type_func_tag ) {`
		633	`/* Look ahead for function definitions */`
		634	`int def = predict_func_defn () ;`
		635	`if ( def & !have_func_declarator ) adjust_param ( (ZI574) ) ;`
		636	`(ZI459) = make_func_decl ( (ZI1073), (ZI574), (ZI419), def ) ;`
		637	`is_function_next = def ;`
		638	`} else {`
		639	`int def = predict_obj_defn () ;`
		640	`(ZI459) = make_object_decl ( (ZI1073), (ZI574), (ZI419), def ) ;`
		641	`is_function_next = 0 ;`
		642	`}`
		643	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		644	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		645	`bs \|= (*ZI511) ;`
		646	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		647	`}`
		648	`have_type_declaration = TYPE_DECL_NONE ;`
		649	`have_func_declarator = 0 ;`
		650	`}`
		651	`{`
		652
		653	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		654	`}`
		655	`{`
		656
		657	`if ( crt_access_list.pending ) {`
		658	`IGNORE report_access ( (ZI459) ) ;`
		659	`}`
		660	`}`
		661	`ZR1075 (ZI511, &ZI1073, &ZI1074, &ZI670, &ZI558, &ZI459);`
		662	`if ((CURRENT_TERMINAL) == 354) {`
		663	`RESTORE_LEXER;`
		664	`goto ZL1;`
		665	`}`
		666	`{`
		667
		668	`(ZI431) = NULL_exp ;`
		669	`}`
		670	`}`
		671	`break;`
		672	`case 354:`
		673	`return;`
		674	`default:`
		675	`goto ZL1;`
		676	`}`
		677	`goto ZL0;`
		678	`ZL1:;`
		679	`SAVE_LEXER (354);`
		680	`return;`
		681	`ZL0:;`
		682	`*ZO431 = ZI431;`
		683	`}`
		684
		685	`void`
		686	`ZR626 PROTO_N ((ZO1199))`
		687	`PROTO_T (EXP *ZO1199)`
		688	`{`
		689	`EXP ZI1199;`
		690
		691	`if ((CURRENT_TERMINAL) == 354) {`
		692	`return;`
		693	`}`
		694	`{`
		695	`EXP ZI431;`
		696
		697	`ZR624 (&ZI431);`
		698	`ZR1200 (ZI431, &ZI1199);`
		699	`if ((CURRENT_TERMINAL) == 354) {`
		700	`RESTORE_LEXER;`
		701	`goto ZL1;`
		702	`}`
		703	`}`
		704	`goto ZL0;`
		705	`ZL1:;`
		706	`SAVE_LEXER (354);`
		707	`return;`
		708	`ZL0:;`
		709	`*ZO1199 = ZI1199;`
		710	`}`
		711
		712	`void`
		713	`ZR1382 PROTO_N ((ZI1380, ZO414))`
		714	`PROTO_T (TYPE ZI1380 X TYPE ZO414)`
		715	`{`
		716	`TYPE ZI414;`
		717
		718	`switch (CURRENT_TERMINAL) {`
		719	`case 10: case 11: case 33: case 65: case 66:`
		720	`case 78: case 331:`
		721	`{`
		722	`TYPE ZI480;`
		723
		724	`ZR951 (&ZI480);`
		725	`if ((CURRENT_TERMINAL) == 354) {`
		726	`RESTORE_LEXER;`
		727	`goto ZL1;`
		728	`}`
		729	`{`
		730
		731	`(ZI414) = ( IS_NULL_type ( (ZI480) ) ? (ZI1380) : inject_pre_type ( (ZI480), (ZI1380), 0 ) ) ;`
		732	`}`
		733	`}`
		734	`break;`
		735	`default:`
		736	`{`
		737	`ZI414 = *ZI1380;`
		738	`}`
		739	`break;`
		740	`case 354:`
		741	`return;`
		742	`}`
		743	`goto ZL0;`
		744	`ZL1:;`
		745	`SAVE_LEXER (354);`
		746	`return;`
		747	`ZL0:;`
		748	`*ZO414 = ZI414;`
		749	`}`
		750
		751	`void`
		752	`ZR1255 PROTO_Z ()`
		753	`{`
		754	`switch (CURRENT_TERMINAL) {`
		755	`case 26: case 30:`
		756	`{`
		757	`ZR1030 ();`
		758	`if ((CURRENT_TERMINAL) == 354) {`
		759	`RESTORE_LEXER;`
		760	`goto ZL1;`
		761	`}`
		762	`{`
		763
		764	`if ( crt_access_list.pending ) {`
		765	`IGNORE report_access ( crt_func_id ) ;`
		766	`}`
		767	`}`
		768	`}`
		769	`break;`
		770	`case 126: case 139: case 154:`
		771	`{`
		772	`EXP ZI431;`
		773
		774	`ZR1077 (&ZI431);`
		775	`if ((CURRENT_TERMINAL) == 354) {`
		776	`RESTORE_LEXER;`
		777	`goto ZL1;`
		778	`}`
		779	`{`
		780
		781	`external_declaration ( (ZI431), 1 ) ;`
		782	`}`
		783	`}`
		784	`break;`
		785	`case 354:`
		786	`return;`
		787	`default:`
		788	`goto ZL1;`
		789	`}`
		790	`return;`
		791	`ZL1:;`
		792	`SAVE_LEXER (354);`
		793	`return;`
		794	`}`
		795
		796	`void`
		797	`ZR1001 PROTO_N ((ZI459, ZO497))`
		798	`PROTO_T (IDENTIFIER ZI459 X SID_LIST_EXP ZO497)`
		799	`{`
		800	`SID_LIST_EXP ZI497;`
		801
		802	`switch (CURRENT_TERMINAL) {`
		803	`case 1: case 2: case 3: case 5: case 6:`
		804	`case 7: case 8: case 9: case 17: case 18:`
		805	`case 19: case 20: case 21: case 22: case 23:`
		806	`case 25: case 33: case 43: case 59: case 61:`
		807	`case 62: case 64: case 65: case 69: case 71:`
		808	`case 78: case 83: case 85: case 97: case 102:`
		809	`case 106: case 110: case 111: case 114: case 115:`
		810	`case 116: case 122: case 123: case 127: case 130:`
		811	`case 131: case 132: case 135: case 140: case 141:`
		812	`case 145: case 146: case 148: case 149: case 150:`
		813	`case 152: case 156: case 170: case 184: case 205:`
		814	`case 209: case 285: case 298: case 329:`
		815	`{`
		816	`ZR999 (*ZI459, &ZI497);`
		817	`if ((CURRENT_TERMINAL) == 354) {`
		818	`RESTORE_LEXER;`
		819	`goto ZL1;`
		820	`}`
		821	`}`
		822	`break;`
		823	`default:`
		824	`{`
		825	`{`
		826
		827	`(ZI497) = NULL_list ( EXP ) ;`
		828	`}`
		829	`}`
		830	`break;`
		831	`case 354:`
		832	`return;`
		833	`}`
		834	`goto ZL0;`
		835	`ZL1:;`
		836	`SAVE_LEXER (354);`
		837	`return;`
		838	`ZL0:;`
		839	`*ZO497 = ZI497;`
		840	`}`
		841
		842	`void`
		843	`ZR751 PROTO_N ((ZO431))`
		844	`PROTO_T (EXP *ZO431)`
		845	`{`
		846	`EXP ZI431;`
		847
		848	`switch (CURRENT_TERMINAL) {`
		849	`case 96:`
		850	`{`
		851	`EXP ZI558;`
		852
		853	`ADVANCE_LEXER;`
		854	`ZR651 (&ZI558);`
		855	`if ((CURRENT_TERMINAL) == 354) {`
		856	`RESTORE_LEXER;`
		857	`goto ZL1;`
		858	`}`
		859	`{`
		860
		861	`report ( crt_loc, ERR_stmt_goto_case ( lex_case ) ) ;`
		862	`(ZI431) = begin_case_stmt ( (ZI558), 1 ) ;`
		863	`}`
		864	`}`
		865	`break;`
		866	`case 100:`
		867	`{`
		868	`ADVANCE_LEXER;`
		869	`{`
		870
		871	`report ( crt_loc, ERR_stmt_goto_case ( lex_default ) ) ;`
		872	`(ZI431) = begin_default_stmt ( 1 ) ;`
		873	`}`
		874	`}`
		875	`break;`
		876	`case 1: case 2: case 3: case 4:`
		877	`{`
		878	`IDENTIFIER ZI419;`
		879
		880	`{`
		881	`switch (CURRENT_TERMINAL) {`
		882	`case 1:`
		883	`{`
		884	`{`
		885
		886	`ZI419 = crt_token->pp_data.id.use ;`
		887	`}`
		888	`ADVANCE_LEXER;`
		889	`}`
		890	`break;`
		891	`case 3:`
		892	`{`
		893	`{`
		894
		895	`ZI419 = crt_token->pp_data.id.use ;`
		896	`}`
		897	`ADVANCE_LEXER;`
		898	`}`
		899	`break;`
		900	`case 4:`
		901	`{`
		902	`{`
		903
		904	`ZI419 = crt_token->pp_data.id.use ;`
		905	`}`
		906	`ADVANCE_LEXER;`
		907	`}`
		908	`break;`
		909	`case 2:`
		910	`{`
		911	`{`
		912
		913	`ZI419 = crt_token->pp_data.id.use ;`
		914	`}`
		915	`ADVANCE_LEXER;`
		916	`}`
		917	`break;`
		918	`default:`
		919	`goto ZL1;`
		920	`}`
		921	`}`
		922	`{`
		923
		924	`crt_id_qualifier = qual_none ;`
		925	`crt_templ_qualifier = 0 ;`
		926	`qual_namespace = NULL_nspace ;`
		927	`}`
		928	`{`
		929
		930	`(ZI431) = make_goto_stmt ( (ZI419) ) ;`
		931	`}`
		932	`}`
		933	`break;`
		934	`case 354:`
		935	`return;`
		936	`default:`
		937	`goto ZL1;`
		938	`}`
		939	`goto ZL0;`
		940	`ZL1:;`
		941	`SAVE_LEXER (354);`
		942	`return;`
		943	`ZL0:;`
		944	`*ZO431 = ZI431;`
		945	`}`
		946
		947	`void`
		948	`ZR808 PROTO_N ((ZO511, ZO414))`
		949	`PROTO_T (BASE_TYPE ZO511 X TYPE ZO414)`
		950	`{`
		951	`BASE_TYPE ZI511;`
		952	`TYPE ZI414;`
		953
		954	`switch (CURRENT_TERMINAL) {`
		955	`case 25:`
		956	`{`
		957	`{`
		958
		959	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		960	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		961	`ZI414 = parse_type_token ( id, args ) ;`
		962	`have_type_declaration = TYPE_DECL_NONE ;`
		963	`have_type_specifier = 1 ;`
		964	`RESCAN_LEXER ;`
		965	`}`
		966	`ADVANCE_LEXER;`
		967	`{`
		968	`(ZI511) = btype_none ;`
		969	`}`
		970	`}`
		971	`break;`
		972	`case 8: case 9: case 83:`
		973	`{`
		974	`IDENTIFIER ZI419;`
		975
		976	`ZR473 (&ZI419);`
		977	`if ((CURRENT_TERMINAL) == 354) {`
		978	`RESTORE_LEXER;`
		979	`goto ZL1;`
		980	`}`
		981	`{`
		982
		983	`MAKE_type_pre ( cv_none, btype_alias, crt_id_qualifier, (ZI414) ) ;`
		984	`COPY_id ( type_name ( (ZI414) ), (ZI419) ) ;`
		985	`have_type_specifier = 1 ;`
		986	`}`
		987	`{`
		988	`(ZI511) = btype_none ;`
		989	`}`
		990	`}`
		991	`break;`
		992	`case 97: case 102: case 106: case 110: case 111:`
		993	`case 114: case 115: case 122: case 123: case 127:`
		994	`case 156: case 184: case 285: case 298:`
		995	`{`
		996	`ZR509 (&ZI511);`
		997	`if ((CURRENT_TERMINAL) == 354) {`
		998	`RESTORE_LEXER;`
		999	`goto ZL1;`
		1000	`}`
		1001	`{`
		1002
		1003	`(ZI414) = NULL_type ;`
		1004	`have_type_specifier = 1 ;`
		1005	`}`
		1006	`}`
		1007	`break;`
		1008	`case 2: case 7:`
		1009	`{`
		1010	`IDENTIFIER ZI419;`
		1011
		1012	`ZR472 (&ZI419);`
		1013	`if ((CURRENT_TERMINAL) == 354) {`
		1014	`RESTORE_LEXER;`
		1015	`goto ZL1;`
		1016	`}`
		1017	`{`
		1018
		1019	`MAKE_type_pre ( cv_none, btype_alias, crt_id_qualifier, (ZI414) ) ;`
		1020	`COPY_id ( type_name ( (ZI414) ), (ZI419) ) ;`
		1021	`have_type_specifier = 1 ;`
		1022	`}`
		1023	`{`
		1024	`(ZI511) = btype_none ;`
		1025	`}`
		1026	`}`
		1027	`break;`
		1028	`case 354:`
		1029	`return;`
		1030	`default:`
		1031	`goto ZL1;`
		1032	`}`
		1033	`goto ZL0;`
		1034	`ZL1:;`
		1035	`SAVE_LEXER (354);`
		1036	`return;`
		1037	`ZL0:;`
		1038	`*ZO511 = ZI511;`
		1039	`*ZO414 = ZI414;`
		1040	`}`
		1041
		1042	`void`
		1043	`ZR1383 PROTO_N ((ZO1138))`
		1044	`PROTO_T (TYPE *ZO1138)`
		1045	`{`
		1046	`TYPE ZI1138;`
		1047
		1048	`switch (CURRENT_TERMINAL) {`
		1049	`case 10: case 11: case 33: case 65: case 66:`
		1050	`case 78: case 331:`
		1051	`{`
		1052	`TYPE ZI414;`
		1053
		1054	`ZR951 (&ZI414);`
		1055	`if ((CURRENT_TERMINAL) == 354) {`
		1056	`RESTORE_LEXER;`
		1057	`goto ZL1;`
		1058	`}`
		1059	`{`
		1060
		1061	`if ( IS_NULL_type ( (ZI414) ) ) {`
		1062	`report ( crt_loc, ERR_dcl_meaning_paren () ) ;`
		1063	`}`
		1064	`}`
		1065	`switch (CURRENT_TERMINAL) {`
		1066	`case 39:`
		1067	`break;`
		1068	`default:`
		1069	`goto ZL1;`
		1070	`}`
		1071	`ADVANCE_LEXER;`
		1072	`ZR1139 (ZI414, &ZI1138);`
		1073	`if ((CURRENT_TERMINAL) == 354) {`
		1074	`RESTORE_LEXER;`
		1075	`goto ZL1;`
		1076	`}`
		1077	`}`
		1078	`break;`
		1079	`case 2: case 7: case 8: case 9: case 25:`
		1080	`case 39: case 47: case 83: case 94: case 97:`
		1081	`case 98: case 102: case 104: case 105: case 106:`
		1082	`case 110: case 111: case 112: case 114: case 115:`
		1083	`case 117: case 118: case 120: case 121: case 122:`
		1084	`case 123: case 124: case 127: case 129: case 133:`
		1085	`case 136: case 137: case 138: case 153: case 155:`
		1086	`case 156: case 184: case 274: case 285: case 298:`
		1087	`{`
		1088	`IDENTIFIER ZI419;`
		1089	`int ZI943;`
		1090	`TYPE ZI414;`
		1091
		1092	`{`
		1093
		1094	`(ZI419) = NULL_id ;`
		1095	`crt_id_qualifier = qual_none ;`
		1096	`qual_namespace = NULL_nspace ;`
		1097	`}`
		1098	`{`
		1099	`(ZI943) = 0 ;`
		1100	`}`
		1101	`{`
		1102
		1103	`func_type_defn ( 0 ) ;`
		1104	`begin_param ( (ZI419) ) ;`
		1105	`have_type_declaration = TYPE_DECL_NONE ;`
		1106	`have_func_declarator = 0 ;`
		1107	`}`
		1108	`ZR944 (ZI943, &ZI414);`
		1109	`if ((CURRENT_TERMINAL) == 354) {`
		1110	`RESTORE_LEXER;`
		1111	`goto ZL1;`
		1112	`}`
		1113	`{`
		1114
		1115	`end_param () ;`
		1116	`have_type_declaration = TYPE_DECL_NONE ;`
		1117	`have_func_declarator = 1 ;`
		1118	`}`
		1119	`ZR1139 (ZI414, &ZI1138);`
		1120	`if ((CURRENT_TERMINAL) == 354) {`
		1121	`RESTORE_LEXER;`
		1122	`goto ZL1;`
		1123	`}`
		1124	`}`
		1125	`break;`
		1126	`case 354:`
		1127	`return;`
		1128	`default:`
		1129	`goto ZL1;`
		1130	`}`
		1131	`goto ZL0;`
		1132	`ZL1:;`
		1133	`SAVE_LEXER (354);`
		1134	`return;`
		1135	`ZL0:;`
		1136	`*ZO1138 = ZI1138;`
		1137	`}`
		1138
		1139	`void`
		1140	`ZR648 PROTO_N ((ZO497))`
		1141	`PROTO_T (SID_LIST_EXP *ZO497)`
		1142	`{`
		1143	`SID_LIST_EXP ZI497;`
		1144
		1145	`switch (CURRENT_TERMINAL) {`
		1146	`case 1: case 2: case 3: case 5: case 6:`
		1147	`case 7: case 8: case 9: case 17: case 18:`
		1148	`case 19: case 20: case 21: case 22: case 23:`
		1149	`case 25: case 33: case 43: case 59: case 61:`
		1150	`case 62: case 65: case 69: case 71: case 78:`
		1151	`case 83: case 85: case 97: case 102: case 106:`
		1152	`case 110: case 111: case 114: case 115: case 116:`
		1153	`case 122: case 123: case 127: case 130: case 131:`
		1154	`case 132: case 135: case 140: case 141: case 145:`
		1155	`case 146: case 148: case 149: case 150: case 152:`
		1156	`case 156: case 170: case 184: case 205: case 209:`
		1157	`case 285: case 298: case 329:`
		1158	`{`
		1159	`EXP ZI493;`
		1160
		1161	`ZR496 (&ZI493);`
		1162	`ZR1290 (&ZI493, &ZI497);`
		1163	`if ((CURRENT_TERMINAL) == 354) {`
		1164	`RESTORE_LEXER;`
		1165	`goto ZL1;`
		1166	`}`
		1167	`}`
		1168	`break;`
		1169	`case 297: case 323:`
		1170	`{`
		1171	`EXP ZI493;`
		1172	`SID_LIST_EXP ZI480;`
		1173
		1174	`ZR643 (&ZI493);`
		1175	`ZR648 (&ZI480);`
		1176	`if ((CURRENT_TERMINAL) == 354) {`
		1177	`RESTORE_LEXER;`
		1178	`goto ZL1;`
		1179	`}`
		1180	`{`
		1181
		1182	`CONS_exp ( (ZI493), (ZI480), (ZI497) ) ;`
		1183	`}`
		1184	`}`
		1185	`break;`
		1186	`case 345:`
		1187	`{`
		1188	`EXP ZI493;`
		1189	`SID_LIST_EXP ZI480;`
		1190
		1191	`ZR644 (&ZI493);`
		1192	`ZR648 (&ZI480);`
		1193	`if ((CURRENT_TERMINAL) == 354) {`
		1194	`RESTORE_LEXER;`
		1195	`goto ZL1;`
		1196	`}`
		1197	`{`
		1198
		1199	`CONS_exp ( (ZI493), (ZI480), (ZI497) ) ;`
		1200	`}`
		1201	`}`
		1202	`break;`
		1203	`case 354:`
		1204	`return;`
		1205	`default:`
		1206	`goto ZL1;`
		1207	`}`
		1208	`goto ZL0;`
		1209	`ZL1:;`
		1210	`SAVE_LEXER (354);`
		1211	`return;`
		1212	`ZL0:;`
		1213	`*ZO497 = ZI497;`
		1214	`}`
		1215
		1216	`void`
		1217	`ZR975 PROTO_N ((ZO945))`
		1218	`PROTO_T (int *ZO945)`
		1219	`{`
		1220	`int ZI945;`
		1221
		1222	`ZL2_975:;`
		1223	`switch (CURRENT_TERMINAL) {`
		1224	`case 47:`
		1225	`{`
		1226	`ADVANCE_LEXER;`
		1227	`{`
		1228	`(ZI945) = 1 ;`
		1229	`}`
		1230	`}`
		1231	`break;`
		1232	`case 2: case 7: case 8: case 9: case 25:`
		1233	`case 83: case 94: case 97: case 98: case 102:`
		1234	`case 104: case 105: case 106: case 110: case 111:`
		1235	`case 112: case 114: case 115: case 117: case 118:`
		1236	`case 120: case 121: case 122: case 123: case 124:`
		1237	`case 127: case 129: case 133: case 136: case 137:`
		1238	`case 138: case 153: case 155: case 156: case 184:`
		1239	`case 274: case 285: case 298:`
		1240	`{`
		1241	`TYPE ZI574;`
		1242	`int ZI497;`
		1243	`IDENTIFIER ZI459;`
		1244
		1245	`{`
		1246
		1247	`(ZI574) = NULL_type ;`
		1248	`}`
		1249	`{`
		1250
		1251	`(ZI497) = CONTEXT_PARAMETER ;`
		1252	`}`
		1253	`ZR971 (ZI574, ZI497, &ZI459);`
		1254	`{`
		1255	`switch (CURRENT_TERMINAL) {`
		1256	`case 42:`
		1257	`{`
		1258	`ADVANCE_LEXER;`
		1259	`goto ZL2_975;`
		1260	`}`
		1261	`/UNREACHED/`
		1262	`case 47:`
		1263	`{`
		1264	`ADVANCE_LEXER;`
		1265	`{`
		1266	`(ZI945) = 1 ;`
		1267	`}`
		1268	`}`
		1269	`break;`
		1270	`default:`
		1271	`{`
		1272	`{`
		1273	`(ZI945) = 0 ;`
		1274	`}`
		1275	`}`
		1276	`break;`
		1277	`case 354:`
		1278	`RESTORE_LEXER;`
		1279	`goto ZL1;`
		1280	`}`
		1281	`}`
		1282	`}`
		1283	`break;`
		1284	`case 354:`
		1285	`return;`
		1286	`default:`
		1287	`goto ZL1;`
		1288	`}`
		1289	`goto ZL0;`
		1290	`ZL1:;`
		1291	`SAVE_LEXER (354);`
		1292	`return;`
		1293	`ZL0:;`
		1294	`*ZO945 = ZI945;`
		1295	`}`
		1296
		1297	`void`
		1298	`ZR1384 PROTO_N ((ZO480))`
		1299	`PROTO_T (SID_LIST_TYPE *ZO480)`
		1300	`{`
		1301	`SID_LIST_TYPE ZI480;`
		1302
		1303	`switch (CURRENT_TERMINAL) {`
		1304	`case 2: case 7: case 8: case 9: case 25:`
		1305	`case 83: case 97: case 98: case 102: case 104:`
		1306	`case 106: case 110: case 111: case 114: case 115:`
		1307	`case 118: case 121: case 122: case 123: case 124:`
		1308	`case 127: case 129: case 153: case 156: case 184:`
		1309	`case 285: case 298:`
		1310	`{`
		1311	`ZR1104 (&ZI480);`
		1312	`if ((CURRENT_TERMINAL) == 354) {`
		1313	`RESTORE_LEXER;`
		1314	`goto ZL1;`
		1315	`}`
		1316	`}`
		1317	`break;`
		1318	`default:`
		1319	`{`
		1320	`{`
		1321
		1322	`/* Extra comma at the end of a list */`
		1323	`report ( crt_loc, ERR_lex_extra_comma () ) ;`
		1324	`}`
		1325	`{`
		1326
		1327	`(ZI480) = NULL_list ( TYPE ) ;`
		1328	`}`
		1329	`}`
		1330	`break;`
		1331	`case 354:`
		1332	`return;`
		1333	`}`
		1334	`goto ZL0;`
		1335	`ZL1:;`
		1336	`SAVE_LEXER (354);`
		1337	`return;`
		1338	`ZL0:;`
		1339	`*ZO480 = ZI480;`
		1340	`}`
		1341
		1342	`void`
		1343	`ZR1257 PROTO_Z ()`
		1344	`{`
		1345	`switch (CURRENT_TERMINAL) {`
		1346	`case 153:`
		1347	`{`
		1348	`NAMESPACE ZI425;`
		1349	`IDENTIFIER ZI419;`
		1350	`TYPE ZI414;`
		1351
		1352	`ADVANCE_LEXER;`
		1353	`{`
		1354
		1355	`crt_templ_qualifier = 0 ;`
		1356	`}`
		1357	`ZR428 (&ZI425);`
		1358	`ZR508 (&ZI419);`
		1359	`if ((CURRENT_TERMINAL) == 354) {`
		1360	`RESTORE_LEXER;`
		1361	`goto ZL1;`
		1362	`}`
		1363	`{`
		1364
		1365	`(ZI414) = make_typename ( (ZI425), (ZI419) ) ;`
		1366	`if ( have_type_declaration == TYPE_DECL_NONE ) {`
		1367	`have_type_declaration = TYPE_DECL_ELABORATE ;`
		1368	`found_elaborate_type = 1 ;`
		1369	`}`
		1370	`have_type_specifier = 1 ;`
		1371	`}`
		1372	`{`
		1373
		1374	`using_typename ( (ZI414) ) ;`
		1375	`}`
		1376	`ZR418 ();`
		1377	`if ((CURRENT_TERMINAL) == 354) {`
		1378	`RESTORE_LEXER;`
		1379	`goto ZL1;`
		1380	`}`
		1381	`}`
		1382	`break;`
		1383	`case 1: case 2: case 3: case 4: case 5:`
		1384	`case 6: case 7: case 8: case 9: case 83:`
		1385	`case 141:`
		1386	`{`
		1387	`IDENTIFIER ZI419;`
		1388
		1389	`ZR942 (&ZI419);`
		1390	`if ((CURRENT_TERMINAL) == 354) {`
		1391	`RESTORE_LEXER;`
		1392	`goto ZL1;`
		1393	`}`
		1394	`{`
		1395
		1396	`IGNORE using_identifier ( (ZI419) ) ;`
		1397	`}`
		1398	`ZR418 ();`
		1399	`if ((CURRENT_TERMINAL) == 354) {`
		1400	`RESTORE_LEXER;`
		1401	`goto ZL1;`
		1402	`}`
		1403	`}`
		1404	`break;`
		1405	`case 354:`
		1406	`return;`
		1407	`default:`
		1408	`goto ZL1;`
		1409	`}`
		1410	`return;`
		1411	`ZL1:;`
		1412	`SAVE_LEXER (354);`
		1413	`return;`
		1414	`}`
		1415
		1416	`void`
		1417	`ZR437 PROTO_N ((ZO431))`
		1418	`PROTO_T (EXP *ZO431)`
		1419	`{`
		1420	`EXP ZI431;`
		1421
		1422	`switch (CURRENT_TERMINAL) {`
		1423	`case 135: case 150:`
		1424	`{`
		1425	`ZR436 (&ZI431);`
		1426	`if ((CURRENT_TERMINAL) == 354) {`
		1427	`RESTORE_LEXER;`
		1428	`goto ZL1;`
		1429	`}`
		1430	`}`
		1431	`break;`
		1432	`case 17: case 18:`
		1433	`{`
		1434	`{`
		1435	`switch (CURRENT_TERMINAL) {`
		1436	`case 17:`
		1437	`{`
		1438	`{`
		1439
		1440	`ZI431 = crt_token->pp_data.exp ;`
		1441	`}`
		1442	`ADVANCE_LEXER;`
		1443	`}`
		1444	`break;`
		1445	`case 18:`
		1446	`{`
		1447	`{`
		1448
		1449	`ZI431 = crt_token->pp_data.exp ;`
		1450	`}`
		1451	`ADVANCE_LEXER;`
		1452	`}`
		1453	`break;`
		1454	`default:`
		1455	`goto ZL1;`
		1456	`}`
		1457	`}`
		1458	`}`
		1459	`break;`
		1460	`case 22:`
		1461	`{`
		1462	`{`
		1463	`{`
		1464	`switch (CURRENT_TERMINAL) {`
		1465	`case 22:`
		1466	`{`
		1467
		1468	`ZI431 = crt_token->pp_data.exp ;`
		1469	`}`
		1470	`break;`
		1471	`default:`
		1472	`goto ZL1;`
		1473	`}`
		1474	`ADVANCE_LEXER;`
		1475	`}`
		1476	`}`
		1477	`}`
		1478	`break;`
		1479	`case 21:`
		1480	`{`
		1481	`{`
		1482	`{`
		1483	`switch (CURRENT_TERMINAL) {`
		1484	`case 21:`
		1485	`{`
		1486
		1487	`ZI431 = crt_token->pp_data.exp ;`
		1488	`}`
		1489	`break;`
		1490	`default:`
		1491	`goto ZL1;`
		1492	`}`
		1493	`ADVANCE_LEXER;`
		1494	`}`
		1495	`}`
		1496	`}`
		1497	`break;`
		1498	`case 19: case 20:`
		1499	`{`
		1500	`{`
		1501	`switch (CURRENT_TERMINAL) {`
		1502	`case 19:`
		1503	`{`
		1504	`{`
		1505
		1506	`ZI431 = crt_token->pp_data.exp ;`
		1507	`}`
		1508	`ADVANCE_LEXER;`
		1509	`}`
		1510	`break;`
		1511	`case 20:`
		1512	`{`
		1513	`{`
		1514
		1515	`ZI431 = crt_token->pp_data.exp ;`
		1516	`}`
		1517	`ADVANCE_LEXER;`
		1518	`}`
		1519	`break;`
		1520	`default:`
		1521	`goto ZL1;`
		1522	`}`
		1523	`}`
		1524	`}`
		1525	`break;`
		1526	`case 354:`
		1527	`return;`
		1528	`default:`
		1529	`goto ZL1;`
		1530	`}`
		1531	`goto ZL0;`
		1532	`ZL1:;`
		1533	`SAVE_LEXER (354);`
		1534	`return;`
		1535	`ZL0:;`
		1536	`*ZO431 = ZI431;`
		1537	`}`
		1538
		1539	`void`
		1540	`ZR939 PROTO_N ((ZO497))`
		1541	`PROTO_T (SID_LIST_TYPE *ZO497)`
		1542	`{`
		1543	`SID_LIST_TYPE ZI497;`
		1544
		1545	`switch (CURRENT_TERMINAL) {`
		1546	`case 149:`
		1547	`{`
		1548	`ADVANCE_LEXER;`
		1549	`switch (CURRENT_TERMINAL) {`
		1550	`case 65:`
		1551	`break;`
		1552	`default:`
		1553	`goto ZL1;`
		1554	`}`
		1555	`ADVANCE_LEXER;`
		1556	`{`
		1557	`switch (CURRENT_TERMINAL) {`
		1558	`case 47:`
		1559	`{`
		1560	`ADVANCE_LEXER;`
		1561	`{`
		1562
		1563	`report ( crt_loc, ERR_except_spec_ellipsis () ) ;`
		1564	`(ZI497) = univ_type_set ;`
		1565	`}`
		1566	`}`
		1567	`break;`
		1568	`case 2: case 7: case 8: case 9: case 25:`
		1569	`case 83: case 97: case 98: case 102: case 104:`
		1570	`case 106: case 110: case 111: case 114: case 115:`
		1571	`case 118: case 121: case 122: case 123: case 124:`
		1572	`case 127: case 129: case 153: case 156: case 184:`
		1573	`case 285: case 298:`
		1574	`{`
		1575	`ZR1104 (&ZI497);`
		1576	`if ((CURRENT_TERMINAL) == 354) {`
		1577	`RESTORE_LEXER;`
		1578	`goto ZL1;`
		1579	`}`
		1580	`}`
		1581	`break;`
		1582	`default:`
		1583	`{`
		1584	`{`
		1585
		1586	`(ZI497) = NULL_list ( TYPE ) ;`
		1587	`}`
		1588	`}`
		1589	`break;`
		1590	`}`
		1591	`}`
		1592	`switch (CURRENT_TERMINAL) {`
		1593	`case 39:`
		1594	`break;`
		1595	`default:`
		1596	`goto ZL1;`
		1597	`}`
		1598	`ADVANCE_LEXER;`
		1599	`}`
		1600	`break;`
		1601	`default:`
		1602	`{`
		1603	`{`
		1604
		1605	`(ZI497) = empty_type_set ;`
		1606	`}`
		1607	`}`
		1608	`break;`
		1609	`case 354:`
		1610	`return;`
		1611	`}`
		1612	`goto ZL0;`
		1613	`ZL1:;`
		1614	`SAVE_LEXER (354);`
		1615	`return;`
		1616	`ZL0:;`
		1617	`*ZO497 = ZI497;`
		1618	`}`
		1619
		1620	`void`
		1621	`parse_decl PROTO_N ((ZI414, ZI689))`
		1622	`PROTO_T (TYPE ZI414 X DECL_SPEC ZI689)`
		1623	`{`
		1624	`if ((CURRENT_TERMINAL) == 354) {`
		1625	`return;`
		1626	`}`
		1627	`{`
		1628	`BASE_TYPE ZI1248;`
		1629	`TYPE ZI1249;`
		1630	`CV_SPEC ZI1250;`
		1631	`DECL_SPEC ZI1251;`
		1632	`BASE_TYPE ZI511;`
		1633	`TYPE ZI875;`
		1634	`CV_SPEC ZI876;`
		1635	`DECL_SPEC ZI909;`
		1636	`DECL_SPEC ZI911;`
		1637
		1638	`{`
		1639
		1640	`/* Resolve declaration-specifiers from other declarators */`
		1641	`(ZI0) = predict_dspec ( 0 ) ;`
		1642	`}`
		1643	`if (!ZI0)`
		1644	`goto ZL2;`
		1645	`ZR906 (ZI414, &ZI1248, &ZI1249, &ZI1250, &ZI1251);`
		1646	`ZR917 (&ZI414, &ZI1248, &ZI1249, &ZI1250, &ZI1251, &ZI511, &ZI875, &ZI876, &ZI909);`
		1647	`if ((CURRENT_TERMINAL) == 354) {`
		1648	`RESTORE_LEXER;`
		1649	`goto ZL1;`
		1650	`}`
		1651	`{`
		1652
		1653	`/* Combine two declaration specifiers */`
		1654	`DECL_SPEC d = ( ( (ZI689) & (ZI909) ) & dspec_duplicate ) ;`
		1655	`if ( d ) report ( crt_loc, ERR_dcl_spec_dup ( d ) ) ;`
		1656	`(ZI911) = ( (ZI689) \| (ZI909) ) ;`
		1657	`}`
		1658	`ZR1252 (&ZI414, &ZI511, &ZI875, &ZI876, &ZI911);`
		1659	`if ((CURRENT_TERMINAL) == 354) {`
		1660	`RESTORE_LEXER;`
		1661	`goto ZL1;`
		1662	`}`
		1663	`goto ZL0;`
		1664	`}`
		1665	`/UNREACHED/`
		1666	`ZL2:;`
		1667	`switch (CURRENT_TERMINAL) {`
		1668	`case 1: case 2: case 3: case 4: case 5:`
		1669	`case 6: case 7: case 8: case 9: case 10:`
		1670	`case 11: case 33: case 65: case 78: case 83:`
		1671	`case 141:`
		1672	`{`
		1673	`BASE_TYPE ZI511;`
		1674	`TYPE ZI875;`
		1675	`CV_SPEC ZI876;`
		1676	`DECL_SPEC ZI909;`
		1677	`DECL_SPEC ZI911;`
		1678	`TYPE ZI879;`
		1679	`DECL_SPEC ZI1073;`
		1680	`TYPE ZI1074;`
		1681	`ACCESS_LIST ZI670;`
		1682	`TYPE ZI574;`
		1683	`IDENTIFIER ZI419;`
		1684	`int ZI558;`
		1685	`IDENTIFIER ZI459;`
		1686
		1687	`{`
		1688	`(ZI511) = btype_none ;`
		1689	`}`
		1690	`{`
		1691
		1692	`(ZI875) = NULL_type ;`
		1693	`}`
		1694	`{`
		1695	`(ZI876) = cv_none ;`
		1696	`}`
		1697	`{`
		1698	`(ZI909) = dspec_none ;`
		1699	`}`
		1700	`{`
		1701
		1702	`/* Combine two declaration specifiers */`
		1703	`DECL_SPEC d = ( ( (ZI689) & (ZI909) ) & dspec_duplicate ) ;`
		1704	`if ( d ) report ( crt_loc, ERR_dcl_spec_dup ( d ) ) ;`
		1705	`(ZI911) = ( (ZI689) \| (ZI909) ) ;`
		1706	`}`
		1707	`{`
		1708
		1709	`/* Complete a declaration specifier and a type */`
		1710	`(ZI1073) = complete_dspec ( (ZI911), (ZI511), (ZI875), (ZI876) ) ;`
		1711	`(ZI879) = complete_pre_type ( (ZI511), (ZI875), (ZI876), 0 ) ;`
		1712	`have_type_specifier = 0 ;`
		1713	`}`
		1714	`{`
		1715
		1716	`(ZI1074) = ( IS_NULL_type ( (ZI414) ) ? (ZI879) : inject_pre_type ( (ZI414), (ZI879), 1 ) ) ;`
		1717	`}`
		1718	`{`
		1719
		1720	`save_access ( &(ZI670) ) ;`
		1721	`}`
		1722	`{`
		1723
		1724	`crt_templ_qualifier = 0 ;`
		1725	`}`
		1726	`ZR950 (ZI1074, &ZI574, &ZI419, &ZI558);`
		1727	`if ((CURRENT_TERMINAL) == 354) {`
		1728	`RESTORE_LEXER;`
		1729	`goto ZL1;`
		1730	`}`
		1731	`{`
		1732
		1733	`if ( type_tag ( (ZI574) ) == type_func_tag ) {`
		1734	`/* Look ahead for function definitions */`
		1735	`int def = predict_func_defn () ;`
		1736	`if ( def & !have_func_declarator ) adjust_param ( (ZI574) ) ;`
		1737	`(ZI459) = make_func_decl ( (ZI1073), (ZI574), (ZI419), def ) ;`
		1738	`is_function_next = def ;`
		1739	`} else {`
		1740	`int def = predict_obj_defn () ;`
		1741	`(ZI459) = make_object_decl ( (ZI1073), (ZI574), (ZI419), def ) ;`
		1742	`is_function_next = 0 ;`
		1743	`}`
		1744	`if ( IS_id_type_alias ( (ZI459) ) ) {`
		1745	`BASE_TYPE bs = DEREF_btype ( id_type_alias_rep ( (ZI459) ) ) ;`
		1746	`bs \|= (ZI511) ;`
		1747	`COPY_btype ( id_type_alias_rep ( (ZI459) ), bs ) ;`
		1748	`}`
		1749	`have_type_declaration = TYPE_DECL_NONE ;`
		1750	`have_func_declarator = 0 ;`
		1751	`}`
		1752	`{`
		1753
		1754	`IGNORE clear_access ( (ZI459), &(ZI670) ) ;`
		1755	`}`
		1756	`{`
		1757
		1758	`if ( crt_access_list.pending ) {`
		1759	`IGNORE report_access ( (ZI459) ) ;`
		1760	`}`
		1761	`}`
		1762	`ZR1075 (&ZI511, &ZI1073, &ZI1074, &ZI670, &ZI558, &ZI459);`
		1763	`if ((CURRENT_TERMINAL) == 354) {`
		1764	`RESTORE_LEXER;`
		1765	`goto ZL1;`
		1766	`}`
		1767	`}`
		1768	`break;`
		1769	`default:`
		1770	`goto ZL1;`
		1771	`}`
		1772	`return;`
		1773	`ZL1:;`
		1774	`{`
		1775	`{`
		1776
		1777	`/* Syntax errors */`
		1778	`ERROR err = ERR_lex_parse ( crt_token ) ;`
		1779	`report ( crt_loc, err ) ;`
		1780	`have_syntax_error = 1 ;`
		1781	`}`
		1782	`}`
		1783	`ZL0:;`
		1784	`}`
		1785
		1786	`void`
		1787	`ZR1258 PROTO_N ((ZO431))`
		1788	`PROTO_T (EXP *ZO431)`
		1789	`{`
		1790	`EXP ZI431;`
		1791
		1792	`switch (CURRENT_TERMINAL) {`
		1793	`case 1: case 2: case 3: case 4:`
		1794	`{`
		1795	`IDENTIFIER ZI1040;`
		1796	`IDENTIFIER ZI419;`
		1797
		1798	`{`
		1799	`switch (CURRENT_TERMINAL) {`
		1800	`case 1:`
		1801	`{`
		1802	`{`
		1803
		1804	`ZI1040 = crt_token->pp_data.id.use ;`
		1805	`}`
		1806	`ADVANCE_LEXER;`
		1807	`}`
		1808	`break;`
		1809	`case 3:`
		1810	`{`
		1811	`{`
		1812
		1813	`ZI1040 = crt_token->pp_data.id.use ;`
		1814	`}`
		1815	`ADVANCE_LEXER;`
		1816	`}`
		1817	`break;`
		1818	`case 4:`
		1819	`{`
		1820	`{`
		1821
		1822	`ZI1040 = crt_token->pp_data.id.use ;`
		1823	`}`
		1824	`ADVANCE_LEXER;`
		1825	`}`
		1826	`break;`
		1827	`case 2:`
		1828	`{`
		1829	`{`
		1830
		1831	`ZI1040 = crt_token->pp_data.id.use ;`
		1832	`}`
		1833	`ADVANCE_LEXER;`
		1834	`}`
		1835	`break;`
		1836	`default:`
		1837	`goto ZL1;`
		1838	`}`
		1839	`}`
		1840	`{`
		1841
		1842	`(ZI419) = (ZI1040) ;`
		1843	`crt_id_qualifier = qual_none ;`
		1844	`last_namespace = crt_namespace ;`
		1845	`}`
		1846	`{`
		1847
		1848	`IDENTIFIER pid = underlying_id ( (ZI419) ) ;`
		1849	`DEREF_loc ( id_loc ( pid ), decl_loc ) ;`
		1850	`}`
		1851	`ZR1433 (&ZI419, &ZI431);`
		1852	`if ((CURRENT_TERMINAL) == 354) {`
		1853	`RESTORE_LEXER;`
		1854	`goto ZL1;`
		1855	`}`
		1856	`}`
		1857	`break;`
		1858	`case 64:`
		1859	`{`
		1860	`DECL_SPEC ZI689;`
		1861	`TYPE ZI414;`
		1862
		1863	`{`
		1864
		1865	`decl_loc = crt_loc ;`
		1866	`begin_namespace ( NULL_id, 1 ) ;`
		1867	`}`
		1868	`{`
		1869	`(ZI689) = dspec_none ;`
		1870	`}`
		1871	`{`
		1872
		1873	`(ZI414) = NULL_type ;`
		1874	`}`
		1875	`{`
		1876	`{`
		1877	`switch (CURRENT_TERMINAL) {`
		1878	`case 64:`
		1879	`break;`
		1880	`default:`
		1881	`goto ZL1;`
		1882	`}`
		1883	`ADVANCE_LEXER;`
		1884	`}`
		1885	`}`
		1886	`ZR1027 (ZI414, ZI689);`
		1887	`if ((CURRENT_TERMINAL) == 354) {`
		1888	`RESTORE_LEXER;`
		1889	`goto ZL1;`
		1890	`}`
		1891	`{`
		1892
		1893	`end_namespace ( 1 ) ;`
		1894	`}`
		1895	`{`
		1896	`{`
		1897	`switch (CURRENT_TERMINAL) {`
		1898	`case 38:`
		1899	`break;`
		1900	`default:`
		1901	`goto ZL1;`
		1902	`}`
		1903	`ADVANCE_LEXER;`
		1904	`}`
		1905	`}`
		1906	`{`
		1907
		1908	`RESCAN_LEXER ;`
		1909	`}`
		1910	`{`
		1911
		1912	`(ZI431) = NULL_exp ;`
		1913	`}`
		1914	`}`
		1915	`break;`
		1916	`case 354:`
		1917	`return;`
		1918	`default:`
		1919	`goto ZL1;`
		1920	`}`
		1921	`goto ZL0;`
		1922	`ZL1:;`
		1923	`SAVE_LEXER (354);`
		1924	`return;`
		1925	`ZL0:;`
		1926	`*ZO431 = ZI431;`
		1927	`}`
		1928
		1929	`void`
		1930	`ZR1259 PROTO_N ((ZO431))`
		1931	`PROTO_T (EXP *ZO431)`
		1932	`{`
		1933	`EXP ZI431;`
		1934
		1935	`switch (CURRENT_TERMINAL) {`
		1936	`case 139:`
		1937	`{`
		1938	`NAMESPACE ZI1047;`
		1939	`IDENTIFIER ZI1048;`
		1940	`IDENTIFIER ZI419;`
		1941	`NAMESPACE ZI425;`
		1942
		1943	`ADVANCE_LEXER;`
		1944	`ZR428 (&ZI1047);`
		1945	`ZR508 (&ZI1048);`
		1946	`if ((CURRENT_TERMINAL) == 354) {`
		1947	`RESTORE_LEXER;`
		1948	`goto ZL1;`
		1949	`}`
		1950	`{`
		1951
		1952	`(ZI419) = check_id ( (ZI1047), (ZI1048), 0 ) ;`
		1953	`last_namespace = (ZI1047) ;`
		1954	`}`
		1955	`{`
		1956
		1957	`(ZI425) = find_nspace_id ( (ZI419) ) ;`
		1958	`}`
		1959	`{`
		1960
		1961	`using_namespace ( (ZI425) ) ;`
		1962	`}`
		1963	`ZR418 ();`
		1964	`if ((CURRENT_TERMINAL) == 354) {`
		1965	`RESTORE_LEXER;`
		1966	`goto ZL1;`
		1967	`}`
		1968	`{`
		1969
		1970	`(ZI431) = NULL_exp ;`
		1971	`}`
		1972	`}`
		1973	`break;`
		1974	`case 1: case 2: case 3: case 4: case 5:`
		1975	`case 6: case 7: case 8: case 9: case 83:`
		1976	`case 141: case 153:`
		1977	`{`
		1978	`ZR1257 ();`
		1979	`if ((CURRENT_TERMINAL) == 354) {`
		1980	`RESTORE_LEXER;`
		1981	`goto ZL1;`
		1982	`}`
		1983	`{`
		1984
		1985	`(ZI431) = NULL_exp ;`
		1986	`}`
		1987	`}`
		1988	`break;`
		1989	`case 354:`
		1990	`return;`
		1991	`default:`
		1992	`goto ZL1;`
		1993	`}`
		1994	`goto ZL0;`
		1995	`ZL1:;`
		1996	`SAVE_LEXER (354);`
		1997	`return;`
		1998	`ZL0:;`
		1999	`*ZO431 = ZI431;`
		2000	`}`
		2001
		2002	`void`
		2003	`ZR624 PROTO_N ((ZO1203))`
		2004	`PROTO_T (EXP *ZO1203)`
		2005	`{`
		2006	`EXP ZI1203;`
		2007
		2008	`if ((CURRENT_TERMINAL) == 354) {`
		2009	`return;`
		2010	`}`
		2011	`{`
		2012	`EXP ZI431;`
		2013
		2014	`ZR622 (&ZI431);`
		2015	`ZR1204 (ZI431, &ZI1203);`
		2016	`if ((CURRENT_TERMINAL) == 354) {`
		2017	`RESTORE_LEXER;`
		2018	`goto ZL1;`
		2019	`}`
		2020	`}`
		2021	`goto ZL0;`
		2022	`ZL1:;`
		2023	`SAVE_LEXER (354);`
		2024	`return;`
		2025	`ZL0:;`
		2026	`*ZO1203 = ZI1203;`
		2027	`}`
		2028
		2029	`void`
		2030	`ZR678 PROTO_N ((ZO431))`
		2031	`PROTO_T (EXP *ZO431)`
		2032	`{`
		2033	`EXP ZI431;`
		2034
		2035	`if ((CURRENT_TERMINAL) == 354) {`
		2036	`return;`
		2037	`}`
		2038	`{`
		2039	`EXP ZI558;`
		2040	`EXP ZI493;`
		2041
		2042	`{`
		2043
		2044	`(ZI558) = begin_compound_stmt ( 1 ) ;`
		2045	`}`
		2046	`{`
		2047	`{`
		2048	`switch (CURRENT_TERMINAL) {`
		2049	`case 64:`
		2050	`break;`
		2051	`default:`
		2052	`goto ZL1;`
		2053	`}`
		2054	`ADVANCE_LEXER;`
		2055	`}`
		2056	`}`
		2057	`{`
		2058
		2059	`COPY_int ( exp_sequence_block ( (ZI558) ), 2 ) ;`
		2060	`}`
		2061	`ZR676 (ZI558, &ZI493);`
		2062	`{`
		2063	`if ((CURRENT_TERMINAL) == 354) {`
		2064	`RESTORE_LEXER;`
		2065	`goto ZL1;`
		2066	`}`
		2067	`{`
		2068	`switch (CURRENT_TERMINAL) {`
		2069	`case 38:`
		2070	`break;`
		2071	`default:`
		2072	`goto ZL1;`
		2073	`}`
		2074	`ADVANCE_LEXER;`
		2075	`}`
		2076	`}`
		2077	`{`
		2078
		2079	`(ZI431) = end_compound_stmt ( (ZI493) ) ;`
		2080	`}`
		2081	`{`
		2082
		2083	`RESCAN_LEXER ;`
		2084	`}`
		2085	`}`
		2086	`goto ZL0;`
		2087	`ZL1:;`
		2088	`SAVE_LEXER (354);`
		2089	`return;`
		2090	`ZL0:;`
		2091	`*ZO431 = ZI431;`
		2092	`}`
		2093
		2094	`void`
		2095	`ZR499 PROTO_N ((ZO480))`
		2096	`PROTO_T (SID_LIST_EXP *ZO480)`
		2097	`{`
		2098	`SID_LIST_EXP ZI480;`
		2099
		2100	`switch (CURRENT_TERMINAL) {`
		2101	`case 42:`
		2102	`{`
		2103	`ADVANCE_LEXER;`
		2104	`ZR498 (&ZI480);`
		2105	`if ((CURRENT_TERMINAL) == 354) {`
		2106	`RESTORE_LEXER;`
		2107	`goto ZL1;`
		2108	`}`
		2109	`}`
		2110	`break;`
		2111	`default:`
		2112	`{`
		2113	`{`
		2114
		2115	`(ZI480) = NULL_list ( EXP ) ;`
		2116	`}`
		2117	`}`
		2118	`break;`
		2119	`case 354:`
		2120	`return;`
		2121	`}`
		2122	`goto ZL0;`
		2123	`ZL1:;`
		2124	`SAVE_LEXER (354);`
		2125	`return;`
		2126	`ZL0:;`
		2127	`*ZO480 = ZI480;`
		2128	`}`
		2129
		2130	`void`
		2131	`ZR418 PROTO_Z ()`
		2132	`{`
		2133	`if ((CURRENT_TERMINAL) == 354) {`
		2134	`return;`
		2135	`}`
		2136	`{`
		2137	`switch (CURRENT_TERMINAL) {`
		2138	`case 77:`
		2139	`break;`
		2140	`default:`
		2141	`goto ZL1;`
		2142	`}`
		2143	`ADVANCE_LEXER;`
		2144	`}`
		2145	`return;`
		2146	`ZL1:;`
		2147	`{`
		2148	`int ZI414;`
		2149
		2150	`{`
		2151	`(ZI414) = lex_semicolon ;`
		2152	`}`
		2153	`{`
		2154
		2155	`/* Expected symbol */`
		2156	`int p = primary_form ( crt_lex_token ) ;`
		2157	`if ( p != (ZI414) ) report ( crt_loc, ERR_lex_expect ( (ZI414) ) ) ;`
		2158	`}`
		2159	`}`
		2160	`}`
		2161
		2162	`void`
		2163	`ZR630 PROTO_N ((ZO1191))`
		2164	`PROTO_T (EXP *ZO1191)`
		2165	`{`
		2166	`EXP ZI1191;`
		2167
		2168	`if ((CURRENT_TERMINAL) == 354) {`
		2169	`return;`
		2170	`}`
		2171	`{`
		2172	`EXP ZI431;`
		2173
		2174	`ZR628 (&ZI431);`
		2175	`ZR1192 (ZI431, &ZI1191);`
		2176	`if ((CURRENT_TERMINAL) == 354) {`
		2177	`RESTORE_LEXER;`
		2178	`goto ZL1;`
		2179	`}`
		2180	`}`
		2181	`goto ZL0;`
		2182	`ZL1:;`
		2183	`SAVE_LEXER (354);`
		2184	`return;`
		2185	`ZL0:;`
		2186	`*ZO1191 = ZI1191;`
		2187	`}`
		2188
		2189	`void`
		2190	`ZR651 PROTO_N ((ZO431))`
		2191	`PROTO_T (EXP *ZO431)`
		2192	`{`
		2193	`EXP ZI431;`
		2194
		2195	`if ((CURRENT_TERMINAL) == 354) {`
		2196	`return;`
		2197	`}`
		2198	`{`
		2199	`EXP ZI493;`
		2200
		2201	`ZR632 (&ZI493);`
		2202	`if ((CURRENT_TERMINAL) == 354) {`
		2203	`RESTORE_LEXER;`
		2204	`goto ZL1;`
		2205	`}`
		2206	`{`
		2207
		2208	`(ZI431) = convert_reference ( (ZI493), REF_NORMAL ) ;`
		2209	`(ZI431) = convert_lvalue ( (ZI431) ) ;`
		2210	`}`
		2211	`}`
		2212	`goto ZL0;`
		2213	`ZL1:;`
		2214	`SAVE_LEXER (354);`
		2215	`return;`
		2216	`ZL0:;`
		2217	`*ZO431 = ZI431;`
		2218	`}`
		2219
		2220	`void`
		2221	`ZR1115 PROTO_N ((ZO419))`
		2222	`PROTO_T (IDENTIFIER *ZO419)`
		2223	`{`
		2224	`IDENTIFIER ZI419;`
		2225
		2226	`switch (CURRENT_TERMINAL) {`
		2227	`case 1: case 2: case 3: case 4:`
		2228	`{`
		2229	`IDENTIFIER ZI460;`
		2230
		2231	`{`
		2232	`switch (CURRENT_TERMINAL) {`
		2233	`case 1:`
		2234	`{`
		2235	`{`
		2236
		2237	`ZI460 = crt_token->pp_data.id.use ;`
		2238	`}`
		2239	`ADVANCE_LEXER;`
		2240	`}`
		2241	`break;`
		2242	`case 3:`
		2243	`{`
		2244	`{`
		2245
		2246	`ZI460 = crt_token->pp_data.id.use ;`
		2247	`}`
		2248	`ADVANCE_LEXER;`
		2249	`}`
		2250	`break;`
		2251	`case 4:`
		2252	`{`
		2253	`{`
		2254
		2255	`ZI460 = crt_token->pp_data.id.use ;`
		2256	`}`
		2257	`ADVANCE_LEXER;`
		2258	`}`
		2259	`break;`
		2260	`case 2:`
		2261	`{`
		2262	`{`
		2263
		2264	`ZI460 = crt_token->pp_data.id.use ;`
		2265	`}`
		2266	`ADVANCE_LEXER;`
		2267	`}`
		2268	`break;`
		2269	`default:`
		2270	`goto ZL1;`
		2271	`}`
		2272	`}`
		2273	`{`
		2274
		2275	`(ZI419) = (ZI460) ;`
		2276	`crt_id_qualifier = qual_none ;`
		2277	`last_namespace = crt_namespace ;`
		2278	`}`
		2279	`}`
		2280	`break;`
		2281	`default:`
		2282	`{`
		2283	`{`
		2284
		2285	`HASHID nm = lookup_anon () ;`
		2286	`(ZI419) = DEREF_id ( hashid_id ( nm ) ) ;`
		2287	`crt_id_qualifier = qual_none ;`
		2288	`qual_namespace = NULL_nspace ;`
		2289	`}`
		2290	`}`
		2291	`break;`
		2292	`case 354:`
		2293	`return;`
		2294	`}`
		2295	`goto ZL0;`
		2296	`ZL1:;`
		2297	`SAVE_LEXER (354);`
		2298	`return;`
		2299	`ZL0:;`
		2300	`*ZO419 = ZI419;`
		2301	`}`
		2302
		2303	`void`
		2304	`ZR1262 PROTO_N ((ZI1260, ZO431))`
		2305	`PROTO_T (EXP ZI1260 X EXP ZO431)`
		2306	`{`
		2307	`EXP ZI431;`
		2308
		2309	`switch (CURRENT_TERMINAL) {`
		2310	`case 72:`
		2311	`{`
		2312	`EXP ZI493;`
		2313	`EXP ZI456;`
		2314
		2315	`ADVANCE_LEXER;`
		2316	`ZR491 (&ZI493);`
		2317	`switch (CURRENT_TERMINAL) {`
		2318	`case 41:`
		2319	`break;`
		2320	`case 354:`
		2321	`RESTORE_LEXER;`
		2322	`goto ZL1;`
		2323	`default:`
		2324	`goto ZL1;`
		2325	`}`
		2326	`ADVANCE_LEXER;`
		2327	`ZR496 (&ZI456);`
		2328	`if ((CURRENT_TERMINAL) == 354) {`
		2329	`RESTORE_LEXER;`
		2330	`goto ZL1;`
		2331	`}`
		2332	`{`
		2333
		2334	`(ZI431) = make_cond_exp ( (*ZI1260), (ZI493), (ZI456) ) ;`
		2335	`}`
		2336	`}`
		2337	`break;`
		2338	`default:`
		2339	`{`
		2340	`ZI431 = *ZI1260;`
		2341	`}`
		2342	`break;`
		2343	`case 354:`
		2344	`return;`
		2345	`}`
		2346	`goto ZL0;`
		2347	`ZL1:;`
		2348	`SAVE_LEXER (354);`
		2349	`return;`
		2350	`ZL0:;`
		2351	`*ZO431 = ZI431;`
		2352	`}`
		2353
		2354	`void`
		2355	`ZR926 PROTO_N ((ZO497))`
		2356	`PROTO_T (TYPE *ZO497)`
		2357	`{`
		2358	`TYPE ZI497;`
		2359
		2360	`switch (CURRENT_TERMINAL) {`
		2361	`case 11:`
		2362	`{`
		2363	`IDENTIFIER ZI419;`
		2364	`CV_SPEC ZI783;`
		2365
		2366	`{`
		2367
		2368	`ZI419 = crt_token->pp_data.id.use ;`
		2369	`}`
		2370	`ADVANCE_LEXER;`
		2371	`ZR788 (&ZI783);`
		2372	`if ((CURRENT_TERMINAL) == 354) {`
		2373	`RESTORE_LEXER;`
		2374	`goto ZL1;`
		2375	`}`
		2376	`{`
		2377
		2378	`CLASS_TYPE ct = find_class ( (ZI419) ) ;`
		2379	`if ( IS_NULL_ctype ( ct ) ) {`
		2380	`report ( crt_loc, ERR_dcl_mptr_type ( (ZI419) ) ) ;`
		2381	`MAKE_type_ptr ( (ZI783), NULL_type, (ZI497) ) ;`
		2382	`} else {`
		2383	`MAKE_type_ptr_mem ( (ZI783), ct, NULL_type, (ZI497) ) ;`
		2384	`}`
		2385	`}`
		2386	`}`
		2387	`break;`
		2388	`case 10:`
		2389	`{`
		2390	`IDENTIFIER ZI419;`
		2391	`CV_SPEC ZI783;`
		2392
		2393	`{`
		2394
		2395	`ZI419 = crt_token->pp_data.id.use ;`
		2396	`}`
		2397	`ADVANCE_LEXER;`
		2398	`ZR788 (&ZI783);`
		2399	`if ((CURRENT_TERMINAL) == 354) {`
		2400	`RESTORE_LEXER;`
		2401	`goto ZL1;`
		2402	`}`
		2403	`{`
		2404
		2405	`CLASS_TYPE ct = find_class ( (ZI419) ) ;`
		2406	`if ( IS_NULL_ctype ( ct ) ) {`
		2407	`report ( crt_loc, ERR_dcl_mptr_type ( (ZI419) ) ) ;`
		2408	`MAKE_type_ptr ( (ZI783), NULL_type, (ZI497) ) ;`
		2409	`} else {`
		2410	`MAKE_type_ptr_mem ( (ZI783), ct, NULL_type, (ZI497) ) ;`
		2411	`}`
		2412	`}`
		2413	`}`
		2414	`break;`
		2415	`case 78:`
		2416	`{`
		2417	`CV_SPEC ZI783;`
		2418
		2419	`ADVANCE_LEXER;`
		2420	`ZR788 (&ZI783);`
		2421	`if ((CURRENT_TERMINAL) == 354) {`
		2422	`RESTORE_LEXER;`
		2423	`goto ZL1;`
		2424	`}`
		2425	`{`
		2426
		2427	`MAKE_type_ptr ( (ZI783), NULL_type, (ZI497) ) ;`
		2428	`}`
		2429	`}`
		2430	`break;`
		2431	`case 33:`
		2432	`{`
		2433	`CV_SPEC ZI783;`
		2434
		2435	`{`
		2436	`{`
		2437	`switch (CURRENT_TERMINAL) {`
		2438	`case 33:`
		2439	`break;`
		2440	`default:`
		2441	`goto ZL1;`
		2442	`}`
		2443	`ADVANCE_LEXER;`
		2444	`}`
		2445	`}`
		2446	`ZR788 (&ZI783);`
		2447	`if ((CURRENT_TERMINAL) == 354) {`
		2448	`RESTORE_LEXER;`
		2449	`goto ZL1;`
		2450	`}`
		2451	`{`
		2452
		2453	`/* Can't have const-volatile qualified references */`
		2454	`if ( (ZI783) ) report ( crt_loc, ERR_dcl_ref_cv ( (ZI783) ) ) ;`
		2455	`MAKE_type_ref ( cv_none, NULL_type, (ZI497) ) ;`
		2456	`}`
		2457	`}`
		2458	`break;`
		2459	`case 354:`
		2460	`return;`
		2461	`default:`
		2462	`goto ZL1;`
		2463	`}`
		2464	`goto ZL0;`
		2465	`ZL1:;`
		2466	`SAVE_LEXER (354);`
		2467	`return;`
		2468	`ZL0:;`
		2469	`*ZO497 = ZI497;`
		2470	`}`
		2471
		2472	`void`
		2473	`ZR1264 PROTO_N ((ZI1263, ZO431))`
		2474	`PROTO_T (EXP ZI1263 X EXP ZO431)`
		2475	`{`
		2476	`EXP ZI431;`
		2477
		2478	`switch (CURRENT_TERMINAL) {`
		2479	`case 36:`
		2480	`{`
		2481	`EXP ZI456;`
		2482
		2483	`ADVANCE_LEXER;`
		2484	`ZR496 (&ZI456);`
		2485	`if ((CURRENT_TERMINAL) == 354) {`
		2486	`RESTORE_LEXER;`
		2487	`goto ZL1;`
		2488	`}`
		2489	`{`
		2490
		2491	`(ZI431) = make_assign_exp ( (*ZI1263), (ZI456), 0 ) ;`
		2492	`}`
		2493	`}`
		2494	`break;`
		2495	`default:`
		2496	`{`
		2497	`ZR1262 (ZI1263, &ZI431);`
		2498	`if ((CURRENT_TERMINAL) == 354) {`
		2499	`RESTORE_LEXER;`
		2500	`goto ZL1;`
		2501	`}`
		2502	`}`
		2503	`break;`
		2504	`case 34: case 45: case 58: case 60: case 68:`
		2505	`case 70: case 74: case 76: case 79: case 81:`
		2506	`{`
		2507	`int ZI450;`
		2508	`EXP ZI456;`
		2509
		2510	`{`
		2511	`(ZI450) = crt_lex_token ;`
		2512	`}`
		2513	`ZR639 ();`
		2514	`ZR496 (&ZI456);`
		2515	`if ((CURRENT_TERMINAL) == 354) {`
		2516	`RESTORE_LEXER;`
		2517	`goto ZL1;`
		2518	`}`
		2519	`{`
		2520
		2521	`/* op will be in its primary form */`
		2522	`(ZI431) = make_become_exp ( (ZI450), (*ZI1263), (ZI456) ) ;`
		2523	`}`
		2524	`}`
		2525	`break;`
		2526	`case 354:`
		2527	`return;`
		2528	`}`
		2529	`goto ZL0;`
		2530	`ZL1:;`
		2531	`SAVE_LEXER (354);`
		2532	`return;`
		2533	`ZL0:;`
		2534	`*ZO431 = ZI431;`
		2535	`}`
		2536
		2537	`void`
		2538	`ZR845 PROTO_Z ()`
		2539	`{`
		2540	`if ((CURRENT_TERMINAL) == 354) {`
		2541	`return;`
		2542	`}`
		2543	`ZL2_845:;`
		2544	`{`
		2545	`ZR842 ();`
		2546	`{`
		2547	`switch (CURRENT_TERMINAL) {`
		2548	`case 42:`
		2549	`{`
		2550	`ADVANCE_LEXER;`
		2551	`goto ZL2_845;`
		2552	`}`
		2553	`/UNREACHED/`
		2554	`case 354:`
		2555	`RESTORE_LEXER;`
		2556	`goto ZL1;`
		2557	`default:`
		2558	`break;`
		2559	`}`
		2560	`}`
		2561	`}`
		2562	`return;`
		2563	`ZL1:;`
		2564	`SAVE_LEXER (354);`
		2565	`return;`
		2566	`}`
		2567
		2568	`void`
		2569	`ZR1062 PROTO_N ((ZI414, ZI689, ZO431))`
		2570	`PROTO_T (TYPE ZI414 X DECL_SPEC ZI689 X EXP *ZO431)`
		2571	`{`
		2572	`EXP ZI431;`
		2573
		2574	`if ((CURRENT_TERMINAL) == 354) {`
		2575	`return;`
		2576	`}`
		2577	`{`
		2578	`EXP ZI558;`
		2579	`DECL_SPEC ZI493;`
		2580	`DECL_SPEC ZI456;`
		2581	`DECL_SPEC ZI1063;`
		2582	`DECL_SPEC ZI909;`
		2583	`EXP ZI764;`
		2584
		2585	`switch (CURRENT_TERMINAL) {`
		2586	`case 105:`
		2587	`break;`
		2588	`default:`
		2589	`goto ZL1;`
		2590	`}`
		2591	`ADVANCE_LEXER;`
		2592	`{`
		2593	`switch (CURRENT_TERMINAL) {`
		2594	`case 19:`
		2595	`{`
		2596	`{`
		2597
		2598	`ZI558 = crt_token->pp_data.exp ;`
		2599	`}`
		2600	`ADVANCE_LEXER;`
		2601	`}`
		2602	`break;`
		2603	`case 20:`
		2604	`{`
		2605	`{`
		2606
		2607	`ZI558 = crt_token->pp_data.exp ;`
		2608	`}`
		2609	`ADVANCE_LEXER;`
		2610	`}`
		2611	`break;`
		2612	`default:`
		2613	`goto ZL1;`
		2614	`}`
		2615	`}`
		2616	`{`
		2617
		2618	`(ZI493) = find_linkage ( (ZI558) ) ;`
		2619	`}`
		2620	`{`
		2621
		2622	`(ZI456) = crt_linkage ;`
		2623	`crt_linkage = (ZI493) ;`
		2624	`IGNORE incr_value ( OPT_VAL_external_specs ) ;`
		2625	`}`
		2626	`{`
		2627	`(ZI1063) = ( dspec_extern \| dspec_c ) ;`
		2628	`}`
		2629	`{`
		2630
		2631	`/* Combine two declaration specifiers */`
		2632	`DECL_SPEC d = ( ( (ZI689) & (ZI1063) ) & dspec_duplicate ) ;`
		2633	`if ( d ) report ( crt_loc, ERR_dcl_spec_dup ( d ) ) ;`
		2634	`(ZI909) = ( (ZI689) \| (ZI1063) ) ;`
		2635	`}`
		2636	`{`
		2637	`{`
		2638	`BASE_TYPE ZI1248;`
		2639	`TYPE ZI1249;`
		2640	`CV_SPEC ZI1250;`
		2641	`DECL_SPEC ZI1251;`
		2642	`BASE_TYPE ZI511;`
		2643	`TYPE ZI875;`
		2644	`CV_SPEC ZI876;`
		2645	`DECL_SPEC ZI1600;`
		2646	`DECL_SPEC ZI911;`
		2647
		2648	`{`
		2649
		2650	`/* Resolve declaration-specifiers from other declarators */`
		2651	`(ZI0) = predict_dspec ( 0 ) ;`
		2652	`}`
		2653	`if (!ZI0)`
		2654	`goto ZL4;`
		2655	`ZR906 (ZI414, &ZI1248, &ZI1249, &ZI1250, &ZI1251);`
		2656	`ZR917 (&ZI414, &ZI1248, &ZI1249, &ZI1250, &ZI1251, &ZI511, &ZI875, &ZI876, &ZI1600);`
		2657	`if ((CURRENT_TERMINAL) == 354) {`
		2658	`RESTORE_LEXER;`
		2659	`goto ZL1;`
		2660	`}`
		2661	`{`
		2662
		2663	`/* Combine two declaration specifiers */`
		2664	`DECL_SPEC d = ( ( (ZI909) & (ZI1600) ) & dspec_duplicate ) ;`
		2665	`if ( d ) report ( crt_loc, ERR_dcl_spec_dup ( d ) ) ;`
		2666	`(ZI911) = ( (ZI909) \| (ZI1600) ) ;`
		2667	`}`
		2668	`ZR1252 (&ZI414, &ZI511, &ZI875, &ZI876, &ZI911);`
		2669	`if ((CURRENT_TERMINAL) == 354) {`
		2670	`RESTORE_LEXER;`
		2671	`goto ZL1;`
		2672	`}`
		2673	`{`
		2674
		2675	`(ZI764) = NULL_exp ;`
		2676	`}`
		2677	`{`
		2678
		2679	`decr_value ( OPT_VAL_external_specs ) ;`
		2680	`crt_linkage = (ZI456) ;`
		2681	`}`
		2682	`goto ZL3;`
		2683	`}`
		2684	`/UNREACHED/`
		2685	`ZL4:;`
		2686	`switch (CURRENT_TERMINAL) {`
		2687	`case 105:`
		2688	`{`
		2689	`ZR1062 (ZI414, ZI909, &ZI764);`
		2690	`if ((CURRENT_TERMINAL) == 354) {`
		2691	`RESTORE_LEXER;`
		2692	`goto ZL1;`
		2693	`}`
		2694	`{`
		2695
		2696	`decr_value ( OPT_VAL_external_specs ) ;`
		2697	`crt_linkage = (ZI456) ;`
		2698	`}`
		2699	`}`
		2700	`break;`
		2701	`case 64:`
		2702	`{`
		2703	`TYPE ZI879;`
		2704	`DECL_SPEC ZI911;`
		2705
		2706	`{`
		2707	`{`
		2708	`switch (CURRENT_TERMINAL) {`
		2709	`case 64:`
		2710	`break;`
		2711	`default:`
		2712	`goto ZL1;`
		2713	`}`
		2714	`ADVANCE_LEXER;`
		2715	`}`
		2716	`}`
		2717	`{`
		2718
		2719	`if ( !IS_NULL_type ( (ZI414) ) ) report ( crt_loc, ERR_temp_decl_bad () ) ;`
		2720	`UNUSED ( (ZI909) ) ;`
		2721	`}`
		2722	`{`
		2723
		2724	`(ZI879) = NULL_type ;`
		2725	`}`
		2726	`{`
		2727	`(ZI911) = dspec_none ;`
		2728	`}`
		2729	`ZR1027 (ZI879, ZI911);`
		2730	`if ((CURRENT_TERMINAL) == 354) {`
		2731	`RESTORE_LEXER;`
		2732	`goto ZL1;`
		2733	`}`
		2734	`{`
		2735
		2736	`decr_value ( OPT_VAL_external_specs ) ;`
		2737	`crt_linkage = (ZI456) ;`
		2738	`}`
		2739	`{`
		2740	`{`
		2741	`switch (CURRENT_TERMINAL) {`
		2742	`case 38:`
		2743	`break;`
		2744	`default:`
		2745	`goto ZL1;`
		2746	`}`
		2747	`ADVANCE_LEXER;`
		2748	`}`
		2749	`}`
		2750	`{`
		2751
		2752	`(ZI764) = NULL_exp ;`
		2753	`}`
		2754	`}`
		2755	`break;`
		2756	`case 134: case 147:`
		2757	`{`
		2758	`ZR1072 (ZI414, ZI909, &ZI764);`
		2759	`if ((CURRENT_TERMINAL) == 354) {`
		2760	`RESTORE_LEXER;`
		2761	`goto ZL1;`
		2762	`}`
		2763	`{`
		2764
		2765	`decr_value ( OPT_VAL_external_specs ) ;`
		2766	`crt_linkage = (ZI456) ;`
		2767	`}`
		2768	`}`
		2769	`break;`
		2770	`case 1: case 2: case 3: case 4: case 5:`
		2771	`case 6: case 7: case 8: case 9: case 10:`
		2772	`case 11: case 33: case 65: case 77: case 78:`
		2773	`case 83: case 141:`
		2774	`{`
		2775	`BASE_TYPE ZI511;`
		2776	`TYPE ZI875;`
		2777	`CV_SPEC ZI1253;`
		2778
		2779	`{`
		2780	`(ZI511) = btype_none ;`
		2781	`}`
		2782	`{`
		2783
		2784	`(ZI875) = NULL_type ;`
		2785	`}`
		2786	`{`
		2787	`(ZI1253) = cv_none ;`
		2788	`}`
		2789	`ZR1254 (&ZI414, &ZI909, &ZI511, &ZI875, &ZI1253, &ZI764);`
		2790	`if ((CURRENT_TERMINAL) == 354) {`
		2791	`RESTORE_LEXER;`
		2792	`goto ZL1;`
		2793	`}`
		2794	`{`
		2795
		2796	`decr_value ( OPT_VAL_external_specs ) ;`
		2797	`crt_linkage = (ZI456) ;`
		2798	`}`
		2799	`}`
		2800	`break;`
		2801	`case 126: case 139: case 154:`
		2802	`{`
		2803	`{`
		2804
		2805	`if ( !IS_NULL_type ( (ZI414) ) ) report ( crt_loc, ERR_temp_decl_bad () ) ;`
		2806	`UNUSED ( (ZI909) ) ;`
		2807	`}`
		2808	`ZR1077 (&ZI764);`
		2809	`if ((CURRENT_TERMINAL) == 354) {`
		2810	`RESTORE_LEXER;`
		2811	`goto ZL1;`
		2812	`}`
		2813	`{`
		2814
		2815	`decr_value ( OPT_VAL_external_specs ) ;`
		2816	`crt_linkage = (ZI456) ;`
		2817	`}`
		2818	`}`
		2819	`break;`
		2820	`default:`
		2821	`goto ZL1;`
		2822	`}`
		2823	`ZL3:;`
		2824	`}`
		2825	`ZI431 = ZI764;`
		2826	`}`
		2827	`goto ZL0;`
		2828	`ZL1:;`
		2829	`SAVE_LEXER (354);`
		2830	`return;`
		2831	`ZL0:;`
		2832	`*ZO431 = ZI431;`
		2833	`}`
		2834
		2835	`void`
		2836	`ZR617 PROTO_N ((ZO1215))`
		2837	`PROTO_T (EXP *ZO1215)`
		2838	`{`
		2839	`EXP ZI1215;`
		2840
		2841	`if ((CURRENT_TERMINAL) == 354) {`
		2842	`return;`
		2843	`}`
		2844	`{`
		2845	`EXP ZI431;`
		2846
		2847	`ZR614 (&ZI431);`
		2848	`ZR1216 (ZI431, &ZI1215);`
		2849	`if ((CURRENT_TERMINAL) == 354) {`
		2850	`RESTORE_LEXER;`
		2851	`goto ZL1;`
		2852	`}`
		2853	`}`
		2854	`goto ZL0;`
		2855	`ZL1:;`
		2856	`SAVE_LEXER (354);`
		2857	`return;`
		2858	`ZL0:;`
		2859	`*ZO1215 = ZI1215;`
		2860	`}`
		2861
		2862	`void`
		2863	`ZR1009 PROTO_N ((ZI689, ZI511, ZI414, ZI670))`
		2864	`PROTO_T (DECL_SPEC ZI689 X BASE_TYPE ZI511 X TYPE ZI414 X ACCESS_LIST ZI670)`
		2865	`{`
		2866	`if ((CURRENT_TERMINAL) == 354) {`
		2867	`return;`
		2868	`}`
		2869	`ZL2_1009:;`
		2870	`{`
		2871	`ZR1008 (ZI689, ZI511, ZI414, ZI670);`
		2872	`{`
		2873	`switch (CURRENT_TERMINAL) {`
		2874	`case 42:`
		2875	`{`
		2876	`ADVANCE_LEXER;`
		2877	`{`
		2878
		2879	`crt_templ_qualifier = 0 ;`
		2880	`}`
		2881	`goto ZL2_1009;`
		2882	`}`
		2883	`/UNREACHED/`
		2884	`case 354:`
		2885	`RESTORE_LEXER;`
		2886	`goto ZL1;`
		2887	`default:`
		2888	`break;`
		2889	`}`
		2890	`}`
		2891	`}`
		2892	`return;`
		2893	`ZL1:;`
		2894	`SAVE_LEXER (354);`
		2895	`return;`
		2896	`}`
		2897
		2898	`void`
		2899	`ZR1266 PROTO_N ((ZI425, ZO1239))`
		2900	`PROTO_T (NAMESPACE ZI425 X EXP ZO1239)`
		2901	`{`
		2902	`EXP ZI1239;`
		2903
		2904	`switch (CURRENT_TERMINAL) {`
		2905	`case 2: case 7:`
		2906	`{`
		2907	`IDENTIFIER ZI460;`
		2908	`IDENTIFIER ZI419;`
		2909	`TYPE ZI1265;`
		2910	`BASE_TYPE ZI511;`
		2911	`CV_SPEC ZI783;`
		2912	`TYPE ZI414;`
		2913	`SID_LIST_EXP ZI497;`
		2914	`EXP ZI431;`
		2915
		2916	`{`
		2917	`switch (CURRENT_TERMINAL) {`
		2918	`case 7:`
		2919	`{`
		2920	`{`
		2921
		2922	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		2923	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		2924	`ZI460 = parse_type_template ( id, args, 0 ) ;`
		2925	`crt_templ_qualifier = 1 ;`
		2926	`RESCAN_LEXER ;`
		2927	`}`
		2928	`ADVANCE_LEXER;`
		2929	`}`
		2930	`break;`
		2931	`case 2:`
		2932	`{`
		2933	`{`
		2934
		2935	`ZI460 = crt_token->pp_data.id.use ;`
		2936	`}`
		2937	`ADVANCE_LEXER;`
		2938	`}`
		2939	`break;`
		2940	`default:`
		2941	`goto ZL1;`
		2942	`}`
		2943	`}`
		2944	`{`
		2945
		2946	`crt_id_qualifier = qual_nested ;`
		2947	`qual_namespace = (*ZI425) ;`
		2948	`}`
		2949	`{`
		2950
		2951	`(ZI419) = check_id ( (*ZI425), (ZI460), 0 ) ;`
		2952	`last_namespace = (*ZI425) ;`
		2953	`}`
		2954	`{`
		2955
		2956	`MAKE_type_pre ( cv_none, btype_alias, crt_id_qualifier, (ZI1265) ) ;`
		2957	`COPY_id ( type_name ( (ZI1265) ), (ZI419) ) ;`
		2958	`have_type_specifier = 1 ;`
		2959	`}`
		2960	`{`
		2961	`(ZI511) = btype_none ;`
		2962	`}`
		2963	`{`
		2964	`(ZI783) = cv_none ;`
		2965	`}`
		2966	`{`
		2967
		2968	`(ZI414) = complete_pre_type ( (ZI511), (ZI1265), (ZI783), 1 ) ;`
		2969	`have_type_specifier = 0 ;`
		2970	`}`
		2971	`switch (CURRENT_TERMINAL) {`
		2972	`case 65:`
		2973	`break;`
		2974	`default:`
		2975	`goto ZL1;`
		2976	`}`
		2977	`ADVANCE_LEXER;`
		2978	`ZR500 (&ZI497);`
		2979	`switch (CURRENT_TERMINAL) {`
		2980	`case 39:`
		2981	`break;`
		2982	`case 354:`
		2983	`RESTORE_LEXER;`
		2984	`goto ZL1;`
		2985	`default:`
		2986	`goto ZL1;`
		2987	`}`
		2988	`ADVANCE_LEXER;`
		2989	`{`
		2990
		2991	`(ZI431) = make_func_cast_exp ( (ZI414), (ZI497) ) ;`
		2992	`}`
		2993	`ZR1240 (ZI431, &ZI1239);`
		2994	`if ((CURRENT_TERMINAL) == 354) {`
		2995	`RESTORE_LEXER;`
		2996	`goto ZL1;`
		2997	`}`
		2998	`}`
		2999	`break;`
		3000	`case 1: case 3: case 5: case 6: case 141:`
		3001	`case 147:`
		3002	`{`
		3003	`int ZI480;`
		3004	`IDENTIFIER ZI478;`
		3005	`IDENTIFIER ZI419;`
		3006	`EXP ZI431;`
		3007
		3008	`ZR475 (*ZI425, &ZI480);`
		3009	`ZR476 (*ZI425, &ZI478);`
		3010	`if ((CURRENT_TERMINAL) == 354) {`
		3011	`RESTORE_LEXER;`
		3012	`goto ZL1;`
		3013	`}`
		3014	`{`
		3015
		3016	`crt_id_qualifier = qual_nested ;`
		3017	`qual_namespace = (*ZI425) ;`
		3018	`}`
		3019	`{`
		3020
		3021	`(ZI419) = check_id ( (*ZI425), (ZI478), (ZI480) ) ;`
		3022	`last_namespace = (*ZI425) ;`
		3023	`}`
		3024	`{`
		3025
		3026	`(ZI431) = make_id_exp ( (ZI419) ) ;`
		3027	`}`
		3028	`ZR1240 (ZI431, &ZI1239);`
		3029	`if ((CURRENT_TERMINAL) == 354) {`
		3030	`RESTORE_LEXER;`
		3031	`goto ZL1;`
		3032	`}`
		3033	`}`
		3034	`break;`
		3035	`case 354:`
		3036	`return;`
		3037	`default:`
		3038	`goto ZL1;`
		3039	`}`
		3040	`goto ZL0;`
		3041	`ZL1:;`
		3042	`SAVE_LEXER (354);`
		3043	`return;`
		3044	`ZL0:;`
		3045	`*ZO1239 = ZI1239;`
		3046	`}`
		3047
		3048	`void`
		3049	`ZR1139 PROTO_N ((ZI1137, ZO1138))`
		3050	`PROTO_T (TYPE ZI1137 X TYPE *ZO1138)`
		3051	`{`
		3052	`TYPE ZI1138;`
		3053
		3054	`ZL2_1139:;`
		3055	`switch (CURRENT_TERMINAL) {`
		3056	`case 65: case 66: case 331:`
		3057	`{`
		3058	`TYPE ZI480;`
		3059	`TYPE ZI414;`
		3060
		3061	`ZR952 (&ZI480);`
		3062	`if ((CURRENT_TERMINAL) == 354) {`
		3063	`RESTORE_LEXER;`
		3064	`goto ZL1;`
		3065	`}`
		3066	`{`
		3067
		3068	`(ZI414) = ( IS_NULL_type ( (ZI1137) ) ? (ZI480) : inject_pre_type ( (ZI1137), (ZI480), 0 ) ) ;`
		3069	`}`
		3070	`ZI1137 = ZI414;`
		3071	`goto ZL2_1139;`
		3072	`}`
		3073	`/UNREACHED/`
		3074	`default:`
		3075	`{`
		3076	`ZI1138 = ZI1137;`
		3077	`}`
		3078	`break;`
		3079	`case 354:`
		3080	`return;`
		3081	`}`
		3082	`goto ZL0;`
		3083	`ZL1:;`
		3084	`SAVE_LEXER (354);`
		3085	`return;`
		3086	`ZL0:;`
		3087	`*ZO1138 = ZI1138;`
		3088	`}`
		3089
		3090	`void`
		3091	`ZR885 PROTO_N ((ZI874, ZI875, ZI876, ZO511, ZO414, ZO783))`
		3092	`PROTO_T (BASE_TYPE ZI874 X TYPE ZI875 X CV_SPEC ZI876 X BASE_TYPE ZO511 X TYPE ZO414 X CV_SPEC ZO783)`
		3093	`{`
		3094	`BASE_TYPE ZI511;`
		3095	`TYPE ZI414;`
		3096	`CV_SPEC ZI783;`
		3097
		3098	`if ((CURRENT_TERMINAL) == 354) {`
		3099	`return;`
		3100	`}`
		3101	`{`
		3102	`TYPE ZI574;`
		3103	`BASE_TYPE ZI1390;`
		3104	`TYPE ZI1391;`
		3105	`CV_SPEC ZI1392;`
		3106	`BASE_TYPE ZI878;`
		3107	`TYPE ZI879;`
		3108	`CV_SPEC ZI880;`
		3109
		3110	`{`
		3111
		3112	`/* Resolve type-specifiers from other declarators */`
		3113	`(ZI0) = predict_tspec ( 0 ) ;`
		3114	`}`
		3115	`if (!ZI0)`
		3116	`goto ZL2;`
		3117	`{`
		3118
		3119	`(ZI574) = NULL_type ;`
		3120	`}`
		3121	`ZR872 (ZI574, &ZI1390, &ZI1391, &ZI1392);`
		3122	`ZR885 (&ZI1390, &ZI1391, &ZI1392, &ZI878, &ZI879, &ZI880);`
		3123	`if ((CURRENT_TERMINAL) == 354) {`
		3124	`RESTORE_LEXER;`
		3125	`goto ZL1;`
		3126	`}`
		3127	`{`
		3128
		3129	`if ( (*ZI874) & (ZI878) ) {`
		3130	`(ZI511) = join_pre_types ( (*ZI874), (ZI878) ) ;`
		3131	`} else {`
		3132	`(ZI511) = ( (*ZI874) \| (ZI878) ) ;`
		3133	`}`
		3134	`}`
		3135	`{`
		3136
		3137	`/* Join two partial types */`
		3138	`if ( IS_NULL_type ( (*ZI875) ) ) {`
		3139	`(ZI414) = (ZI879) ;`
		3140	`} else if ( IS_NULL_type ( (ZI879) ) ) {`
		3141	`(ZI414) = (*ZI875) ;`
		3142	`} else {`
		3143	`report ( crt_loc, ERR_dcl_type_simple_many ( (*ZI875), (ZI879) ) ) ;`
		3144	`(ZI414) = (ZI879) ;`
		3145	`}`
		3146	`}`
		3147	`{`
		3148
		3149	`CV_SPEC c = ( (*ZI876) & (ZI880) ) ;`
		3150	`if ( c ) report ( crt_loc, ERR_dcl_type_cv_dup ( c ) ) ;`
		3151	`(ZI783) = ( (*ZI876) \| (ZI880) ) ;`
		3152	`}`
		3153	`goto ZL0;`
		3154	`}`
		3155	`/UNREACHED/`
		3156	`ZL2:;`
		3157	`switch (CURRENT_TERMINAL) {`
		3158	`default:`
		3159	`{`
		3160	`ZI511 = *ZI874;`
		3161	`ZI414 = *ZI875;`
		3162	`ZI783 = *ZI876;`
		3163	`}`
		3164	`break;`
		3165	`}`
		3166	`goto ZL0;`
		3167	`ZL1:;`
		3168	`SAVE_LEXER (354);`
		3169	`return;`
		3170	`ZL0:;`
		3171	`*ZO511 = ZI511;`
		3172	`*ZO414 = ZI414;`
		3173	`*ZO783 = ZI783;`
		3174	`}`
		3175
		3176	`void`
		3177	`ZR1394 PROTO_N ((ZI1393, ZO419))`
		3178	`PROTO_T (NAMESPACE ZI1393 X IDENTIFIER ZO419)`
		3179	`{`
		3180	`IDENTIFIER ZI419;`
		3181
		3182	`switch (CURRENT_TERMINAL) {`
		3183	`case 1: case 3: case 5: case 6: case 141:`
		3184	`case 147:`
		3185	`{`
		3186	`int ZI480;`
		3187	`IDENTIFIER ZI478;`
		3188
		3189	`ZR475 (*ZI1393, &ZI480);`
		3190	`ZR476 (*ZI1393, &ZI478);`
		3191	`if ((CURRENT_TERMINAL) == 354) {`
		3192	`RESTORE_LEXER;`
		3193	`goto ZL1;`
		3194	`}`
		3195	`{`
		3196
		3197	`(ZI419) = check_id ( (*ZI1393), (ZI478), (ZI480) ) ;`
		3198	`last_namespace = (*ZI1393) ;`
		3199	`}`
		3200	`}`
		3201	`break;`
		3202	`case 43:`
		3203	`{`
		3204	`IDENTIFIER ZI519;`
		3205	`BASE_TYPE ZI520;`
		3206	`QUALIFIER ZI455;`
		3207	`int ZI456;`
		3208	`IDENTIFIER ZI522;`
		3209	`BASE_TYPE ZI523;`
		3210	`IDENTIFIER ZI478;`
		3211
		3212	`{`
		3213
		3214	`(ZI519) = DEREF_id ( nspace_name ( (*ZI1393) ) ) ;`
		3215	`}`
		3216	`{`
		3217	`(ZI520) = btype_none ;`
		3218	`}`
		3219	`{`
		3220
		3221	`(ZI455) = crt_id_qualifier ;`
		3222	`(ZI456) = crt_templ_qualifier ;`
		3223	`}`
		3224	`{`
		3225	`{`
		3226	`switch (CURRENT_TERMINAL) {`
		3227	`case 43:`
		3228	`break;`
		3229	`default:`
		3230	`goto ZL1;`
		3231	`}`
		3232	`ADVANCE_LEXER;`
		3233	`}`
		3234	`}`
		3235	`ZR516 (&ZI522, &ZI523);`
		3236	`if ((CURRENT_TERMINAL) == 354) {`
		3237	`RESTORE_LEXER;`
		3238	`goto ZL1;`
		3239	`}`
		3240	`{`
		3241
		3242	`crt_id_qualifier = (ZI455) ;`
		3243	`crt_templ_qualifier = (ZI456) ;`
		3244	`}`
		3245	`{`
		3246
		3247	`(ZI478) = make_pseudo_destr ( (ZI519), (ZI520), (ZI522), (ZI523) ) ;`
		3248	`}`
		3249	`{`
		3250
		3251	`(ZI419) = check_id ( (*ZI1393), (ZI478), 0 ) ;`
		3252	`last_namespace = (*ZI1393) ;`
		3253	`}`
		3254	`}`
		3255	`break;`
		3256	`case 354:`
		3257	`return;`
		3258	`default:`
		3259	`goto ZL1;`
		3260	`}`
		3261	`goto ZL0;`
		3262	`ZL1:;`
		3263	`SAVE_LEXER (354);`
		3264	`return;`
		3265	`ZL0:;`
		3266	`*ZO419 = ZI419;`
		3267	`}`
		3268
		3269	`void`
		3270	`ZR1267 PROTO_N ((ZI425, ZO1239))`
		3271	`PROTO_T (NAMESPACE ZI425 X EXP ZO1239)`
		3272	`{`
		3273	`EXP ZI1239;`
		3274
		3275	`switch (CURRENT_TERMINAL) {`
		3276	`case 2: case 7:`
		3277	`{`
		3278	`IDENTIFIER ZI460;`
		3279	`IDENTIFIER ZI419;`
		3280	`TYPE ZI1265;`
		3281	`BASE_TYPE ZI511;`
		3282	`CV_SPEC ZI783;`
		3283	`TYPE ZI414;`
		3284	`SID_LIST_EXP ZI497;`
		3285	`EXP ZI431;`
		3286
		3287	`{`
		3288	`switch (CURRENT_TERMINAL) {`
		3289	`case 7:`
		3290	`{`
		3291	`{`
		3292
		3293	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		3294	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		3295	`ZI460 = parse_type_template ( id, args, 0 ) ;`
		3296	`crt_templ_qualifier = 1 ;`
		3297	`RESCAN_LEXER ;`
		3298	`}`
		3299	`ADVANCE_LEXER;`
		3300	`}`
		3301	`break;`
		3302	`case 2:`
		3303	`{`
		3304	`{`
		3305
		3306	`ZI460 = crt_token->pp_data.id.use ;`
		3307	`}`
		3308	`ADVANCE_LEXER;`
		3309	`}`
		3310	`break;`
		3311	`default:`
		3312	`goto ZL1;`
		3313	`}`
		3314	`}`
		3315	`{`
		3316
		3317	`crt_id_qualifier = qual_full ;`
		3318	`qual_namespace = (*ZI425) ;`
		3319	`}`
		3320	`{`
		3321
		3322	`(ZI419) = check_id ( (*ZI425), (ZI460), 0 ) ;`
		3323	`last_namespace = (*ZI425) ;`
		3324	`}`
		3325	`{`
		3326
		3327	`MAKE_type_pre ( cv_none, btype_alias, crt_id_qualifier, (ZI1265) ) ;`
		3328	`COPY_id ( type_name ( (ZI1265) ), (ZI419) ) ;`
		3329	`have_type_specifier = 1 ;`
		3330	`}`
		3331	`{`
		3332	`(ZI511) = btype_none ;`
		3333	`}`
		3334	`{`
		3335	`(ZI783) = cv_none ;`
		3336	`}`
		3337	`{`
		3338
		3339	`(ZI414) = complete_pre_type ( (ZI511), (ZI1265), (ZI783), 1 ) ;`
		3340	`have_type_specifier = 0 ;`
		3341	`}`
		3342	`switch (CURRENT_TERMINAL) {`
		3343	`case 65:`
		3344	`break;`
		3345	`default:`
		3346	`goto ZL1;`
		3347	`}`
		3348	`ADVANCE_LEXER;`
		3349	`ZR500 (&ZI497);`
		3350	`switch (CURRENT_TERMINAL) {`
		3351	`case 39:`
		3352	`break;`
		3353	`case 354:`
		3354	`RESTORE_LEXER;`
		3355	`goto ZL1;`
		3356	`default:`
		3357	`goto ZL1;`
		3358	`}`
		3359	`ADVANCE_LEXER;`
		3360	`{`
		3361
		3362	`(ZI431) = make_func_cast_exp ( (ZI414), (ZI497) ) ;`
		3363	`}`
		3364	`ZR1240 (ZI431, &ZI1239);`
		3365	`if ((CURRENT_TERMINAL) == 354) {`
		3366	`RESTORE_LEXER;`
		3367	`goto ZL1;`
		3368	`}`
		3369	`}`
		3370	`break;`
		3371	`case 1: case 3: case 5: case 6: case 141:`
		3372	`case 147:`
		3373	`{`
		3374	`int ZI480;`
		3375	`IDENTIFIER ZI478;`
		3376	`IDENTIFIER ZI419;`
		3377	`EXP ZI431;`
		3378
		3379	`ZR475 (*ZI425, &ZI480);`
		3380	`ZR476 (*ZI425, &ZI478);`
		3381	`if ((CURRENT_TERMINAL) == 354) {`
		3382	`RESTORE_LEXER;`
		3383	`goto ZL1;`
		3384	`}`
		3385	`{`
		3386
		3387	`crt_id_qualifier = qual_full ;`
		3388	`qual_namespace = (*ZI425) ;`
		3389	`}`
		3390	`{`
		3391
		3392	`(ZI419) = check_id ( (*ZI425), (ZI478), (ZI480) ) ;`
		3393	`last_namespace = (*ZI425) ;`
		3394	`}`
		3395	`{`
		3396
		3397	`(ZI431) = make_id_exp ( (ZI419) ) ;`
		3398	`}`
		3399	`ZR1240 (ZI431, &ZI1239);`
		3400	`if ((CURRENT_TERMINAL) == 354) {`
		3401	`RESTORE_LEXER;`
		3402	`goto ZL1;`
		3403	`}`
		3404	`}`
		3405	`break;`
		3406	`case 354:`
		3407	`return;`
		3408	`default:`
		3409	`goto ZL1;`
		3410	`}`
		3411	`goto ZL0;`
		3412	`ZL1:;`
		3413	`SAVE_LEXER (354);`
		3414	`return;`
		3415	`ZL0:;`
		3416	`*ZO1239 = ZI1239;`
		3417	`}`
		3418
		3419	`void`
		3420	`ZR1268 PROTO_N ((ZO1239))`
		3421	`PROTO_T (EXP *ZO1239)`
		3422	`{`
		3423	`EXP ZI1239;`
		3424
		3425	`switch (CURRENT_TERMINAL) {`
		3426	`case 2: case 7:`
		3427	`{`
		3428	`IDENTIFIER ZI460;`
		3429	`NAMESPACE ZI425;`
		3430	`IDENTIFIER ZI419;`
		3431	`TYPE ZI1265;`
		3432	`BASE_TYPE ZI511;`
		3433	`CV_SPEC ZI783;`
		3434	`TYPE ZI414;`
		3435	`SID_LIST_EXP ZI497;`
		3436	`EXP ZI431;`
		3437
		3438	`{`
		3439	`switch (CURRENT_TERMINAL) {`
		3440	`case 7:`
		3441	`{`
		3442	`{`
		3443
		3444	`IDENTIFIER id = crt_token->pp_data.tok.id ;`
		3445	`PPTOKEN *args = crt_token->pp_data.tok.args ;`
		3446	`ZI460 = parse_type_template ( id, args, 0 ) ;`
		3447	`crt_templ_qualifier = 1 ;`
		3448	`RESCAN_LEXER ;`
		3449	`}`
		3450	`ADVANCE_LEXER;`
		3451	`}`
		3452	`break;`
		3453	`case 2:`
		3454	`{`
		3455	`{`
		3456
		3457	`ZI460 = crt_token->pp_data.id.use ;`
		3458	`}`
		3459	`ADVANCE_LEXER;`
		3460	`}`
		3461	`break;`
		3462	`default:`
		3463	`goto ZL1;`
		3464	`}`
		3465	`}`
		3466	`{`
		3467
		3468	`(ZI425) = global_namespace ;`
		3469	`crt_id_qualifier = qual_top ;`
		3470	`qual_namespace = (ZI425) ;`
		3471	`}`
		3472	`{`
		3473
		3474	`(ZI419) = check_id ( (ZI425), (ZI460), 0 ) ;`
		3475	`last_namespace = (ZI425) ;`
		3476	`}`
		3477	`{`
		3478
		3479	`MAKE_type_pre ( cv_none, btype_alias, crt_id_qualifier, (ZI1265) ) ;`
		3480	`COPY_id ( type_name ( (ZI1265) ), (ZI419) ) ;`
		3481	`have_type_specifier = 1 ;`
		3482	`}`
		3483	`{`
		3484	`(ZI511) = btype_none ;`
		3485	`}`
		3486	`{`
		3487	`(ZI783) = cv_none ;`
		3488	`}`
		3489	`{`
		3490
		3491	`(ZI414) = complete_pre_type ( (ZI511), (ZI1265), (ZI783), 1 ) ;`
		3492	`have_type_specifier = 0 ;`
		3493	`}`
		3494	`switch (CURRENT_TERMINAL) {`
		3495	`case 65:`
		3496	`break;`
		3497	`default:`
		3498	`goto ZL1;`
		3499	`}`
		3500	`ADVANCE_LEXER;`
		3501	`ZR500 (&ZI497);`
		3502	`switch (CURRENT_TERMINAL) {`
		3503	`case 39:`
		3504	`break;`
		3505	`case 354:`
		3506	`RESTORE_LEXER;`
		3507	`goto ZL1;`
		3508	`default:`
		3509	`goto ZL1;`
		3510	`}`
		3511	`ADVANCE_LEXER;`
		3512	`{`
		3513
		3514	`(ZI431) = make_func_cast_exp ( (ZI414), (ZI497) ) ;`
		3515	`}`
		3516	`ZR1240 (ZI431, &ZI1239);`
		3517	`if ((CURRENT_TERMINAL) == 354) {`
		3518	`RESTORE_LEXER;`
		3519	`goto ZL1;`
		3520	`}`
		3521	`}`
		3522	`break;`
		3523	`case 1: case 3: case 5: case 6: case 141:`
		3524	`case 147:`
		3525	`{`
		3526	`NAMESPACE ZI425;`
		3527	`int ZI480;`
		3528	`IDENTIFIER ZI478;`
		3529	`IDENTIFIER ZI419;`
		3530	`EXP ZI431;`
		3531
		3532	`{`
		3533
		3534	`(ZI425) = global_namespace ;`
		3535	`crt_id_qualifier = qual_top ;`
		3536	`qual_namespace = (ZI425) ;`
		3537	`}`
		3538	`ZR475 (ZI425, &ZI480);`
		3539	`ZR476 (ZI425, &ZI478);`
		3540	`if ((CURRENT_TERMINAL) == 354) {`
		3541	`RESTORE_LEXER;`
		3542	`goto ZL1;`
		3543	`}`
		3544	`{`
		3545
		3546	`(ZI419) = check_id ( (ZI425), (ZI478), (ZI480) ) ;`
		3547	`last_namespace = (ZI425) ;`
		3548	`}`
		3549	`{`
		3550
		3551	`(ZI431) = make_id_exp ( (ZI419) ) ;`
		3552	`}`
		3553	`ZR1240 (ZI431, &ZI1239);`
		3554	`if ((CURRENT_TERMINAL) == 354) {`
		3555	`RESTORE_LEXER;`
		3556	`goto ZL1;`
		3557	`}`
		3558	`}`
		3559	`break;`
		3560	`case 354:`
		3561	`return;`
		3562	`default:`
		3563	`goto ZL1;`
		3564	`}`
		3565	`goto ZL0;`
		3566	`ZL1:;`
		3567	`SAVE_LEXER (354);`
		3568	`return;`
		3569	`ZL0:;`
		3570	`*ZO1239 = ZI1239;`
		3571	`}`
		3572
		3573	`void`
		3574	`ZR605 PROTO_N ((ZO1231))`
		3575	`PROTO_T (EXP *ZO1231)`
		3576	`{`
		3577	`EXP ZI1231;`
		3578
		3579	`if ((CURRENT_TERMINAL) == 354) {`
		3580	`return;`
		3581	`}`
		3582	`{`
		3583	`EXP ZI431;`
		3584
		3585	`ZR601 (&ZI431);`
		3586	`ZR1232 (ZI431, &ZI1231);`
		3587	`if ((CURRENT_TERMINAL) == 354) {`
		3588	`RESTORE_LEXER;`
		3589	`goto ZL1;`
		3590	`}`
		3591	`}`
		3592	`goto ZL0;`
		3593	`ZL1:;`
		3594	`SAVE_LEXER (354);`
		3595	`return;`
		3596	`ZL0:;`
		3597	`*ZO1231 = ZI1231;`
		3598	`}`
		3599
		3600	`/* BEGINNING OF TRAILER */`
		3601
		3602
		3603
		3604	`/* END OF FILE */`

Subversion Repositories tendra.SVN

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