WebSVN – tendra.SVN – Blame – /branches/tendra5/src/tools/tspec/syntax.c

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

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/tools/tspec/syntax.c – Rev 5