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

Subversion Repositories tendra.SVN

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