WebSVN – tendra.SVN – Blame – /branches/algol60/src/tools/tpl/syntax.c

Rev	Author	Line No.	Line
6	7u83	1	`/*`
		2	`* Automatically generated from the files:`
		3	`* syntax.sid`
		4	`* and`
		5	`* syntax.act`
		6	`* by:`
		7	`* obj/../../utilities/sid/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 "util.h"`
		45	`#include "defs.h"`
		46	`#include "encodings.h"`
		47	`#include "enc_nos.h"`
		48	`#include "consfile.h"`
		49	`#include "lex.h"`
		50	`#include "analyse_sort.h"`
		51	`#include "find_id.h"`
		52	`#include "readstreams.h"`
		53	`#include "standardsh.h"`
		54	`#include "syntax.h"`
		55	`#include "units.h"`
		56
		57	`#if FS_TENDRA`
		58	`#pragma TenDRA begin`
		59	`#pragma TenDRA unreachable code allow`
		60	`#pragma TenDRA variable analysis off`
		61	`#endif`
		62
		63	`static int saved = 0;`
		64	`#define CURRENT_TERMINAL (unsigned)lex_v.t`
		65	`#define ADVANCE_LEXER lex_v = reader()`
		66	`#define SAVE_LEXER(e) ((saved = lex_v.t), (lex_v.t = (e)))`
		67	`#define RESTORE_LEXER (lex_v.t = saved)`
		68
		69	`typedef Al_tagdec *PTR_Al_tagdec;`
		70	`typedef Labdec *PTR_Labdec;`
		71	`typedef char *PTR_char;`
		72	`typedef Tagdec *PTR_Tagdec;`
		73	`typedef TDF *PTR_TDF;`
		74	`typedef Tokdec *PTR_Tokdec;`
		75	`typedef Tokpar *PTR_Tokpar;`
		76	`typedef unsigned long unsigned_long;`
		77
		78
		79	`static Tokpar *g_tokpars;`
		80	`static Sort g_sname;`
		81	`static TDF g_tok_defn;`
		82	`static TokSort g_toksort;`
		83	`int search_for_toks = 1;`
		84	`static Tokdec *g_tokformals;`
		85	`static int g_lastfield;`
		86	`static TDF g_shape;`
		87	`static TDF g_lastshape;`
		88
		89	`static Name *g_shtokname;`
		90	`static int g_has_vis = 0;`
		91	`static Bool issigned;`
		92	`static Labdec *g_labdec;`
		93	`static unsigned long intvalue;`
		94	`static TDF optlab;`
		95	`static TDF g_lower;`
		96	`static TDF g_upper;`
		97	`static Bool g_has_upper;`
		98	`static TDF intro_acc;`
		99	`static TDF intro_init;`
		100
		101	`static int query_t;`
		102	`static int g_cr_v;`
		103	`static int g_ce_v;`
		104	`static int g_unt;`
		105	`static Tagdec *g_app_tags;`
		106
		107	`static void`
		108	`do_procprops(int i)`
		109	`{`
		110	`switch (i) {`
		111	`case 0: return;`
		112	`case 1: OPTION(o_var_callers); return;`
		113	`case 2: OPTION(o_var_callees); return;`
		114	`case 3: OPTION(o_add_procprops(o_var_callers, o_var_callees)); return;`
		115	`case 4: OPTION(o_untidy); return;`
		116	`case 5: OPTION(o_add_procprops(o_var_callers, o_untidy)); return;`
		117	`case 6: OPTION(o_add_procprops(o_var_callees, o_untidy)); return;`
		118	`case 7: OPTION(o_add_procprops(o_var_callers,`
		119	`o_add_procprops(o_var_callees, o_untidy))); return;`
		120	`case 8: OPTION(o_check_stack); return;`
		121	`case 9: OPTION(o_add_procprops(o_var_callers,o_check_stack)); return;`
		122	`case 10: OPTION(o_add_procprops(o_var_callees,o_check_stack)); return;`
		123	`case 11: OPTION(o_add_procprops(o_check_stack,`
		124	`o_add_procprops(o_var_callers, o_var_callees))); return;`
		125	`case 12: OPTION(o_add_procprops(o_untidy,o_check_stack)); return;`
		126	`case 13: OPTION(o_add_procprops(o_check_stack,`
		127	`o_add_procprops(o_var_callers, o_untidy))); return;`
		128	`case 14: OPTION(o_add_procprops(o_check_stack,`
		129	`o_add_procprops(o_var_callees, o_untidy))); return;`
		130	`case 15: OPTION(o_add_procprops(o_check_stack,`
		131	`o_add_procprops(o_var_callers,`
		132	`o_add_procprops(o_var_callees, o_untidy)))); return;`
		133	`}`
		134	`}`
		135
		136	`static int defaultlab = -1;`
		137	`static TDF g_lablist;`
		138	`int do_pp = 0;`
		139
		140	`static void`
		141	`success(void)`
		142	`{`
		143	`IGNORE printf("Reached end\n");`
		144	`print_res();`
		145	`}`
		146
		147	`static int HAS_MAGIC = 1;`
		148	`unsigned long MAJOR_NO = major_version;`
		149	`unsigned long MINOR_NO = minor_version;`
		150
		151
		152
		153	`/* BEGINNING OF FUNCTION DECLARATIONS */`
		154
		155	`extern void read_label(void);`
		156	`static void ZR641(PTR_Tokdec *);`
		157	`static void ZRfull__sortname(void);`
		158	`static void ZR643(int *);`
		159	`static void ZR645(void);`
		160	`extern void read_variety(void);`
		161	`static void ZR646(void);`
		162	`static void ZRtok__formal__list__opt(void);`
		163	`static void ZR647(void);`
		164	`static void ZR648(void);`
		165	`static void ZR650(void);`
		166	`static void ZRsortname__list(void);`
		167	`static void ZRsignature__opt(void);`
		168	`static void ZRexp__sequence(void);`
		169	`static void ZRrange(void);`
		170	`static void ZR654(void);`
		171	`static void ZR655(TDF , PTR_TDF );`
		172	`static void ZRrange__label__list(void);`
		173	`static void ZR656(void);`
		174	`extern void read_shape(void);`
		175	`static void ZR657(void);`
		176	`static void ZRaccess__list(void);`
		177	`static void ZR660(TDF , TDF , TDF , TDF );`
		178	`static void ZRtagshacc__list__opt(void);`
		179	`static void ZR661(TDF , PTR_TDF );`
		180	`static void ZRlabdest__opt(void);`
		181	`static void ZR662(PTR_TDF *);`
		182	`static void ZRalignment__list__opt(void);`
		183	`static void ZR663(void);`
		184	`extern void read_string(void);`
		185	`static void ZR664(void);`
		186	`static void ZRotagexp__list(void);`
		187	`static void ZRvariety__sign(void);`
		188	`static void ZR668(void);`
		189	`static void ZR669(TDF , TDF , PTR_TDF , PTR_Tagdec , int *);`
		190	`static void ZR670(TDF , TDF , PTR_TDF , PTR_Tagdec , int *);`
		191	`extern void read_signed_nat(void);`
		192	`static void ZR672(TDF , TDF , PTR_TDF , PTR_char );`
		193	`extern void read_token(void);`
		194	`static void ZR673(void);`
		195	`static void ZRnat__not__int(void);`
		196	`static void ZRshape__body(void);`
		197	`static void ZRrepeat__starter__opt(void);`
		198	`static void ZR674(void);`
		199	`static void ZRfield__list(void);`
		200	`static void ZR675(void);`
		201	`static void ZR676(void);`
		202	`static void ZR677(TDF , TDF , PTR_TDF , PTR_Tagdec , PTR_char , int );`
		203	`static void ZRrounding__mode__opt(void);`
		204	`static void ZR678(TDF , TDF , PTR_TDF , PTR_Tagdec , PTR_char , int );`
		205	`static void ZRnonst__shape(void);`
		206	`static void ZR679(TDF , TDF , PTR_TDF , PTR_Tagdec , PTR_char , int );`
		207	`static void ZRaccess__opt(void);`
		208	`extern void read_error_code(void);`
		209	`static void ZRpostlude__opt(void);`
		210	`static void ZR680(TDF , TDF , PTR_TDF , PTR_Tagdec , int *);`
		211	`static void ZRexponent__opt(void);`
		212	`static void ZR681(TDF , TDF , PTR_TDF , PTR_Tagdec , int *);`
		213	`static void ZRclosed__exp(void);`
		214	`extern void read_bool(void);`
		215	`static void ZRvarintro__opt(void);`
		216	`extern void read_ntest(void);`
		217	`extern void read_bitfield_variety(void);`
		218	`static void ZRsigned__nat__body(void);`
		219	`static void ZRlabset__opt(void);`
		220	`static void ZRkeep__item(void);`
		221	`static void ZRstruct__def(void);`
		222	`static void ZRnonst__shape__body(void);`
		223	`extern void read_tag(void);`
		224	`static void ZRvariety__opt(void);`
		225	`extern void read_nat_option(void);`
		226	`static void ZRsortname__list__opt(void);`
		227	`extern void read_floating_variety(void);`
		228	`static void ZRtagshacc(void);`
		229	`static void ZRelement__list__opt(void);`
		230	`extern void read_nat(void);`
		231	`extern void read_alignment(void);`
		232	`static void ZRvarpar__opt(void);`
		233	`static void ZRkeep__list(void);`
		234	`static void ZRproc__def(void);`
		235	`extern void read_error_code_list(void);`
		236	`static void ZRcallee__var__opt(void);`
		237	`static void ZRtag__dec(void);`
		238	`static void ZRtag__intro(void);`
		239	`extern void read_exp(void);`
		240	`static void ZRtag__def(void);`
		241	`static void ZRotagexp__list__opt(void);`
		242	`static void ZRtok__formal__list(void);`
		243	`static void ZRuntidy__opt(void);`
		244	`static void ZRcaller__var__opt(void);`
		245	`static void ZRproc__def__body(void);`
		246	`static void ZRlabelled__list(void);`
		247	`static void ZRoffset__exp__list(void);`
		248	`static void ZRbitfield__sign(void);`
		249	`static void ZRtok__dec(void);`
		250	`static void ZRexp__comma__list(void);`
		251	`static void ZRexp__body(void);`
		252	`static void ZRtok__def(void);`
		253	`static void ZRunary__exp(void);`
		254	`static void ZRtagshacc__list(void);`
		255	`static void ZRshapetok(void);`
		256	`static void ZRalignment__list(void);`
		257	`extern void read_error_treatment(void);`
		258	`static void ZRcallee(void);`
		259	`extern void read_al_tag(void);`
		260	`extern void read_exp_list(void);`
		261	`static void ZRelement(void);`
		262	`static void ZR622(void);`
		263	`static void ZRtok__def__body(void);`
		264	`static void ZRinteger(void);`
		265	`extern void read_transfer_mode(void);`
		266	`extern void read_rounding_mode(void);`
		267	`static void ZR625(void);`
		268	`static void ZR626(void);`
		269	`extern void read_access(void);`
		270	`static void ZR627(void);`
		271	`static void ZR628(void);`
		272	`static void ZR629(void);`
		273	`static void ZR630(void);`
		274	`static void ZR632(void);`
		275	`static void ZRkeep__list__opt(void);`
		276	`static void ZR633(void);`
		277	`static void ZRal__tag__def(void);`
		278	`static void ZRotagexp(void);`
		279	`extern void read_program(void);`
		280	`static void ZR634(void);`
		281
		282	`/* BEGINNING OF STATIC VARIABLES */`
		283
		284
		285	`/* BEGINNING OF FUNCTION DEFINITIONS */`
		286
		287	`void`
		288	`read_label(void)`
		289	`{`
		290	`ZL2_label:;`
		291	`switch (CURRENT_TERMINAL) {`
		292	`case 59:`
		293	`{`
		294	`ADVANCE_LEXER;`
		295	`switch (CURRENT_TERMINAL) {`
		296	`case 24:`
		297	`break;`
		298	`default:`
		299	`goto ZL1;`
		300	`}`
		301	`ADVANCE_LEXER;`
		302	`goto ZL2_label;`
		303	`}`
		304	`/UNREACHED/`
		305	`case 60:`
		306	`{`
		307	`PTR_Tokdec ZIa;`
		308
		309	`{`
		310
		311	`(ZIa) = lex_v.val.tokname;`
		312	`(ZIa)->isused = 1;`
		313	`}`
		314	`ADVANCE_LEXER;`
		315	`{`
		316
		317	`expand_tok((ZIa), &(ZIa)->sort);`
		318	`}`
		319	`}`
		320	`break;`
		321	`case 54:`
		322	`{`
		323	`{`
		324
		325	`char * n =lex_v.val.name;`
		326	`Labdec * x = find_lab(n);`
		327	`if (x== (Labdec*)0) {`
		328	`x = MALLOC(Labdec);`
		329	`x->idname.id = n; x->idname.name.unit_name = next_label();`
		330	`x->declared = 0;`
		331	`x->next = labdecs; labdecs = x;`
		332	`}`
		333	`g_labdec = x;`
		334	`o_make_label(out_tdfint32(LOCNAME(x->idname)));`
		335	`}`
		336	`ADVANCE_LEXER;`
		337	`}`
		338	`break;`
		339	`case 130:`
		340	`return;`
		341	`default:`
		342	`goto ZL1;`
		343	`}`
		344	`return;`
		345	`ZL1:;`
		346	`{`
		347	`{`
		348
		349	`fail("Syntax error");`
		350	`}`
		351	`}`
		352	`}`
		353
		354	`static void`
		355	`ZR641(PTR_Tokdec *ZI640)`
		356	`{`
		357	`switch (CURRENT_TERMINAL) {`
		358	`case 43:`
		359	`{`
		360	`ADVANCE_LEXER;`
		361	`{`
		362
		363	`expand_tok((ZI640), &(ZI640)->sort);`
		364	`}`
		365	`}`
		366	`break;`
		367	`case 100:`
		368	`{`
		369	`TDF ZIa;`
		370	`TDF ZIb;`
		371
		372	`ADVANCE_LEXER;`
		373	`{`
		374
		375	`expand_tok((ZI640), &(ZI640)->sort);`
		376	`}`
		377	`{`
		378
		379	`/* (ZIb) uninitialised */`
		380	`(ZIa) = *current_TDF;`
		381	`INIT_TDF(current_TDF);`
		382	`}`
		383	`switch (CURRENT_TERMINAL) {`
		384	`case 78:`
		385	`break;`
		386	`default:`
		387	`goto ZL1;`
		388	`}`
		389	`ADVANCE_LEXER;`
		390	`read_variety ();`
		391	`if ((CURRENT_TERMINAL) == 130) {`
		392	`RESTORE_LEXER;`
		393	`goto ZL1;`
		394	`}`
		395	`{`
		396
		397	`(ZIb) = *current_TDF;`
		398	`INIT_TDF(current_TDF);`
		399	`o_make_int(append_TDF(&(ZIb),1), append_TDF(&(ZIa),1));`
		400	`}`
		401	`switch (CURRENT_TERMINAL) {`
		402	`case 29:`
		403	`break;`
		404	`default:`
		405	`goto ZL1;`
		406	`}`
		407	`ADVANCE_LEXER;`
		408	`}`
		409	`break;`
		410	`case 130:`
		411	`return;`
		412	`default:`
		413	`goto ZL1;`
		414	`}`
		415	`return;`
		416	`ZL1:;`
		417	`SAVE_LEXER (130);`
		418	`return;`
		419	`}`
		420
		421	`static void`
		422	`ZRfull__sortname(void)`
		423	`{`
		424	`if ((CURRENT_TERMINAL) == 130) {`
		425	`return;`
		426	`}`
		427	`{`
		428	`{`
		429
		430	`g_sname.sort = lex_v.t;`
		431	`}`
		432	`{`
		433	`switch (CURRENT_TERMINAL) {`
		434	`case 1:`
		435	`{`
		436	`ADVANCE_LEXER;`
		437	`}`
		438	`break;`
		439	`case 4:`
		440	`{`
		441	`ADVANCE_LEXER;`
		442	`}`
		443	`break;`
		444	`case 8:`
		445	`{`
		446	`ADVANCE_LEXER;`
		447	`}`
		448	`break;`
		449	`case 14:`
		450	`{`
		451	`ADVANCE_LEXER;`
		452	`}`
		453	`break;`
		454	`case 17:`
		455	`{`
		456	`ADVANCE_LEXER;`
		457	`}`
		458	`break;`
		459	`case 39:`
		460	`{`
		461	`ADVANCE_LEXER;`
		462	`}`
		463	`break;`
		464	`case 42:`
		465	`{`
		466	`ADVANCE_LEXER;`
		467	`}`
		468	`break;`
		469	`case 48:`
		470	`{`
		471	`ADVANCE_LEXER;`
		472	`}`
		473	`break;`
		474	`case 59:`
		475	`{`
		476	`ADVANCE_LEXER;`
		477	`}`
		478	`break;`
		479	`case 70:`
		480	`{`
		481	`ADVANCE_LEXER;`
		482	`}`
		483	`break;`
		484	`case 74:`
		485	`{`
		486	`ADVANCE_LEXER;`
		487	`}`
		488	`break;`
		489	`case 90:`
		490	`{`
		491	`ADVANCE_LEXER;`
		492	`}`
		493	`break;`
		494	`case 95:`
		495	`{`
		496	`ADVANCE_LEXER;`
		497	`}`
		498	`break;`
		499	`case 99:`
		500	`{`
		501	`ADVANCE_LEXER;`
		502	`}`
		503	`break;`
		504	`case 105:`
		505	`{`
		506	`ADVANCE_LEXER;`
		507	`}`
		508	`break;`
		509	`case 110:`
		510	`{`
		511	`ADVANCE_LEXER;`
		512	`}`
		513	`break;`
		514	`case 116:`
		515	`{`
		516	`ADVANCE_LEXER;`
		517	`}`
		518	`break;`
		519	`case 119:`
		520	`{`
		521	`ADVANCE_LEXER;`
		522	`}`
		523	`break;`
		524	`case 127:`
		525	`{`
		526	`ADVANCE_LEXER;`
		527	`}`
		528	`break;`
		529	`default:`
		530	`goto ZL1;`
		531	`}`
		532	`}`
		533	`ZR674 ();`
		534	`if ((CURRENT_TERMINAL) == 130) {`
		535	`RESTORE_LEXER;`
		536	`goto ZL1;`
		537	`}`
		538	`}`
		539	`return;`
		540	`ZL1:;`
		541	`SAVE_LEXER (130);`
		542	`return;`
		543	`}`
		544
		545	`static void`
		546	`ZR643(int *ZI642)`
		547	`{`
		548	`switch (CURRENT_TERMINAL) {`
		549	`case 41:`
		550	`{`
		551	`ADVANCE_LEXER;`
		552	`{`
		553
		554	`(constructs[(*ZI642)].f)();`
		555	`}`
		556	`}`
		557	`break;`
		558	`case 98:`
		559	`{`
		560	`TDF ZIa;`
		561	`TDF ZIb;`
		562
		563	`ADVANCE_LEXER;`
		564	`{`
		565
		566	`(constructs[(*ZI642)].f)();`
		567	`}`
		568	`{`
		569
		570	`/* (ZIb) uninitialised */`
		571	`(ZIa) = *current_TDF;`
		572	`INIT_TDF(current_TDF);`
		573	`}`
		574	`switch (CURRENT_TERMINAL) {`
		575	`case 78:`
		576	`break;`
		577	`default:`
		578	`goto ZL1;`
		579	`}`
		580	`ADVANCE_LEXER;`
		581	`read_variety ();`
		582	`if ((CURRENT_TERMINAL) == 130) {`
		583	`RESTORE_LEXER;`
		584	`goto ZL1;`
		585	`}`
		586	`{`
		587
		588	`(ZIb) = *current_TDF;`
		589	`INIT_TDF(current_TDF);`
		590	`o_make_int(append_TDF(&(ZIb),1), append_TDF(&(ZIa),1));`
		591	`}`
		592	`switch (CURRENT_TERMINAL) {`
		593	`case 29:`
		594	`break;`
		595	`default:`
		596	`goto ZL1;`
		597	`}`
		598	`ADVANCE_LEXER;`
		599	`}`
		600	`break;`
		601	`case 130:`
		602	`return;`
		603	`default:`
		604	`goto ZL1;`
		605	`}`
		606	`return;`
		607	`ZL1:;`
		608	`SAVE_LEXER (130);`
		609	`return;`
		610	`}`
		611
		612	`static void`
		613	`ZR645(void)`
		614	`{`
		615	`switch (CURRENT_TERMINAL) {`
		616	`case 78:`
		617	`{`
		618	`TDF ZIa;`
		619	`PTR_TDF ZIb;`
		620
		621	`ADVANCE_LEXER;`
		622	`{`
		623
		624	`SET_TDF((ZIb), &(ZIa));`
		625	`}`
		626	`read_exp ();`
		627	`if ((CURRENT_TERMINAL) == 130) {`
		628	`RESTORE_LEXER;`
		629	`goto ZL1;`
		630	`}`
		631	`{`
		632
		633	`RESET_TDF((ZIb));`
		634	`o_negate(o_wrap, append_TDF(&(ZIa),1));`
		635	`}`
		636	`switch (CURRENT_TERMINAL) {`
		637	`case 29:`
		638	`break;`
		639	`default:`
		640	`goto ZL1;`
		641	`}`
		642	`ADVANCE_LEXER;`
		643	`}`
		644	`break;`
		645	`case 22: case 55: case 69: case 70: case 71:`
		646	`{`
		647	`TDF ZIa;`
		648	`TDF ZIb;`
		649
		650	`ZR634 ();`
		651	`if ((CURRENT_TERMINAL) == 130) {`
		652	`RESTORE_LEXER;`
		653	`goto ZL1;`
		654	`}`
		655	`{`
		656
		657	`/* (ZIb) uninitialised */`
		658	`(ZIa) = *current_TDF;`
		659	`INIT_TDF(current_TDF);`
		660	`}`
		661	`switch (CURRENT_TERMINAL) {`
		662	`case 78:`
		663	`break;`
		664	`default:`
		665	`goto ZL1;`
		666	`}`
		667	`ADVANCE_LEXER;`
		668	`read_variety ();`
		669	`if ((CURRENT_TERMINAL) == 130) {`
		670	`RESTORE_LEXER;`
		671	`goto ZL1;`
		672	`}`
		673	`{`
		674
		675	`(ZIb) = *current_TDF;`
		676	`INIT_TDF(current_TDF);`
		677	`o_make_int(append_TDF(&(ZIb),1), append_TDF(&(ZIa),1));`
		678	`}`
		679	`switch (CURRENT_TERMINAL) {`
		680	`case 29:`
		681	`break;`
		682	`default:`
		683	`goto ZL1;`
		684	`}`
		685	`ADVANCE_LEXER;`
		686	`}`
		687	`break;`
		688	`case 44:`
		689	`{`
		690	`TDF ZIa;`
		691	`TDF ZIb;`
		692	`TDF ZIc;`
		693	`TDF ZId;`
		694	`PTR_TDF ZIe;`
		695	`int ZIf;`
		696	`unsigned_long ZIg;`
		697
		698	`{`
		699
		700	`/* (ZIc), (ZId) uninitialised */`
		701	`(ZIf) = 1;`
		702	`(ZIg) = UL(radix);`
		703	`SET_TDF((ZIe), &(ZIa));`
		704	`out_tdfstring_bytes(fformat(lex_v.val.name,lnum), 8, UI(lnum));`
		705	`RESET_TDF((ZIe));`
		706	`SET_TDF((ZIe), &(ZIb));`
		707	`}`
		708	`ADVANCE_LEXER;`
		709	`ZRexponent__opt ();`
		710	`switch (CURRENT_TERMINAL) {`
		711	`case 78:`
		712	`break;`
		713	`case 130:`
		714	`RESTORE_LEXER;`
		715	`goto ZL1;`
		716	`default:`
		717	`goto ZL1;`
		718	`}`
		719	`ADVANCE_LEXER;`
		720	`{`
		721
		722	`RESET_TDF((ZIe));`
		723	`SET_TDF((ZIe), &(ZIc));`
		724	`}`
		725	`read_floating_variety ();`
		726	`if ((CURRENT_TERMINAL) == 130) {`
		727	`RESTORE_LEXER;`
		728	`goto ZL1;`
		729	`}`
		730	`{`
		731
		732	`RESET_TDF((ZIe));`
		733	`SET_TDF((ZIe), &(ZId));`
		734	`}`
		735	`ZRrounding__mode__opt ();`
		736	`if ((CURRENT_TERMINAL) == 130) {`
		737	`RESTORE_LEXER;`
		738	`goto ZL1;`
		739	`}`
		740	`{`
		741
		742	`RESET_TDF((ZIe));`
		743	`o_make_floating(append_TDF(&(ZIc),1),`
		744	`append_TDF(&(ZId),1),`
		745	`if ((ZIf)) { o_true; } else { o_false; },`
		746	`o_make_string(append_TDF(&(ZIa), 1)),`
		747	`o_make_nat(out_tdfint32((ZIg))),`
		748	`append_TDF(&(ZIb), 1));`
		749	`}`
		750	`switch (CURRENT_TERMINAL) {`
		751	`case 29:`
		752	`break;`
		753	`default:`
		754	`goto ZL1;`
		755	`}`
		756	`ADVANCE_LEXER;`
		757	`}`
		758	`break;`
		759	`case 130:`
		760	`return;`
		761	`default:`
		762	`goto ZL1;`
		763	`}`
		764	`return;`
		765	`ZL1:;`
		766	`SAVE_LEXER (130);`
		767	`return;`
		768	`}`
		769
		770	`void`
		771	`read_variety(void)`
		772	`{`
		773	`ZL2_variety:;`
		774	`switch (CURRENT_TERMINAL) {`
		775	`case 127:`
		776	`{`
		777	`ADVANCE_LEXER;`
		778	`{`
		779	`switch (CURRENT_TERMINAL) {`
		780	`case 24:`
		781	`{`
		782	`ADVANCE_LEXER;`
		783	`goto ZL2_variety;`
		784	`}`
		785	`/UNREACHED/`
		786	`case 86:`
		787	`{`
		788	`TDF ZIa;`
		789	`TDF ZIb;`
		790	`TDF ZIc;`
		791	`PTR_TDF ZId;`
		792
		793	`ADVANCE_LEXER;`
		794	`{`
		795
		796	`/* (ZIb), (ZIc) uninitialised */`
		797	`SET_TDF((ZId), &(ZIa));`
		798	`}`
		799	`switch (CURRENT_TERMINAL) {`
		800	`case 78:`
		801	`break;`
		802	`default:`
		803	`goto ZL1;`
		804	`}`
		805	`ADVANCE_LEXER;`
		806	`read_exp ();`
		807	`if ((CURRENT_TERMINAL) == 130) {`
		808	`RESTORE_LEXER;`
		809	`goto ZL1;`
		810	`}`
		811	`{`
		812
		813	`RESET_TDF((ZId));`
		814	`SET_TDF((ZId), &(ZIb));`
		815	`}`
		816	`switch (CURRENT_TERMINAL) {`
		817	`case 25:`
		818	`break;`
		819	`default:`
		820	`goto ZL1;`
		821	`}`
		822	`ADVANCE_LEXER;`
		823	`read_variety ();`
		824	`if ((CURRENT_TERMINAL) == 130) {`
		825	`RESTORE_LEXER;`
		826	`goto ZL1;`
		827	`}`
		828	`{`
		829
		830	`RESET_TDF((ZId));`
		831	`SET_TDF((ZId), &(ZIc));`
		832	`}`
		833	`switch (CURRENT_TERMINAL) {`
		834	`case 25:`
		835	`break;`
		836	`default:`
		837	`goto ZL1;`
		838	`}`
		839	`ADVANCE_LEXER;`
		840	`read_variety ();`
		841	`if ((CURRENT_TERMINAL) == 130) {`
		842	`RESTORE_LEXER;`
		843	`goto ZL1;`
		844	`}`
		845	`{`
		846
		847	`RESET_TDF((ZId));`
		848	`o_var_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		849	`append_TDF(&(ZIc),1));`
		850	`}`
		851	`switch (CURRENT_TERMINAL) {`
		852	`case 29:`
		853	`break;`
		854	`default:`
		855	`goto ZL1;`
		856	`}`
		857	`ADVANCE_LEXER;`
		858	`}`
		859	`break;`
		860	`default:`
		861	`goto ZL1;`
		862	`}`
		863	`}`
		864	`}`
		865	`break;`
		866	`case 21: case 56: case 64: case 97: case 101:`
		867	`case 121:`
		868	`{`
		869	`ZRvariety__sign ();`
		870	`ZR650 ();`
		871	`if ((CURRENT_TERMINAL) == 130) {`
		872	`RESTORE_LEXER;`
		873	`goto ZL1;`
		874	`}`
		875	`}`
		876	`break;`
		877	`case 126:`
		878	`{`
		879	`int ZIa;`
		880
		881	`{`
		882
		883	`(ZIa) = lex_v.val.v;`
		884	`}`
		885	`ADVANCE_LEXER;`
		886	`{`
		887
		888	`(constructs[(ZIa)].f)();`
		889	`}`
		890	`}`
		891	`break;`
		892	`case 128:`
		893	`{`
		894	`PTR_Tokdec ZIa;`
		895
		896	`{`
		897
		898	`(ZIa) = lex_v.val.tokname;`
		899	`(ZIa)->isused = 1;`
		900	`}`
		901	`ADVANCE_LEXER;`
		902	`{`
		903
		904	`expand_tok((ZIa), &(ZIa)->sort);`
		905	`}`
		906	`}`
		907	`break;`
		908	`case 10: case 22: case 55: case 62: case 68:`
		909	`case 98: case 99: case 100:`
		910	`{`
		911	`TDF ZIa;`
		912	`TDF ZIb;`
		913	`PTR_TDF ZIc;`
		914
		915	`{`
		916
		917	`/* (ZIb) uninitialised */`
		918	`SET_TDF((ZIc), &(ZIa));`
		919	`}`
		920	`ZRsigned__nat__body ();`
		921	`if ((CURRENT_TERMINAL) == 130) {`
		922	`RESTORE_LEXER;`
		923	`goto ZL1;`
		924	`}`
		925	`{`
		926
		927	`RESET_TDF((ZIc));`
		928	`SET_TDF((ZIc), &(ZIb));`
		929	`}`
		930	`switch (CURRENT_TERMINAL) {`
		931	`case 24:`
		932	`break;`
		933	`default:`
		934	`goto ZL1;`
		935	`}`
		936	`ADVANCE_LEXER;`
		937	`ZRsigned__nat__body ();`
		938	`if ((CURRENT_TERMINAL) == 130) {`
		939	`RESTORE_LEXER;`
		940	`goto ZL1;`
		941	`}`
		942	`{`
		943
		944	`RESET_TDF((ZIc));`
		945	`o_var_limits(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		946	`}`
		947	`}`
		948	`break;`
		949	`case 130:`
		950	`return;`
		951	`default:`
		952	`goto ZL1;`
		953	`}`
		954	`return;`
		955	`ZL1:;`
		956	`{`
		957	`{`
		958
		959	`fail("Syntax error");`
		960	`}`
		961	`}`
		962	`}`
		963
		964	`static void`
		965	`ZR646(void)`
		966	`{`
		967	`switch (CURRENT_TERMINAL) {`
		968	`case 79:`
		969	`{`
		970	`TDF ZIa;`
		971	`TDF ZIb;`
		972	`TDF ZIc;`
		973	`TDF ZId;`
		974
		975	`{`
		976
		977	`/* (ZIb), (ZIc), (ZId) uninitialised */`
		978	`(ZIa) = *current_TDF;`
		979	`INIT_TDF(current_TDF);`
		980	`}`
		981	`ADVANCE_LEXER;`
		982	`read_shape ();`
		983	`if ((CURRENT_TERMINAL) == 130) {`
		984	`RESTORE_LEXER;`
		985	`goto ZL1;`
		986	`}`
		987	`{`
		988
		989	`(ZIb) = *current_TDF;`
		990	`INIT_TDF(current_TDF);`
		991	`}`
		992	`switch (CURRENT_TERMINAL) {`
		993	`case 30:`
		994	`break;`
		995	`default:`
		996	`goto ZL1;`
		997	`}`
		998	`ADVANCE_LEXER;`
		999	`ZR660 (&ZIa, &ZIb, &ZIc, &ZId);`
		1000	`if ((CURRENT_TERMINAL) == 130) {`
		1001	`RESTORE_LEXER;`
		1002	`goto ZL1;`
		1003	`}`
		1004	`}`
		1005	`break;`
		1006	`case 112:`
		1007	`{`
		1008	`TDF ZIa;`
		1009
		1010	`{`
		1011
		1012	`(ZIa) = *current_TDF;`
		1013	`INIT_TDF(current_TDF);`
		1014	`}`
		1015	`ADVANCE_LEXER;`
		1016	`switch (CURRENT_TERMINAL) {`
		1017	`case 79:`
		1018	`break;`
		1019	`default:`
		1020	`goto ZL1;`
		1021	`}`
		1022	`ADVANCE_LEXER;`
		1023	`ZRcallee ();`
		1024	`ZRcallee__var__opt ();`
		1025	`if ((CURRENT_TERMINAL) == 130) {`
		1026	`RESTORE_LEXER;`
		1027	`goto ZL1;`
		1028	`}`
		1029	`{`
		1030
		1031	`TDF cees;`
		1032	`cees = *current_TDF;`
		1033	`INIT_TDF(current_TDF);`
		1034	`o_tail_call(do_procprops(g_ce_v*2),`
		1035	`append_TDF(&(ZIa),1), append_TDF(&cees,1));`
		1036	`}`
		1037	`switch (CURRENT_TERMINAL) {`
		1038	`case 30:`
		1039	`break;`
		1040	`default:`
		1041	`goto ZL1;`
		1042	`}`
		1043	`ADVANCE_LEXER;`
		1044	`}`
		1045	`break;`
		1046	`case 130:`
		1047	`return;`
		1048	`default:`
		1049	`break;`
		1050	`}`
		1051	`return;`
		1052	`ZL1:;`
		1053	`SAVE_LEXER (130);`
		1054	`return;`
		1055	`}`
		1056
		1057	`static void`
		1058	`ZRtok__formal__list__opt(void)`
		1059	`{`
		1060	`switch (CURRENT_TERMINAL) {`
		1061	`case 54:`
		1062	`{`
		1063	`ZRtok__formal__list ();`
		1064	`if ((CURRENT_TERMINAL) == 130) {`
		1065	`RESTORE_LEXER;`
		1066	`goto ZL1;`
		1067	`}`
		1068	`}`
		1069	`break;`
		1070	`default:`
		1071	`{`
		1072	`{`
		1073
		1074	`g_tokpars = (Tokpar*)0;`
		1075	`}`
		1076	`}`
		1077	`break;`
		1078	`case 130:`
		1079	`return;`
		1080	`}`
		1081	`return;`
		1082	`ZL1:;`
		1083	`SAVE_LEXER (130);`
		1084	`return;`
		1085	`}`
		1086
		1087	`static void`
		1088	`ZR647(void)`
		1089	`{`
		1090	`switch (CURRENT_TERMINAL) {`
		1091	`case 54:`
		1092	`{`
		1093	`{`
		1094
		1095	`char * n = lex_v.val.name;`
		1096	`Tagdec * x = find_tag(n);`
		1097	`if (x == (Tagdec*)0) { fail("%s is not a tag", n); }`
		1098	`else`
		1099	`if (!x->isvar \|\| x->hassh == 0) {`
		1100	`fail("Don't know shape of %s", n);`
		1101	`}`
		1102	`o_contents(`
		1103	`if (x->hassh == 1) {`
		1104	`o_shape_apply_token(make_tok(&x->sh.shtok), {});`
		1105	`} else { append_TDF(&x->sh.tdfsh, 0); },`
		1106	`o_obtain_tag(make_tag(&x->idname.name)));`
		1107	`}`
		1108	`ADVANCE_LEXER;`
		1109	`}`
		1110	`break;`
		1111	`case 78:`
		1112	`{`
		1113	`TDF ZIa;`
		1114	`TDF ZIb;`
		1115	`PTR_TDF ZIc;`
		1116
		1117	`{`
		1118
		1119	`/* (ZIb) uninitialised */`
		1120	`SET_TDF((ZIc), &(ZIa));`
		1121	`}`
		1122	`ADVANCE_LEXER;`
		1123	`read_shape ();`
		1124	`switch (CURRENT_TERMINAL) {`
		1125	`case 29:`
		1126	`break;`
		1127	`case 130:`
		1128	`RESTORE_LEXER;`
		1129	`goto ZL1;`
		1130	`default:`
		1131	`goto ZL1;`
		1132	`}`
		1133	`ADVANCE_LEXER;`
		1134	`{`
		1135
		1136	`RESET_TDF((ZIc));`
		1137	`SET_TDF((ZIc), &(ZIb));`
		1138	`}`
		1139	`ZRunary__exp ();`
		1140	`if ((CURRENT_TERMINAL) == 130) {`
		1141	`RESTORE_LEXER;`
		1142	`goto ZL1;`
		1143	`}`
		1144	`{`
		1145
		1146	`RESET_TDF((ZIc));`
		1147	`o_contents(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		1148	`}`
		1149	`}`
		1150	`break;`
		1151	`case 130:`
		1152	`return;`
		1153	`default:`
		1154	`goto ZL1;`
		1155	`}`
		1156	`return;`
		1157	`ZL1:;`
		1158	`SAVE_LEXER (130);`
		1159	`return;`
		1160	`}`
		1161
		1162	`static void`
		1163	`ZR648(void)`
		1164	`{`
		1165	`switch (CURRENT_TERMINAL) {`
		1166	`case 76:`
		1167	`{`
		1168	`TDF ZIa;`
		1169	`TDF ZIb;`
		1170	`TDF ZIc;`
		1171	`PTR_TDF ZId;`
		1172	`int ZIe;`
		1173	`PTR_Labdec ZIf;`
		1174
		1175	`{`
		1176
		1177	`/* (ZIb), (ZIc) uninitialised */`
		1178	`(ZIe) = defaultlab;`
		1179	`(ZIf) = labdecs;`
		1180	`defaultlab = -1;`
		1181	`SET_TDF((ZId), &(ZIa));`
		1182	`}`
		1183	`ADVANCE_LEXER;`
		1184	`ZRexp__sequence ();`
		1185	`if ((CURRENT_TERMINAL) == 130) {`
		1186	`RESTORE_LEXER;`
		1187	`goto ZL1;`
		1188	`}`
		1189	`{`
		1190
		1191	`RESET_TDF((ZId));`
		1192	`SET_TDF((ZId), &(ZIb));`
		1193	`}`
		1194	`switch (CURRENT_TERMINAL) {`
		1195	`case 11:`
		1196	`break;`
		1197	`default:`
		1198	`goto ZL1;`
		1199	`}`
		1200	`ADVANCE_LEXER;`
		1201	`ZRlabset__opt ();`
		1202	`if ((CURRENT_TERMINAL) == 130) {`
		1203	`RESTORE_LEXER;`
		1204	`goto ZL1;`
		1205	`}`
		1206	`{`
		1207
		1208	`(ZIc) = optlab;`
		1209	`defaultlab = (ZIe);`
		1210	`tidy_labels((ZIf));`
		1211	`}`
		1212	`ZRexp__sequence ();`
		1213	`if ((CURRENT_TERMINAL) == 130) {`
		1214	`RESTORE_LEXER;`
		1215	`goto ZL1;`
		1216	`}`
		1217	`{`
		1218
		1219	`INIT_TDF((ZId));`
		1220	`RESET_TDF((ZId));`
		1221	`o_conditional(append_TDF(&(ZIc),1),`
		1222	`append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		1223	`}`
		1224	`switch (CURRENT_TERMINAL) {`
		1225	`case 20:`
		1226	`break;`
		1227	`default:`
		1228	`goto ZL1;`
		1229	`}`
		1230	`ADVANCE_LEXER;`
		1231	`}`
		1232	`break;`
		1233	`case 78:`
		1234	`{`
		1235	`TDF ZIa;`
		1236	`TDF ZIb;`
		1237	`TDF ZIc;`
		1238	`PTR_TDF ZId;`
		1239	`int ZIe;`
		1240
		1241	`{`
		1242
		1243	`query_t = lex_query;`
		1244	`}`
		1245	`ADVANCE_LEXER;`
		1246	`{`
		1247
		1248	`/* (ZIb), (ZIc) uninitialised */`
		1249	`(ZIe) = query_t;`
		1250	`SET_TDF((ZId),&(ZIa));`
		1251	`}`
		1252	`read_exp ();`
		1253	`if ((CURRENT_TERMINAL) == 130) {`
		1254	`RESTORE_LEXER;`
		1255	`goto ZL1;`
		1256	`}`
		1257	`{`
		1258
		1259	`RESET_TDF((ZId));`
		1260	`SET_TDF((ZId),&(ZIb));`
		1261	`}`
		1262	`read_ntest ();`
		1263	`if ((CURRENT_TERMINAL) == 130) {`
		1264	`RESTORE_LEXER;`
		1265	`goto ZL1;`
		1266	`}`
		1267	`{`
		1268
		1269	`RESET_TDF((ZId));`
		1270	`SET_TDF((ZId), &(ZIc))`
		1271	`}`
		1272	`read_exp ();`
		1273	`ZRlabdest__opt ();`
		1274	`if ((CURRENT_TERMINAL) == 130) {`
		1275	`RESTORE_LEXER;`
		1276	`goto ZL1;`
		1277	`}`
		1278	`{`
		1279
		1280	`RESET_TDF((ZId));`
		1281	`switch ((ZIe)) {`
		1282	`case lex_query:`
		1283	`o_integer_test({}, append_TDF(&(ZIb),1), append_TDF(&optlab,1),`
		1284	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		1285	`break;`
		1286	`case lex_float__query:`
		1287	`o_floating_test({}, o_impossible, append_TDF(&(ZIb),1),`
		1288	`append_TDF(&optlab,1),`
		1289	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		1290	`break;`
		1291	`case lex_ptr__query:`
		1292	`o_pointer_test({}, append_TDF(&(ZIb),1),append_TDF(&optlab,1),`
		1293	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		1294	`break;`
		1295	`case lex_proc__query:`
		1296	`o_proc_test({}, append_TDF(&(ZIb),1),append_TDF(&optlab,1),`
		1297	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1)`
		1298	`);`
		1299	`break;`
		1300	`case lex_offset__query:`
		1301	`o_offset_test({}, append_TDF(&(ZIb),1), append_TDF(&optlab,1),`
		1302	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1)`
		1303	`);`
		1304	`break;`
		1305	`default: fail("Don't understand test");`
		1306	`}`
		1307	`}`
		1308	`switch (CURRENT_TERMINAL) {`
		1309	`case 29:`
		1310	`break;`
		1311	`default:`
		1312	`goto ZL1;`
		1313	`}`
		1314	`ADVANCE_LEXER;`
		1315	`}`
		1316	`break;`
		1317	`case 130:`
		1318	`return;`
		1319	`default:`
		1320	`goto ZL1;`
		1321	`}`
		1322	`return;`
		1323	`ZL1:;`
		1324	`SAVE_LEXER (130);`
		1325	`return;`
		1326	`}`
		1327
		1328	`static void`
		1329	`ZR650(void)`
		1330	`{`
		1331	`switch (CURRENT_TERMINAL) {`
		1332	`case 21:`
		1333	`{`
		1334	`ADVANCE_LEXER;`
		1335	`{`
		1336
		1337	`o_var_limits(`
		1338	`o_make_signed_nat(out_tdfbool(issigned),`
		1339	`out_tdfint32(UL((issigned)?MINSC:0))),`
		1340	`o_make_signed_nat(out_tdfbool(0),`
		1341	`out_tdfint32(UL((issigned)?MAXSC:MAXUSC))));`
		1342	`}`
		1343	`}`
		1344	`break;`
		1345	`case 56:`
		1346	`{`
		1347	`ADVANCE_LEXER;`
		1348	`{`
		1349
		1350	`o_var_limits(`
		1351	`o_make_signed_nat(out_tdfbool(issigned),`
		1352	`out_tdfint32(UL((issigned)?MINSI:0))),`
		1353	`o_make_signed_nat(out_tdfbool(0),`
		1354	`out_tdfint32(UL((issigned)?MAXSI:MAXUSI))));`
		1355	`}`
		1356	`}`
		1357	`break;`
		1358	`case 64:`
		1359	`{`
		1360	`ADVANCE_LEXER;`
		1361	`{`
		1362
		1363	`o_var_limits(`
		1364	`o_make_signed_nat(out_tdfbool(issigned),`
		1365	`out_tdfint32(UL((issigned)?MINSL:0))),`
		1366	`o_make_signed_nat(out_tdfbool(0),`
		1367	`out_tdfint32(UL((issigned)?MAXSL:MAXUSL))));`
		1368	`}`
		1369	`}`
		1370	`break;`
		1371	`case 97:`
		1372	`{`
		1373	`ADVANCE_LEXER;`
		1374	`{`
		1375
		1376	`o_var_limits(`
		1377	`o_make_signed_nat(out_tdfbool(issigned),`
		1378	`out_tdfint32(UL((issigned)?MINSS:0))),`
		1379	`o_make_signed_nat(out_tdfbool(0),`
		1380	`out_tdfint32(UL((issigned)?MAXSS:MAXUSS))));`
		1381	`}`
		1382	`}`
		1383	`break;`
		1384	`case 130:`
		1385	`return;`
		1386	`default:`
		1387	`goto ZL1;`
		1388	`}`
		1389	`return;`
		1390	`ZL1:;`
		1391	`SAVE_LEXER (130);`
		1392	`return;`
		1393	`}`
		1394
		1395	`static void`
		1396	`ZRsortname__list(void)`
		1397	`{`
		1398	`if ((CURRENT_TERMINAL) == 130) {`
		1399	`return;`
		1400	`}`
		1401	`{`
		1402	`ZRfull__sortname ();`
		1403	`ZR673 ();`
		1404	`if ((CURRENT_TERMINAL) == 130) {`
		1405	`RESTORE_LEXER;`
		1406	`goto ZL1;`
		1407	`}`
		1408	`}`
		1409	`return;`
		1410	`ZL1:;`
		1411	`SAVE_LEXER (130);`
		1412	`return;`
		1413	`}`
		1414
		1415	`static void`
		1416	`ZRsignature__opt(void)`
		1417	`{`
		1418	`switch (CURRENT_TERMINAL) {`
		1419	`case 85: case 104: case 105: case 107:`
		1420	`{`
		1421	`read_string ();`
		1422	`if ((CURRENT_TERMINAL) == 130) {`
		1423	`RESTORE_LEXER;`
		1424	`goto ZL1;`
		1425	`}`
		1426	`{`
		1427
		1428	`current_TDF->no=1;`
		1429	`}`
		1430	`}`
		1431	`break;`
		1432	`case 130:`
		1433	`return;`
		1434	`default:`
		1435	`break;`
		1436	`}`
		1437	`return;`
		1438	`ZL1:;`
		1439	`SAVE_LEXER (130);`
		1440	`return;`
		1441	`}`
		1442
		1443	`static void`
		1444	`ZRexp__sequence(void)`
		1445	`{`
		1446	`switch (CURRENT_TERMINAL) {`
		1447	`case 10: case 19: case 22: case 28: case 41:`
		1448	`case 42: case 43: case 44: case 45: case 52:`
		1449	`case 54: case 55: case 58: case 61: case 62:`
		1450	`case 68: case 76: case 77: case 78: case 79:`
		1451	`case 81: case 82: case 84: case 85: case 86:`
		1452	`case 88: case 98: case 99: case 100: case 102:`
		1453	`case 103: case 104: case 105: case 107: case 109:`
		1454	`case 110: case 111: case 124:`
		1455	`{`
		1456	`read_exp ();`
		1457	`if ((CURRENT_TERMINAL) == 130) {`
		1458	`RESTORE_LEXER;`
		1459	`goto ZL1;`
		1460	`}`
		1461	`{`
		1462
		1463	`current_TDF->no =1;`
		1464	`}`
		1465	`ZR628 ();`
		1466	`if ((CURRENT_TERMINAL) == 130) {`
		1467	`RESTORE_LEXER;`
		1468	`goto ZL1;`
		1469	`}`
		1470	`}`
		1471	`break;`
		1472	`default:`
		1473	`{`
		1474	`{`
		1475
		1476	`current_TDF->no =1;`
		1477	`o_make_top;`
		1478	`}`
		1479	`ZR628 ();`
		1480	`if ((CURRENT_TERMINAL) == 130) {`
		1481	`RESTORE_LEXER;`
		1482	`goto ZL1;`
		1483	`}`
		1484	`}`
		1485	`break;`
		1486	`case 130:`
		1487	`return;`
		1488	`}`
		1489	`return;`
		1490	`ZL1:;`
		1491	`SAVE_LEXER (130);`
		1492	`return;`
		1493	`}`
		1494
		1495	`static void`
		1496	`ZRrange(void)`
		1497	`{`
		1498	`if ((CURRENT_TERMINAL) == 130) {`
		1499	`return;`
		1500	`}`
		1501	`{`
		1502	`PTR_TDF ZIa;`
		1503
		1504	`{`
		1505
		1506	`SET_TDF((ZIa), &g_lower);`
		1507	`}`
		1508	`ZRsigned__nat__body ();`
		1509	`ZR662 (&ZIa);`
		1510	`if ((CURRENT_TERMINAL) == 130) {`
		1511	`RESTORE_LEXER;`
		1512	`goto ZL1;`
		1513	`}`
		1514	`}`
		1515	`return;`
		1516	`ZL1:;`
		1517	`SAVE_LEXER (130);`
		1518	`return;`
		1519	`}`
		1520
		1521	`static void`
		1522	`ZR654(void)`
		1523	`{`
		1524	`switch (CURRENT_TERMINAL) {`
		1525	`case 21:`
		1526	`{`
		1527	`ADVANCE_LEXER;`
		1528	`{`
		1529
		1530	`Name * shtok = tokforcharsh(issigned);`
		1531	`o_shape_apply_token(make_tok(shtok), {});`
		1532	`}`
		1533	`}`
		1534	`break;`
		1535	`case 56:`
		1536	`{`
		1537	`ADVANCE_LEXER;`
		1538	`{`
		1539
		1540	`Name * shtok = tokforintsh(issigned);`
		1541	`o_shape_apply_token(make_tok(shtok), {});`
		1542	`}`
		1543	`}`
		1544	`break;`
		1545	`case 64:`
		1546	`{`
		1547	`ADVANCE_LEXER;`
		1548	`{`
		1549
		1550	`Name * shtok = tokforlongsh(issigned);`
		1551	`o_shape_apply_token(make_tok(shtok), {});`
		1552	`}`
		1553	`}`
		1554	`break;`
		1555	`case 97:`
		1556	`{`
		1557	`ADVANCE_LEXER;`
		1558	`{`
		1559
		1560	`Name * shtok = tokforshortsh(issigned);`
		1561	`o_shape_apply_token(make_tok(shtok), {});`
		1562	`}`
		1563	`}`
		1564	`break;`
		1565	`case 130:`
		1566	`return;`
		1567	`default:`
		1568	`goto ZL1;`
		1569	`}`
		1570	`return;`
		1571	`ZL1:;`
		1572	`SAVE_LEXER (130);`
		1573	`return;`
		1574	`}`
		1575
		1576	`static void`
		1577	`ZR655(TDF ZIa, PTR_TDF ZIb)`
		1578	`{`
		1579	`switch (CURRENT_TERMINAL) {`
		1580	`case 24:`
		1581	`{`
		1582	`ADVANCE_LEXER;`
		1583	`{`
		1584
		1585	`char* n = lex_v.val.name;`
		1586	`Tagdec * x = find_tag(n);`
		1587	`if (x != (Tagdec*)0) { fail("Tag %s declared twice", n); }`
		1588	`x = MALLOC(Tagdec); x->isdeffed = 1; x->hassh=0; x->iskept=0;`
		1589	`NEW_IDNAME(x->idname, n, tag_ent);`
		1590	`x->isvar = 1;`
		1591	`x->next = g_app_tags; g_app_tags = x;`
		1592	`RESET_TDF((*ZIb));`
		1593	`o_make_otagexp(OPTION(make_tag(&x->idname.name)),append_TDF(&(*ZIa),1));`
		1594	`}`
		1595	`switch (CURRENT_TERMINAL) {`
		1596	`case 54:`
		1597	`break;`
		1598	`default:`
		1599	`goto ZL1;`
		1600	`}`
		1601	`ADVANCE_LEXER;`
		1602	`}`
		1603	`break;`
		1604	`default:`
		1605	`{`
		1606	`{`
		1607
		1608	`RESET_TDF((*ZIb));`
		1609	`o_make_otagexp({}, append_TDF(&(*ZIa),1));`
		1610	`}`
		1611	`}`
		1612	`break;`
		1613	`case 130:`
		1614	`return;`
		1615	`}`
		1616	`return;`
		1617	`ZL1:;`
		1618	`SAVE_LEXER (130);`
		1619	`return;`
		1620	`}`
		1621
		1622	`static void`
		1623	`ZRrange__label__list(void)`
		1624	`{`
		1625	`if ((CURRENT_TERMINAL) == 130) {`
		1626	`return;`
		1627	`}`
		1628	`{`
		1629	`TDF ZIa;`
		1630	`PTR_TDF ZIb;`
		1631
		1632	`{`
		1633
		1634	`SET_TDF((ZIb),&(ZIa));`
		1635	`}`
		1636	`ZRrange ();`
		1637	`switch (CURRENT_TERMINAL) {`
		1638	`case 51:`
		1639	`break;`
		1640	`case 130:`
		1641	`RESTORE_LEXER;`
		1642	`goto ZL1;`
		1643	`default:`
		1644	`goto ZL1;`
		1645	`}`
		1646	`ADVANCE_LEXER;`
		1647	`read_label ();`
		1648	`ZR661 (&ZIa, &ZIb);`
		1649	`if ((CURRENT_TERMINAL) == 130) {`
		1650	`RESTORE_LEXER;`
		1651	`goto ZL1;`
		1652	`}`
		1653	`}`
		1654	`return;`
		1655	`ZL1:;`
		1656	`SAVE_LEXER (130);`
		1657	`return;`
		1658	`}`
		1659
		1660	`static void`
		1661	`ZR656(void)`
		1662	`{`
		1663	`switch (CURRENT_TERMINAL) {`
		1664	`case 10: case 19: case 22: case 28: case 41:`
		1665	`case 42: case 43: case 44: case 45: case 52:`
		1666	`case 54: case 55: case 58: case 61: case 62:`
		1667	`case 68: case 76: case 77: case 78: case 79:`
		1668	`case 81: case 82: case 84: case 85: case 86:`
		1669	`case 88: case 98: case 99: case 100: case 102:`
		1670	`case 103: case 104: case 105: case 107: case 109:`
		1671	`case 110: case 111: case 124:`
		1672	`{`
		1673	`ZRexp__comma__list ();`
		1674	`if ((CURRENT_TERMINAL) == 130) {`
		1675	`RESTORE_LEXER;`
		1676	`goto ZL1;`
		1677	`}`
		1678	`}`
		1679	`break;`
		1680	`case 130:`
		1681	`return;`
		1682	`default:`
		1683	`break;`
		1684	`}`
		1685	`return;`
		1686	`ZL1:;`
		1687	`SAVE_LEXER (130);`
		1688	`return;`
		1689	`}`
		1690
		1691	`void`
		1692	`read_shape(void)`
		1693	`{`
		1694	`if ((CURRENT_TERMINAL) == 130) {`
		1695	`return;`
		1696	`}`
		1697	`{`
		1698	`TDF ZIa;`
		1699	`PTR_TDF ZIb;`
		1700	`int ZIc;`
		1701
		1702	`{`
		1703
		1704	`(ZIc) = (current_TDF->first == current_TDF->last &&`
		1705	`current_TDF->first->usage == 0 &&`
		1706	`current_TDF->first->offst == 0);`
		1707	`if (!(ZIc)) { SET_TDF((ZIb), &(ZIa)); }`
		1708	`}`
		1709	`ZRshape__body ();`
		1710	`if ((CURRENT_TERMINAL) == 130) {`
		1711	`RESTORE_LEXER;`
		1712	`goto ZL1;`
		1713	`}`
		1714	`{`
		1715
		1716	`if (!(ZIc)) {`
		1717	`SET((ZIb));`
		1718	`RESET_TDF((ZIb));`
		1719	`append_TDF(&(ZIa),1);`
		1720	`}`
		1721	`}`
		1722	`}`
		1723	`return;`
		1724	`ZL1:;`
		1725	`{`
		1726	`{`
		1727
		1728	`fail("Syntax error");`
		1729	`}`
		1730	`}`
		1731	`}`
		1732
		1733	`static void`
		1734	`ZR657(void)`
		1735	`{`
		1736	`switch (CURRENT_TERMINAL) {`
		1737	`case 23:`
		1738	`{`
		1739	`ADVANCE_LEXER;`
		1740	`{`
		1741
		1742	`g_unt = 3;`
		1743	`}`
		1744	`}`
		1745	`break;`
		1746	`default:`
		1747	`{`
		1748	`{`
		1749
		1750	`g_unt = 1;`
		1751	`}`
		1752	`}`
		1753	`break;`
		1754	`case 130:`
		1755	`return;`
		1756	`}`
		1757	`}`
		1758
		1759	`static void`
		1760	`ZRaccess__list(void)`
		1761	`{`
		1762	`if ((CURRENT_TERMINAL) == 130) {`
		1763	`return;`
		1764	`}`
		1765	`{`
		1766	`read_access ();`
		1767	`if ((CURRENT_TERMINAL) == 130) {`
		1768	`RESTORE_LEXER;`
		1769	`goto ZL1;`
		1770	`}`
		1771	`{`
		1772
		1773	`current_TDF->no=1;`
		1774	`}`
		1775	`ZR627 ();`
		1776	`if ((CURRENT_TERMINAL) == 130) {`
		1777	`RESTORE_LEXER;`
		1778	`goto ZL1;`
		1779	`}`
		1780	`}`
		1781	`return;`
		1782	`ZL1:;`
		1783	`SAVE_LEXER (130);`
		1784	`return;`
		1785	`}`
		1786
		1787	`static void`
		1788	`ZR660(TDF ZIa, TDF ZIb, TDF ZIc, TDF ZId)`
		1789	`{`
		1790	`switch (CURRENT_TERMINAL) {`
		1791	`case 78:`
		1792	`{`
		1793	`ADVANCE_LEXER;`
		1794	`read_exp_list ();`
		1795	`if ((CURRENT_TERMINAL) == 130) {`
		1796	`RESTORE_LEXER;`
		1797	`goto ZL1;`
		1798	`}`
		1799	`{`
		1800
		1801	`(ZIc) = current_TDF;`
		1802	`INIT_TDF(current_TDF);`
		1803	`}`
		1804	`ZRvarpar__opt ();`
		1805	`if ((CURRENT_TERMINAL) == 130) {`
		1806	`RESTORE_LEXER;`
		1807	`goto ZL1;`
		1808	`}`
		1809	`{`
		1810
		1811	`(ZId) = current_TDF;`
		1812	`INIT_TDF(current_TDF);`
		1813	`o_apply_proc(append_TDF(&(ZIb),1), append_TDF(&(ZIa),1),`
		1814	`{ append_TDF(&(ZIc), 1); current_TDF->no = (ZIc).no; },`
		1815	`if ((ZId).no !=0) { OPTION(append_TDF(&(ZId),1)); }`
		1816	`);`
		1817	`}`
		1818	`switch (CURRENT_TERMINAL) {`
		1819	`case 29:`
		1820	`break;`
		1821	`default:`
		1822	`goto ZL1;`
		1823	`}`
		1824	`ADVANCE_LEXER;`
		1825	`}`
		1826	`break;`
		1827	`case 79:`
		1828	`{`
		1829	`TDF ZIe;`
		1830	`TDF ZIf;`
		1831	`TDF ZIg;`
		1832	`int ZIh;`
		1833	`int ZIi;`
		1834	`PTR_Tagdec ZIj;`
		1835	`PTR_Tagdec ZIk;`
		1836	`PTR_Tagdec ZIl;`
		1837
		1838	`ADVANCE_LEXER;`
		1839	`{`
		1840
		1841	`/* (ZIe), (ZIf), (ZIg) uninitialised */`
		1842	`/* (ZIh), (ZIi), (ZIk) uninitialised */`
		1843	`(ZIj) = g_app_tags;`
		1844	`(ZIl) = tagdecs;`
		1845	`g_app_tags = (Tagdec*)0;`
		1846	`}`
		1847	`ZRotagexp__list__opt ();`
		1848	`ZRcaller__var__opt ();`
		1849	`if ((CURRENT_TERMINAL) == 130) {`
		1850	`RESTORE_LEXER;`
		1851	`goto ZL1;`
		1852	`}`
		1853	`{`
		1854
		1855	`(ZIe) = *current_TDF;`
		1856	`INIT_TDF(current_TDF);`
		1857	`(ZIh) = g_cr_v;`
		1858	`(ZIk) = g_app_tags;`
		1859	`g_app_tags = (ZIj);`
		1860	`}`
		1861	`switch (CURRENT_TERMINAL) {`
		1862	`case 93:`
		1863	`break;`
		1864	`default:`
		1865	`goto ZL1;`
		1866	`}`
		1867	`ADVANCE_LEXER;`
		1868	`ZRcallee ();`
		1869	`ZRcallee__var__opt ();`
		1870	`if ((CURRENT_TERMINAL) == 130) {`
		1871	`RESTORE_LEXER;`
		1872	`goto ZL1;`
		1873	`}`
		1874	`{`
		1875
		1876	`(ZIf) = *current_TDF;`
		1877	`(ZIi) = g_ce_v;`
		1878	`INIT_TDF(current_TDF);`
		1879	`while ((ZIk) != (Tagdec*)0) {`
		1880	`Tagdec * x = (ZIk);`
		1881	`(ZIk) = x->next;`
		1882	`x->next = tagdecs;`
		1883	`tagdecs = x;`
		1884	`}`
		1885	`}`
		1886	`ZRpostlude__opt ();`
		1887	`switch (CURRENT_TERMINAL) {`
		1888	`case 30:`
		1889	`break;`
		1890	`case 130:`
		1891	`RESTORE_LEXER;`
		1892	`goto ZL1;`
		1893	`default:`
		1894	`goto ZL1;`
		1895	`}`
		1896	`ADVANCE_LEXER;`
		1897	`ZRuntidy__opt ();`
		1898	`if ((CURRENT_TERMINAL) == 130) {`
		1899	`RESTORE_LEXER;`
		1900	`goto ZL1;`
		1901	`}`
		1902	`{`
		1903
		1904	`(ZIg) = *current_TDF;`
		1905	`INIT_TDF(current_TDF);`
		1906	`tagdecs = (ZIl);`
		1907	`o_apply_general_proc(`
		1908	`append_TDF(&(ZIb),1), do_procprops((ZIh)+2(ZIi)+4*g_unt),`
		1909	`append_TDF(&(*ZIa),1),`
		1910	`{ append_TDF(&(ZIe),1); current_TDF->no = (ZIe).no; },`
		1911	`append_TDF(&(ZIf),1),`
		1912	`append_TDF(&(ZIg), 1))`
		1913	`}`
		1914	`}`
		1915	`break;`
		1916	`case 130:`
		1917	`return;`
		1918	`default:`
		1919	`goto ZL1;`
		1920	`}`
		1921	`return;`
		1922	`ZL1:;`
		1923	`SAVE_LEXER (130);`
		1924	`return;`
		1925	`}`
		1926
		1927	`static void`
		1928	`ZRtagshacc__list__opt(void)`
		1929	`{`
		1930	`if ((CURRENT_TERMINAL) == 130) {`
		1931	`return;`
		1932	`}`
		1933	`{`
		1934	`{`
		1935
		1936	`current_TDF->no =0;`
		1937	`}`
		1938	`ZR664 ();`
		1939	`if ((CURRENT_TERMINAL) == 130) {`
		1940	`RESTORE_LEXER;`
		1941	`goto ZL1;`
		1942	`}`
		1943	`}`
		1944	`return;`
		1945	`ZL1:;`
		1946	`SAVE_LEXER (130);`
		1947	`return;`
		1948	`}`
		1949
		1950	`static void`
		1951	`ZR661(TDF ZIa, PTR_TDF ZIb)`
		1952	`{`
		1953	`switch (CURRENT_TERMINAL) {`
		1954	`default:`
		1955	`{`
		1956	`{`
		1957
		1958	`RESET_TDF((*ZIb));`
		1959	`o_make_caselim(append_TDF(&(*ZIa),1),`
		1960	`append_TDF(&g_lower, g_has_upper),`
		1961	`append_TDF(&g_upper,1));`
		1962	`current_TDF->no = 1;`
		1963	`}`
		1964	`}`
		1965	`break;`
		1966	`case 25:`
		1967	`{`
		1968	`{`
		1969
		1970	`RESET_TDF((*ZIb));`
		1971	`o_make_caselim(append_TDF(&(*ZIa),1),`
		1972	`append_TDF(&g_lower, g_has_upper),`
		1973	`append_TDF(&g_upper,1));`
		1974	`}`
		1975	`ADVANCE_LEXER;`
		1976	`ZRrange__label__list ();`
		1977	`if ((CURRENT_TERMINAL) == 130) {`
		1978	`RESTORE_LEXER;`
		1979	`goto ZL1;`
		1980	`}`
		1981	`{`
		1982
		1983	`current_TDF->no++;`
		1984	`}`
		1985	`}`
		1986	`break;`
		1987	`case 130:`
		1988	`return;`
		1989	`}`
		1990	`return;`
		1991	`ZL1:;`
		1992	`SAVE_LEXER (130);`
		1993	`return;`
		1994	`}`
		1995
		1996	`static void`
		1997	`ZRlabdest__opt(void)`
		1998	`{`
		1999	`switch (CURRENT_TERMINAL) {`
		2000	`case 11:`
		2001	`{`
		2002	`PTR_TDF ZIa;`
		2003
		2004	`ADVANCE_LEXER;`
		2005	`{`
		2006
		2007	`SET_TDF((ZIa), &optlab);`
		2008	`}`
		2009	`read_label ();`
		2010	`if ((CURRENT_TERMINAL) == 130) {`
		2011	`RESTORE_LEXER;`
		2012	`goto ZL1;`
		2013	`}`
		2014	`{`
		2015
		2016	`RESET_TDF((ZIa));`
		2017	`}`
		2018	`}`
		2019	`break;`
		2020	`default:`
		2021	`{`
		2022	`{`
		2023
		2024	`TDF * hold;`
		2025	`SET_TDF(hold, &optlab);`
		2026	`if (defaultlab==-1)defaultlab = next_label();`
		2027	`o_make_label(out_tdfint32(UL(defaultlab)));`
		2028	`RESET_TDF(hold);`
		2029	`}`
		2030	`}`
		2031	`break;`
		2032	`case 130:`
		2033	`return;`
		2034	`}`
		2035	`return;`
		2036	`ZL1:;`
		2037	`SAVE_LEXER (130);`
		2038	`return;`
		2039	`}`
		2040
		2041	`static void`
		2042	`ZR662(PTR_TDF *ZIa)`
		2043	`{`
		2044	`switch (CURRENT_TERMINAL) {`
		2045	`case 24:`
		2046	`{`
		2047	`ADVANCE_LEXER;`
		2048	`{`
		2049
		2050	`RESET_TDF((*ZIa));`
		2051	`SET_TDF((*ZIa), &g_upper);`
		2052	`}`
		2053	`ZRsigned__nat__body ();`
		2054	`if ((CURRENT_TERMINAL) == 130) {`
		2055	`RESTORE_LEXER;`
		2056	`goto ZL1;`
		2057	`}`
		2058	`{`
		2059
		2060	`RESET_TDF((*ZIa));`
		2061	`g_has_upper=1;`
		2062	`}`
		2063	`}`
		2064	`break;`
		2065	`default:`
		2066	`{`
		2067	`{`
		2068
		2069	`RESET_TDF((*ZIa));`
		2070	`g_upper = g_lower;`
		2071	`g_has_upper=0;`
		2072	`}`
		2073	`}`
		2074	`break;`
		2075	`case 130:`
		2076	`return;`
		2077	`}`
		2078	`return;`
		2079	`ZL1:;`
		2080	`SAVE_LEXER (130);`
		2081	`return;`
		2082	`}`
		2083
		2084	`static void`
		2085	`ZRalignment__list__opt(void)`
		2086	`{`
		2087	`switch (CURRENT_TERMINAL) {`
		2088	`default:`
		2089	`{`
		2090	`{`
		2091
		2092	`o_alignment(o_top);`
		2093	`}`
		2094	`}`
		2095	`break;`
		2096	`case 4: case 5: case 7: case 8: case 9:`
		2097	`case 54: case 78:`
		2098	`{`
		2099	`TDF ZIa;`
		2100	`PTR_TDF ZIb;`
		2101	`int ZIc;`
		2102
		2103	`{`
		2104
		2105	`(ZIc) = (current_TDF->first == current_TDF->last &&`
		2106	`current_TDF->first->usage == 0 &&`
		2107	`current_TDF->first->offst == 0);`
		2108	`if (!(ZIc)) { SET_TDF((ZIb), &(ZIa)); }`
		2109	`}`
		2110	`ZRalignment__list ();`
		2111	`if ((CURRENT_TERMINAL) == 130) {`
		2112	`RESTORE_LEXER;`
		2113	`goto ZL1;`
		2114	`}`
		2115	`{`
		2116
		2117	`if (!(ZIc)) {`
		2118	`SET((ZIb));`
		2119	`RESET_TDF((ZIb));`
		2120	`append_TDF(&(ZIa),1);`
		2121	`}`
		2122	`}`
		2123	`}`
		2124	`break;`
		2125	`case 130:`
		2126	`return;`
		2127	`}`
		2128	`return;`
		2129	`ZL1:;`
		2130	`SAVE_LEXER (130);`
		2131	`return;`
		2132	`}`
		2133
		2134	`static void`
		2135	`ZR663(void)`
		2136	`{`
		2137	`switch (CURRENT_TERMINAL) {`
		2138	`case 25:`
		2139	`{`
		2140	`ADVANCE_LEXER;`
		2141	`ZRoffset__exp__list ();`
		2142	`if ((CURRENT_TERMINAL) == 130) {`
		2143	`RESTORE_LEXER;`
		2144	`goto ZL1;`
		2145	`}`
		2146	`{`
		2147
		2148	`current_TDF->no+=2;`
		2149	`}`
		2150	`}`
		2151	`break;`
		2152	`default:`
		2153	`{`
		2154	`{`
		2155
		2156	`current_TDF->no = 2;`
		2157	`}`
		2158	`}`
		2159	`break;`
		2160	`case 130:`
		2161	`return;`
		2162	`}`
		2163	`return;`
		2164	`ZL1:;`
		2165	`SAVE_LEXER (130);`
		2166	`return;`
		2167	`}`
		2168
		2169	`void`
		2170	`read_string(void)`
		2171	`{`
		2172	`ZL2_string:;`
		2173	`switch (CURRENT_TERMINAL) {`
		2174	`case 105:`
		2175	`{`
		2176	`ADVANCE_LEXER;`
		2177	`{`
		2178	`switch (CURRENT_TERMINAL) {`
		2179	`case 24:`
		2180	`{`
		2181	`ADVANCE_LEXER;`
		2182	`goto ZL2_string;`
		2183	`}`
		2184	`/UNREACHED/`
		2185	`case 86:`
		2186	`{`
		2187	`TDF ZIa;`
		2188	`TDF ZIb;`
		2189	`TDF ZIc;`
		2190	`PTR_TDF ZId;`
		2191
		2192	`ADVANCE_LEXER;`
		2193	`{`
		2194
		2195	`/* (ZIb), (ZIc) uninitialised */`
		2196	`SET_TDF((ZId), &(ZIa));`
		2197	`}`
		2198	`switch (CURRENT_TERMINAL) {`
		2199	`case 78:`
		2200	`break;`
		2201	`default:`
		2202	`goto ZL1;`
		2203	`}`
		2204	`ADVANCE_LEXER;`
		2205	`read_exp ();`
		2206	`if ((CURRENT_TERMINAL) == 130) {`
		2207	`RESTORE_LEXER;`
		2208	`goto ZL1;`
		2209	`}`
		2210	`{`
		2211
		2212	`RESET_TDF((ZId));`
		2213	`SET_TDF((ZId), &(ZIb));`
		2214	`}`
		2215	`switch (CURRENT_TERMINAL) {`
		2216	`case 25:`
		2217	`break;`
		2218	`default:`
		2219	`goto ZL1;`
		2220	`}`
		2221	`ADVANCE_LEXER;`
		2222	`read_string ();`
		2223	`switch (CURRENT_TERMINAL) {`
		2224	`case 25:`
		2225	`break;`
		2226	`case 130:`
		2227	`RESTORE_LEXER;`
		2228	`goto ZL1;`
		2229	`default:`
		2230	`goto ZL1;`
		2231	`}`
		2232	`ADVANCE_LEXER;`
		2233	`{`
		2234
		2235	`RESET_TDF((ZId));`
		2236	`SET_TDF((ZId), &(ZIc));`
		2237	`}`
		2238	`read_string ();`
		2239	`if ((CURRENT_TERMINAL) == 130) {`
		2240	`RESTORE_LEXER;`
		2241	`goto ZL1;`
		2242	`}`
		2243	`{`
		2244
		2245	`RESET_TDF((ZId));`
		2246	`o_string_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		2247	`append_TDF(&(ZIc),1));`
		2248	`}`
		2249	`switch (CURRENT_TERMINAL) {`
		2250	`case 29:`
		2251	`break;`
		2252	`default:`
		2253	`goto ZL1;`
		2254	`}`
		2255	`ADVANCE_LEXER;`
		2256	`}`
		2257	`break;`
		2258	`default:`
		2259	`goto ZL1;`
		2260	`}`
		2261	`}`
		2262	`}`
		2263	`break;`
		2264	`case 104:`
		2265	`{`
		2266	`int ZIa;`
		2267
		2268	`{`
		2269
		2270	`(ZIa) = lex_v.val.v;`
		2271	`}`
		2272	`ADVANCE_LEXER;`
		2273	`{`
		2274
		2275	`(constructs[(ZIa)].f)();`
		2276	`}`
		2277	`}`
		2278	`break;`
		2279	`case 107:`
		2280	`{`
		2281	`PTR_Tokdec ZIa;`
		2282
		2283	`{`
		2284
		2285	`(ZIa) = lex_v.val.tokname;`
		2286	`(ZIa)->isused = 1;`
		2287	`}`
		2288	`ADVANCE_LEXER;`
		2289	`{`
		2290
		2291	`expand_tok((ZIa), &(ZIa)->sort);`
		2292	`}`
		2293	`}`
		2294	`break;`
		2295	`case 85:`
		2296	`{`
		2297	`{`
		2298
		2299	`char * s = lex_v.val.name;`
		2300	`o_make_string(out_tdfstring_bytes(s, 8, UI(strlen(s))));`
		2301	`}`
		2302	`ADVANCE_LEXER;`
		2303	`}`
		2304	`break;`
		2305	`case 130:`
		2306	`return;`
		2307	`default:`
		2308	`goto ZL1;`
		2309	`}`
		2310	`return;`
		2311	`ZL1:;`
		2312	`{`
		2313	`{`
		2314
		2315	`fail("Syntax error");`
		2316	`}`
		2317	`}`
		2318	`}`
		2319
		2320	`static void`
		2321	`ZR664(void)`
		2322	`{`
		2323	`switch (CURRENT_TERMINAL) {`
		2324	`case 54:`
		2325	`{`
		2326	`ZRtagshacc__list ();`
		2327	`if ((CURRENT_TERMINAL) == 130) {`
		2328	`RESTORE_LEXER;`
		2329	`goto ZL1;`
		2330	`}`
		2331	`}`
		2332	`break;`
		2333	`case 130:`
		2334	`return;`
		2335	`default:`
		2336	`break;`
		2337	`}`
		2338	`return;`
		2339	`ZL1:;`
		2340	`SAVE_LEXER (130);`
		2341	`return;`
		2342	`}`
		2343
		2344	`static void`
		2345	`ZRotagexp__list(void)`
		2346	`{`
		2347	`if ((CURRENT_TERMINAL) == 130) {`
		2348	`return;`
		2349	`}`
		2350	`{`
		2351	`ZRotagexp ();`
		2352	`if ((CURRENT_TERMINAL) == 130) {`
		2353	`RESTORE_LEXER;`
		2354	`goto ZL1;`
		2355	`}`
		2356	`{`
		2357
		2358	`current_TDF->no = 1;`
		2359	`}`
		2360	`ZR626 ();`
		2361	`if ((CURRENT_TERMINAL) == 130) {`
		2362	`RESTORE_LEXER;`
		2363	`goto ZL1;`
		2364	`}`
		2365	`}`
		2366	`return;`
		2367	`ZL1:;`
		2368	`SAVE_LEXER (130);`
		2369	`return;`
		2370	`}`
		2371
		2372	`static void`
		2373	`ZRvariety__sign(void)`
		2374	`{`
		2375	`switch (CURRENT_TERMINAL) {`
		2376	`case 101:`
		2377	`{`
		2378	`ADVANCE_LEXER;`
		2379	`{`
		2380
		2381	`issigned = 1;`
		2382	`}`
		2383	`}`
		2384	`break;`
		2385	`case 121:`
		2386	`{`
		2387	`ADVANCE_LEXER;`
		2388	`{`
		2389
		2390	`issigned = 0;`
		2391	`}`
		2392	`}`
		2393	`break;`
		2394	`default:`
		2395	`{`
		2396	`{`
		2397
		2398	`issigned = 1;`
		2399	`}`
		2400	`}`
		2401	`break;`
		2402	`case 130:`
		2403	`return;`
		2404	`}`
		2405	`}`
		2406
		2407	`static void`
		2408	`ZR668(void)`
		2409	`{`
		2410	`switch (CURRENT_TERMINAL) {`
		2411	`case 11:`
		2412	`{`
		2413	`ADVANCE_LEXER;`
		2414	`ZRlabelled__list ();`
		2415	`if ((CURRENT_TERMINAL) == 130) {`
		2416	`RESTORE_LEXER;`
		2417	`goto ZL1;`
		2418	`}`
		2419	`{`
		2420
		2421	`g_lablist.no++;`
		2422	`}`
		2423	`}`
		2424	`break;`
		2425	`default:`
		2426	`{`
		2427	`{`
		2428
		2429	`g_lablist.no = 1;`
		2430	`}`
		2431	`}`
		2432	`break;`
		2433	`case 130:`
		2434	`return;`
		2435	`}`
		2436	`return;`
		2437	`ZL1:;`
		2438	`SAVE_LEXER (130);`
		2439	`return;`
		2440	`}`
		2441
		2442	`static void`
		2443	`ZR669(TDF ZIa, TDF ZIb, PTR_TDF ZIc, PTR_Tagdec ZId, int *ZIe)`
		2444	`{`
		2445	`switch (CURRENT_TERMINAL) {`
		2446	`case 36:`
		2447	`{`
		2448	`{`
		2449
		2450	`RESET_TDF((*ZIc));`
		2451	`SET_TDF((ZIc), &(ZIb));`
		2452	`(*ZIe) = g_has_vis;`
		2453	`}`
		2454	`ADVANCE_LEXER;`
		2455	`read_exp ();`
		2456	`if ((CURRENT_TERMINAL) == 130) {`
		2457	`RESTORE_LEXER;`
		2458	`goto ZL1;`
		2459	`}`
		2460	`{`
		2461
		2462	`RESET_TDF((*ZIc));`
		2463	`intro_acc = (*ZIa);`
		2464	`intro_init = (*ZIb);`
		2465	`(*ZId)->isvar=1;`
		2466	`if ((*ZIe)) {`
		2467	`Tagdec * y = MALLOC(Tagdec);`
		2468	`y = (*ZId);`
		2469	`y->next = tagdecs;`
		2470	`tagdecs = y;`
		2471	`}`
		2472	`(*ZId)->next = localdecs;`
		2473	`localdecs = (*ZId);`
		2474	`}`
		2475	`}`
		2476	`break;`
		2477	`case 24:`
		2478	`{`
		2479	`{`
		2480
		2481	`RESET_TDF((*ZIc));`
		2482	`SET_TDF((ZIc), &(ZId)->sh.tdfsh);`
		2483	`(*ZId)->hassh=2;`
		2484	`}`
		2485	`ADVANCE_LEXER;`
		2486	`read_shape ();`
		2487	`if ((CURRENT_TERMINAL) == 130) {`
		2488	`RESTORE_LEXER;`
		2489	`goto ZL1;`
		2490	`}`
		2491	`{`
		2492
		2493	`RESET_TDF((*ZIc));`
		2494	`SET_TDF((ZIc), &(ZIb));`
		2495	`(*ZIe) = g_has_vis;`
		2496	`}`
		2497	`ZR670 (ZIa, ZIb, ZIc, ZId, ZIe);`
		2498	`if ((CURRENT_TERMINAL) == 130) {`
		2499	`RESTORE_LEXER;`
		2500	`goto ZL1;`
		2501	`}`
		2502	`}`
		2503	`break;`
		2504	`case 130:`
		2505	`return;`
		2506	`default:`
		2507	`goto ZL1;`
		2508	`}`
		2509	`return;`
		2510	`ZL1:;`
		2511	`SAVE_LEXER (130);`
		2512	`return;`
		2513	`}`
		2514
		2515	`static void`
		2516	`ZR670(TDF ZIa, TDF ZIb, PTR_TDF ZIc, PTR_Tagdec ZId, int *ZIe)`
		2517	`{`
		2518	`switch (CURRENT_TERMINAL) {`
		2519	`case 36:`
		2520	`{`
		2521	`ADVANCE_LEXER;`
		2522	`read_exp ();`
		2523	`if ((CURRENT_TERMINAL) == 130) {`
		2524	`RESTORE_LEXER;`
		2525	`goto ZL1;`
		2526	`}`
		2527	`{`
		2528
		2529	`RESET_TDF((*ZIc));`
		2530	`intro_acc = (*ZIa);`
		2531	`intro_init = (*ZIb);`
		2532	`(*ZId)->isvar=1;`
		2533	`if ((*ZIe)) {`
		2534	`Tagdec * y = MALLOC(Tagdec);`
		2535	`y = (*ZId);`
		2536	`y->next = tagdecs;`
		2537	`tagdecs = y;`
		2538	`}`
		2539	`(*ZId)->next = localdecs;`
		2540	`localdecs = (*ZId);`
		2541	`}`
		2542	`}`
		2543	`break;`
		2544	`default:`
		2545	`{`
		2546	`{`
		2547
		2548	`o_make_value(append_TDF(&(*ZId)->sh.tdfsh, 0));`
		2549	`}`
		2550	`{`
		2551
		2552	`RESET_TDF((*ZIc));`
		2553	`intro_acc = (*ZIa);`
		2554	`intro_init = (*ZIb);`
		2555	`(*ZId)->isvar=1;`
		2556	`if ((*ZIe)) {`
		2557	`Tagdec * y = MALLOC(Tagdec);`
		2558	`y = (*ZId);`
		2559	`y->next = tagdecs;`
		2560	`tagdecs = y;`
		2561	`}`
		2562	`(*ZId)->next = localdecs;`
		2563	`localdecs = (*ZId);`
		2564	`}`
		2565	`}`
		2566	`break;`
		2567	`case 130:`
		2568	`return;`
		2569	`}`
		2570	`return;`
		2571	`ZL1:;`
		2572	`SAVE_LEXER (130);`
		2573	`return;`
		2574	`}`
		2575
		2576	`void`
		2577	`read_signed_nat(void)`
		2578	`{`
		2579	`if ((CURRENT_TERMINAL) == 130) {`
		2580	`return;`
		2581	`}`
		2582	`{`
		2583	`ZRsigned__nat__body ();`
		2584	`if ((CURRENT_TERMINAL) == 130) {`
		2585	`RESTORE_LEXER;`
		2586	`goto ZL1;`
		2587	`}`
		2588	`}`
		2589	`return;`
		2590	`ZL1:;`
		2591	`{`
		2592	`{`
		2593
		2594	`fail("Syntax error");`
		2595	`}`
		2596	`}`
		2597	`}`
		2598
		2599	`static void`
		2600	`ZR672(TDF ZIa, TDF ZIb, PTR_TDF ZIc, PTR_char ZId)`
		2601	`{`
		2602	`switch (CURRENT_TERMINAL) {`
		2603	`case 3:`
		2604	`{`
		2605	`ADVANCE_LEXER;`
		2606	`ZRunary__exp ();`
		2607	`if ((CURRENT_TERMINAL) == 130) {`
		2608	`RESTORE_LEXER;`
		2609	`goto ZL1;`
		2610	`}`
		2611	`{`
		2612
		2613	`INIT_TDF((*ZIc));`
		2614	`RESET_TDF((*ZIc));`
		2615	`if (strcmp((ZId), "+.") ==0) {`
		2616	`o_add_to_ptr(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2617	`} else if (strcmp((ZId), "-*") ==0) {`
		2618	`o_subtract_ptrs(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2619	`} else if (strcmp((ZId), ".") ==0) {`
		2620	`o_offset_mult(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2621	`} else if (strcmp((*ZId), ".+.") ==0) {`
		2622	`o_offset_add(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2623	`} else if (strcmp((*ZId), ".-.") ==0) {`
		2624	`o_offset_subtract(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2625	`} else if (strcmp((*ZId), "./") ==0) {`
		2626	`o_offset_div_by_int(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2627	`} else if (strcmp((*ZId), "./.") ==0) {`
		2628	`o_offset_div(`
		2629	`o_var_limits(`
		2630	`o_make_signed_nat(out_tdfbool(1), out_tdfint32(UL(MINSI))),`
		2631	`o_make_signed_nat(out_tdfbool(0), out_tdfint32(UL(MAXSI)))),`
		2632	`append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2633	`} else if (strcmp((*ZId), ".max.") ==0) {`
		2634	`o_offset_max(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2635	`} else { fail("%s not an addrop", (*ZId)); }`
		2636	`}`
		2637	`}`
		2638	`break;`
		2639	`case 36:`
		2640	`{`
		2641	`ADVANCE_LEXER;`
		2642	`ZRunary__exp ();`
		2643	`if ((CURRENT_TERMINAL) == 130) {`
		2644	`RESTORE_LEXER;`
		2645	`goto ZL1;`
		2646	`}`
		2647	`{`
		2648
		2649	`INIT_TDF((*ZIc));`
		2650	`RESET_TDF((*ZIc));`
		2651	`o_assign(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2652	`}`
		2653	`}`
		2654	`break;`
		2655	`case 63:`
		2656	`{`
		2657	`ADVANCE_LEXER;`
		2658	`ZRunary__exp ();`
		2659	`if ((CURRENT_TERMINAL) == 130) {`
		2660	`RESTORE_LEXER;`
		2661	`goto ZL1;`
		2662	`}`
		2663	`{`
		2664
		2665	`INIT_TDF((*ZIc));`
		2666	`RESET_TDF((*ZIc));`
		2667	`if (strcmp((*ZId), "And") ==0) {`
		2668	`o_and(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2669	`} else if (strcmp((*ZId), "Or") ==0) {`
		2670	`o_or(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2671	`} else if (strcmp((*ZId), "Xor") ==0) {`
		2672	`o_xor(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2673	`} else { fail("%s not a logop", (*ZId)); }`
		2674	`}`
		2675	`}`
		2676	`break;`
		2677	`case 10: case 68: case 103:`
		2678	`{`
		2679	`{`
		2680	`switch (CURRENT_TERMINAL) {`
		2681	`case 10:`
		2682	`{`
		2683	`ADVANCE_LEXER;`
		2684	`}`
		2685	`break;`
		2686	`case 68:`
		2687	`{`
		2688	`ADVANCE_LEXER;`
		2689	`}`
		2690	`break;`
		2691	`case 103:`
		2692	`{`
		2693	`ADVANCE_LEXER;`
		2694	`}`
		2695	`break;`
		2696	`default:`
		2697	`goto ZL1;`
		2698	`}`
		2699	`}`
		2700	`ZRunary__exp ();`
		2701	`if ((CURRENT_TERMINAL) == 130) {`
		2702	`RESTORE_LEXER;`
		2703	`goto ZL1;`
		2704	`}`
		2705	`{`
		2706
		2707	`INIT_TDF((*ZIc));`
		2708	`RESET_TDF((*ZIc));`
		2709	`if (strcmp((*ZId),"%") ==0) {`
		2710	`o_rem2(o_continue, o_continue, append_TDF(&(*ZIa),1),`
		2711	`append_TDF(&(*ZIb),1));`
		2712	`} else if (strcmp((*ZId),"%1") ==0) {`
		2713	`o_rem1(o_continue, o_continue, append_TDF(&(*ZIa),1),`
		2714	`append_TDF(&(*ZIb),1));`
		2715	`} else if (strcmp((ZId),"") ==0) {`
		2716	`o_mult(o_wrap, append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2717	`} else if (strcmp((*ZId),"+") ==0) {`
		2718	`o_plus(o_wrap, append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2719	`} else if (strcmp((*ZId),"-") ==0) {`
		2720	`o_minus(o_wrap, append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2721	`} else if (strcmp((*ZId),"/") ==0) {`
		2722	`o_div2(o_continue, o_continue, append_TDF(&(*ZIa),1),`
		2723	`append_TDF(&(*ZIb),1));`
		2724	`} else if (strcmp((*ZId),"/1") ==0) {`
		2725	`o_div1(o_continue, o_continue, append_TDF(&(*ZIa),1),`
		2726	`append_TDF(&(*ZIb),1));`
		2727	`} else if (strcmp((*ZId),"<<") ==0) {`
		2728	`o_shift_left(o_wrap, append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2729	`} else if (strcmp((ZId),"F") ==0) {`
		2730	`o_floating_mult(o_continue,`
		2731	`{ LIST_ELEM(append_TDF(&(*ZIa),1));`
		2732	`LIST_ELEM(append_TDF(&(*ZIb),1))});`
		2733	`} else if (strcmp((*ZId),">>") ==0) {`
		2734	`o_shift_right(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		2735	`} else if (strcmp((*ZId),"F+") ==0) {`
		2736	`o_floating_plus(o_continue,`
		2737	`{ LIST_ELEM(append_TDF(&(*ZIa),1));`
		2738	`LIST_ELEM(append_TDF(&(*ZIb),1))});`
		2739	`} else if (strcmp((*ZId),"F-") ==0) {`
		2740	`o_floating_minus(o_continue, append_TDF(&(*ZIa),1),`
		2741	`append_TDF(&(*ZIb),1));`
		2742	`} else if (strcmp((*ZId),"F/") ==0) {`
		2743	`o_floating_div(o_continue, append_TDF(&(*ZIa),1),`
		2744	`append_TDF(&(*ZIb),1));`
		2745	`} else { fail("%s not an arithop", (*ZId)); }`
		2746	`}`
		2747	`}`
		2748	`break;`
		2749	`case 130:`
		2750	`return;`
		2751	`default:`
		2752	`goto ZL1;`
		2753	`}`
		2754	`return;`
		2755	`ZL1:;`
		2756	`SAVE_LEXER (130);`
		2757	`return;`
		2758	`}`
		2759
		2760	`void`
		2761	`read_token(void)`
		2762	`{`
		2763	`ZL2_token:;`
		2764	`switch (CURRENT_TERMINAL) {`
		2765	`case 116:`
		2766	`{`
		2767	`ADVANCE_LEXER;`
		2768	`switch (CURRENT_TERMINAL) {`
		2769	`case 24:`
		2770	`break;`
		2771	`default:`
		2772	`goto ZL1;`
		2773	`}`
		2774	`ADVANCE_LEXER;`
		2775	`goto ZL2_token;`
		2776	`}`
		2777	`/UNREACHED/`
		2778	`case 123:`
		2779	`{`
		2780	`TDF ZIa;`
		2781
		2782	`ADVANCE_LEXER;`
		2783	`{`
		2784
		2785	`(ZIa) = g_tok_defn;`
		2786	`}`
		2787	`ZRtok__def__body ();`
		2788	`if ((CURRENT_TERMINAL) == 130) {`
		2789	`RESTORE_LEXER;`
		2790	`goto ZL1;`
		2791	`}`
		2792	`{`
		2793
		2794	`o_use_tokdef(append_TDF(&g_tok_defn,1));`
		2795	`g_tok_defn = (ZIa);`
		2796	`}`
		2797	`}`
		2798	`break;`
		2799	`case 2: case 5: case 9: case 15: case 18:`
		2800	`case 40: case 43: case 49: case 60: case 71:`
		2801	`case 75: case 91: case 96: case 100: case 111:`
		2802	`case 120: case 128:`
		2803	`{`
		2804	`{`
		2805
		2806	`Tokdec * td = lex_v.val.tokname;`
		2807	`if (td->isparam) {`
		2808	`o_token_apply_token(make_tok(&td->idname.name), {});`
		2809	`} else {`
		2810	`make_tok(&td->idname.name);`
		2811	`}`
		2812	`/* token should only be expanded as parameter of a token */`
		2813	`}`
		2814	`{`
		2815	`switch (CURRENT_TERMINAL) {`
		2816	`case 2:`
		2817	`{`
		2818	`ADVANCE_LEXER;`
		2819	`}`
		2820	`break;`
		2821	`case 5:`
		2822	`{`
		2823	`ADVANCE_LEXER;`
		2824	`}`
		2825	`break;`
		2826	`case 9:`
		2827	`{`
		2828	`ADVANCE_LEXER;`
		2829	`}`
		2830	`break;`
		2831	`case 15:`
		2832	`{`
		2833	`ADVANCE_LEXER;`
		2834	`}`
		2835	`break;`
		2836	`case 18:`
		2837	`{`
		2838	`ADVANCE_LEXER;`
		2839	`}`
		2840	`break;`
		2841	`case 40:`
		2842	`{`
		2843	`ADVANCE_LEXER;`
		2844	`}`
		2845	`break;`
		2846	`case 43:`
		2847	`{`
		2848	`ADVANCE_LEXER;`
		2849	`}`
		2850	`break;`
		2851	`case 49:`
		2852	`{`
		2853	`ADVANCE_LEXER;`
		2854	`}`
		2855	`break;`
		2856	`case 60:`
		2857	`{`
		2858	`ADVANCE_LEXER;`
		2859	`}`
		2860	`break;`
		2861	`case 71:`
		2862	`{`
		2863	`ADVANCE_LEXER;`
		2864	`}`
		2865	`break;`
		2866	`case 75:`
		2867	`{`
		2868	`ADVANCE_LEXER;`
		2869	`}`
		2870	`break;`
		2871	`case 91:`
		2872	`{`
		2873	`ADVANCE_LEXER;`
		2874	`}`
		2875	`break;`
		2876	`case 96:`
		2877	`{`
		2878	`ADVANCE_LEXER;`
		2879	`}`
		2880	`break;`
		2881	`case 100:`
		2882	`{`
		2883	`ADVANCE_LEXER;`
		2884	`}`
		2885	`break;`
		2886	`case 111:`
		2887	`{`
		2888	`ADVANCE_LEXER;`
		2889	`}`
		2890	`break;`
		2891	`case 120:`
		2892	`{`
		2893	`ADVANCE_LEXER;`
		2894	`}`
		2895	`break;`
		2896	`case 128:`
		2897	`{`
		2898	`ADVANCE_LEXER;`
		2899	`}`
		2900	`break;`
		2901	`default:`
		2902	`goto ZL1;`
		2903	`}`
		2904	`}`
		2905	`}`
		2906	`break;`
		2907	`case 130:`
		2908	`return;`
		2909	`default:`
		2910	`goto ZL1;`
		2911	`}`
		2912	`return;`
		2913	`ZL1:;`
		2914	`{`
		2915	`{`
		2916
		2917	`fail("Syntax error");`
		2918	`}`
		2919	`}`
		2920	`}`
		2921
		2922	`static void`
		2923	`ZR673(void)`
		2924	`{`
		2925	`switch (CURRENT_TERMINAL) {`
		2926	`default:`
		2927	`{`
		2928	`{`
		2929
		2930	`g_tokpars = MALLOC(Tokpar);`
		2931	`g_tokpars->par = g_sname;`
		2932	`g_tokpars->next = (Tokpar*)0;`
		2933	`}`
		2934	`}`
		2935	`break;`
		2936	`case 25:`
		2937	`{`
		2938	`Sort ZIa;`
		2939
		2940	`{`
		2941
		2942	`(ZIa) = g_sname;`
		2943	`}`
		2944	`ADVANCE_LEXER;`
		2945	`ZRsortname__list ();`
		2946	`if ((CURRENT_TERMINAL) == 130) {`
		2947	`RESTORE_LEXER;`
		2948	`goto ZL1;`
		2949	`}`
		2950	`{`
		2951
		2952	`Tokpar * x = MALLOC(Tokpar);`
		2953	`x->par = (ZIa);`
		2954	`x->next = g_tokpars;`
		2955	`g_tokpars = x;`
		2956	`}`
		2957	`}`
		2958	`break;`
		2959	`case 130:`
		2960	`return;`
		2961	`}`
		2962	`return;`
		2963	`ZL1:;`
		2964	`SAVE_LEXER (130);`
		2965	`return;`
		2966	`}`
		2967
		2968	`static void`
		2969	`ZRnat__not__int(void)`
		2970	`{`
		2971	`ZL2_nat__not__int:;`
		2972	`switch (CURRENT_TERMINAL) {`
		2973	`case 70:`
		2974	`{`
		2975	`ADVANCE_LEXER;`
		2976	`{`
		2977	`switch (CURRENT_TERMINAL) {`
		2978	`case 24:`
		2979	`{`
		2980	`ADVANCE_LEXER;`
		2981	`read_nat ();`
		2982	`if ((CURRENT_TERMINAL) == 130) {`
		2983	`RESTORE_LEXER;`
		2984	`goto ZL1;`
		2985	`}`
		2986	`}`
		2987	`break;`
		2988	`case 86:`
		2989	`{`
		2990	`TDF ZIa;`
		2991	`TDF ZIb;`
		2992	`TDF ZIc;`
		2993	`PTR_TDF ZId;`
		2994
		2995	`ADVANCE_LEXER;`
		2996	`{`
		2997
		2998	`/* (ZIb), (ZIc) uninitialised */`
		2999	`SET_TDF((ZId), &(ZIa));`
		3000	`}`
		3001	`switch (CURRENT_TERMINAL) {`
		3002	`case 78:`
		3003	`break;`
		3004	`default:`
		3005	`goto ZL1;`
		3006	`}`
		3007	`ADVANCE_LEXER;`
		3008	`read_exp ();`
		3009	`if ((CURRENT_TERMINAL) == 130) {`
		3010	`RESTORE_LEXER;`
		3011	`goto ZL1;`
		3012	`}`
		3013	`{`
		3014
		3015	`RESET_TDF((ZId));`
		3016	`SET_TDF((ZId), &(ZIb));`
		3017	`}`
		3018	`switch (CURRENT_TERMINAL) {`
		3019	`case 25:`
		3020	`break;`
		3021	`default:`
		3022	`goto ZL1;`
		3023	`}`
		3024	`ADVANCE_LEXER;`
		3025	`read_nat ();`
		3026	`if ((CURRENT_TERMINAL) == 130) {`
		3027	`RESTORE_LEXER;`
		3028	`goto ZL1;`
		3029	`}`
		3030	`{`
		3031
		3032	`RESET_TDF((ZId));`
		3033	`SET_TDF((ZId), &(ZIc));`
		3034	`}`
		3035	`switch (CURRENT_TERMINAL) {`
		3036	`case 25:`
		3037	`break;`
		3038	`default:`
		3039	`goto ZL1;`
		3040	`}`
		3041	`ADVANCE_LEXER;`
		3042	`read_nat ();`
		3043	`if ((CURRENT_TERMINAL) == 130) {`
		3044	`RESTORE_LEXER;`
		3045	`goto ZL1;`
		3046	`}`
		3047	`{`
		3048
		3049	`RESET_TDF((ZId));`
		3050	`o_nat_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		3051	`append_TDF(&(ZIc),1));`
		3052	`}`
		3053	`switch (CURRENT_TERMINAL) {`
		3054	`case 29:`
		3055	`break;`
		3056	`default:`
		3057	`goto ZL1;`
		3058	`}`
		3059	`ADVANCE_LEXER;`
		3060	`}`
		3061	`break;`
		3062	`default:`
		3063	`goto ZL1;`
		3064	`}`
		3065	`}`
		3066	`}`
		3067	`break;`
		3068	`case 69:`
		3069	`{`
		3070	`int ZIa;`
		3071
		3072	`{`
		3073
		3074	`(ZIa) = lex_v.val.v;`
		3075	`}`
		3076	`ADVANCE_LEXER;`
		3077	`{`
		3078
		3079	`(constructs[(ZIa)].f)();`
		3080	`}`
		3081	`}`
		3082	`break;`
		3083	`case 71:`
		3084	`{`
		3085	`PTR_Tokdec ZIa;`
		3086
		3087	`{`
		3088
		3089	`(ZIa) = lex_v.val.tokname;`
		3090	`(ZIa)->isused = 1;`
		3091	`}`
		3092	`ADVANCE_LEXER;`
		3093	`{`
		3094
		3095	`expand_tok((ZIa), &(ZIa)->sort);`
		3096	`}`
		3097	`}`
		3098	`break;`
		3099	`case 130:`
		3100	`return;`
		3101	`default:`
		3102	`goto ZL1;`
		3103	`}`
		3104	`return;`
		3105	`ZL1:;`
		3106	`SAVE_LEXER (130);`
		3107	`return;`
		3108	`}`
		3109
		3110	`static void`
		3111	`ZRshape__body(void)`
		3112	`{`
		3113	`switch (CURRENT_TERMINAL) {`
		3114	`case 32:`
		3115	`{`
		3116	`ADVANCE_LEXER;`
		3117	`{`
		3118
		3119	`Name * shtok = tokfordoublesh();`
		3120	`o_shape_apply_token(make_tok(shtok), {});`
		3121	`}`
		3122	`}`
		3123	`break;`
		3124	`case 46:`
		3125	`{`
		3126	`ADVANCE_LEXER;`
		3127	`{`
		3128
		3129	`Name * shtok = tokforfloatsh();`
		3130	`o_shape_apply_token(make_tok(shtok), {});`
		3131	`}`
		3132	`}`
		3133	`break;`
		3134	`case 83:`
		3135	`{`
		3136	`TDF ZIa;`
		3137	`PTR_TDF ZIb;`
		3138
		3139	`ADVANCE_LEXER;`
		3140	`{`
		3141
		3142	`SET_TDF((ZIb), &(ZIa));`
		3143	`}`
		3144	`read_shape ();`
		3145	`if ((CURRENT_TERMINAL) == 130) {`
		3146	`RESTORE_LEXER;`
		3147	`goto ZL1;`
		3148	`}`
		3149	`{`
		3150
		3151	`RESET_TDF((ZIb));`
		3152	`o_pointer(o_alignment(append_TDF(&(ZIa),1)));`
		3153	`}`
		3154	`}`
		3155	`break;`
		3156	`case 95:`
		3157	`{`
		3158	`ADVANCE_LEXER;`
		3159	`ZR676 ();`
		3160	`if ((CURRENT_TERMINAL) == 130) {`
		3161	`RESTORE_LEXER;`
		3162	`goto ZL1;`
		3163	`}`
		3164	`}`
		3165	`break;`
		3166	`case 21: case 56: case 64: case 97: case 101:`
		3167	`case 121:`
		3168	`{`
		3169	`ZRvariety__sign ();`
		3170	`ZR654 ();`
		3171	`if ((CURRENT_TERMINAL) == 130) {`
		3172	`RESTORE_LEXER;`
		3173	`goto ZL1;`
		3174	`}`
		3175	`}`
		3176	`break;`
		3177	`case 94:`
		3178	`{`
		3179	`int ZIa;`
		3180
		3181	`{`
		3182
		3183	`(ZIa) = lex_v.val.v;`
		3184	`}`
		3185	`ADVANCE_LEXER;`
		3186	`{`
		3187
		3188	`(constructs[(ZIa)].f)();`
		3189	`}`
		3190	`}`
		3191	`break;`
		3192	`case 96:`
		3193	`{`
		3194	`PTR_Tokdec ZIa;`
		3195
		3196	`{`
		3197
		3198	`(ZIa) = lex_v.val.tokname;`
		3199	`(ZIa)->isused = 1;`
		3200	`}`
		3201	`ADVANCE_LEXER;`
		3202	`{`
		3203
		3204	`expand_tok((ZIa), &(ZIa)->sort);`
		3205	`}`
		3206	`}`
		3207	`break;`
		3208	`case 130:`
		3209	`return;`
		3210	`default:`
		3211	`goto ZL1;`
		3212	`}`
		3213	`return;`
		3214	`ZL1:;`
		3215	`SAVE_LEXER (130);`
		3216	`return;`
		3217	`}`
		3218
		3219	`static void`
		3220	`ZRrepeat__starter__opt(void)`
		3221	`{`
		3222	`switch (CURRENT_TERMINAL) {`
		3223	`case 78:`
		3224	`{`
		3225	`ADVANCE_LEXER;`
		3226	`ZRexp__sequence ();`
		3227	`switch (CURRENT_TERMINAL) {`
		3228	`case 29:`
		3229	`break;`
		3230	`case 130:`
		3231	`RESTORE_LEXER;`
		3232	`goto ZL1;`
		3233	`default:`
		3234	`goto ZL1;`
		3235	`}`
		3236	`ADVANCE_LEXER;`
		3237	`}`
		3238	`break;`
		3239	`default:`
		3240	`{`
		3241	`{`
		3242
		3243	`o_make_top;`
		3244	`}`
		3245	`}`
		3246	`break;`
		3247	`case 130:`
		3248	`return;`
		3249	`}`
		3250	`return;`
		3251	`ZL1:;`
		3252	`SAVE_LEXER (130);`
		3253	`return;`
		3254	`}`
		3255
		3256	`static void`
		3257	`ZR674(void)`
		3258	`{`
		3259	`switch (CURRENT_TERMINAL) {`
		3260	`default:`
		3261	`{`
		3262	`{`
		3263
		3264	`if (g_sname.sort == token_sort) {`
		3265	`fail("Token pars require result and parameter sorts");`
		3266	`}`
		3267	`g_sname.toksort= (TokSort*)0;`
		3268	`}`
		3269	`}`
		3270	`break;`
		3271	`case 79:`
		3272	`{`
		3273	`Sort ZIa;`
		3274	`PTR_Tokpar ZIb;`
		3275	`PTR_Tokpar ZIc;`
		3276
		3277	`{`
		3278
		3279	`/* (ZIb) uninitialised */`
		3280	`(ZIc) = g_tokpars;`
		3281	`(ZIa) = g_sname;`
		3282	`if (g_sname.sort != token_sort) {`
		3283	`fail("Only token pars require result and parameter sorts");`
		3284	`}`
		3285	`}`
		3286	`ADVANCE_LEXER;`
		3287	`ZRsortname__list__opt ();`
		3288	`switch (CURRENT_TERMINAL) {`
		3289	`case 30:`
		3290	`break;`
		3291	`case 130:`
		3292	`RESTORE_LEXER;`
		3293	`goto ZL1;`
		3294	`default:`
		3295	`goto ZL1;`
		3296	`}`
		3297	`ADVANCE_LEXER;`
		3298	`{`
		3299
		3300	`(ZIb) = g_tokpars;`
		3301	`}`
		3302	`ZRfull__sortname ();`
		3303	`if ((CURRENT_TERMINAL) == 130) {`
		3304	`RESTORE_LEXER;`
		3305	`goto ZL1;`
		3306	`}`
		3307	`{`
		3308
		3309	`TokSort * ts = MALLOC(TokSort);`
		3310	`ts->ressort = g_sname;`
		3311	`ts->pars = (ZIb);`
		3312	`g_tokpars = (ZIc);`
		3313	`(ZIa).toksort = ts;`
		3314	`g_sname = (ZIa);`
		3315	`}`
		3316	`}`
		3317	`break;`
		3318	`case 130:`
		3319	`return;`
		3320	`}`
		3321	`return;`
		3322	`ZL1:;`
		3323	`SAVE_LEXER (130);`
		3324	`return;`
		3325	`}`
		3326
		3327	`static void`
		3328	`ZRfield__list(void)`
		3329	`{`
		3330	`if ((CURRENT_TERMINAL) == 130) {`
		3331	`return;`
		3332	`}`
		3333	`ZL2_field__list:;`
		3334	`{`
		3335	`PTR_TDF ZIa;`
		3336	`PTR_Tokdec ZIb;`
		3337	`PTR_Tokdec ZIc;`
		3338
		3339	`{`
		3340
		3341	`char * dotn = append_string(".",lex_v.val.name);`
		3342	`char * n = lex_v.val.name;`
		3343	`(ZIb) = find_tok(dotn);`
		3344	`(ZIc) = find_tok(n);`
		3345	`if ((ZIb)!= (Tokdec)0 \|\| (ZIc)!= (Tokdec)0)`
		3346	`fail("Field name %s must be unique", dotn);`
		3347	`(ZIb) = MALLOC(Tokdec); NEW_IDNAME((ZIb)->idname, dotn, tok_ent);`
		3348	`(ZIb)->isdeffed = 1; (ZIb)->isused=0; (ZIb)->iskept = 0;`
		3349	`(ZIb)->sort.ressort.sort = exp_sort;`
		3350	`(ZIb)->sort.pars = (Tokpar *)0;`
		3351
		3352	`(ZIc) = MALLOC(Tokdec); NEW_IDNAME((ZIc)->idname, n, tok_ent);`
		3353	`(ZIc)->isdeffed = 1; (ZIc)->isused=0; (ZIc)->iskept = 0;`
		3354	`(ZIc)->sort.ressort.sort = exp_sort;`
		3355	`(ZIc)->sort.pars = MALLOC(Tokpar);`
		3356	`(ZIc)->sort.pars->par.sort = exp_sort;`
		3357	`(ZIc)->sort.pars->next = (Tokpar*)0;`
		3358	`(ZIb)->next = (ZIc);`
		3359	`SET_TDF((ZIa), &g_shape);`
		3360	`}`
		3361	`switch (CURRENT_TERMINAL) {`
		3362	`case 54:`
		3363	`break;`
		3364	`default:`
		3365	`goto ZL1;`
		3366	`}`
		3367	`ADVANCE_LEXER;`
		3368	`switch (CURRENT_TERMINAL) {`
		3369	`case 24:`
		3370	`break;`
		3371	`default:`
		3372	`goto ZL1;`
		3373	`}`
		3374	`ADVANCE_LEXER;`
		3375	`read_shape ();`
		3376	`if ((CURRENT_TERMINAL) == 130) {`
		3377	`RESTORE_LEXER;`
		3378	`goto ZL1;`
		3379	`}`
		3380	`{`
		3381
		3382	`int tn;`
		3383	`RESET_TDF((ZIa));`
		3384	`o_make_tokdef(out_tdfint32(LOCNAME((ZIb)->idname)), {},`
		3385	`o_token_def(o_exp, {},`
		3386	`if (g_lastfield==-1) { /* first field */`
		3387	`o_offset_zero(o_alignment(append_TDF(&g_shape, 0)));`
		3388	`} else {`
		3389	`o_offset_pad(o_alignment(append_TDF(&g_shape,0)),`
		3390	`o_offset_add(o_exp_apply_token(`
		3391	`o_make_tok(out_tdfint32(UL(g_lastfield))),{}),`
		3392	`o_shape_offset(append_TDF(&g_lastshape, 1))))`
		3393	`}));`
		3394	`g_lastfield = (int)(LOCNAME((ZIb)->idname));`
		3395	`g_lastshape = g_shape;`
		3396	`INC_LIST;`
		3397	`o_make_tokdef(out_tdfint32(LOCNAME((ZIc)->idname)), {},`
		3398	`o_token_def(o_exp,`
		3399	`LIST_ELEM(o_make_tokformals(o_exp,`
		3400	`out_tdfint32(UL(tn=next_unit_name(tok_ent))))),`
		3401	`o_component(append_TDF(&g_lastshape,0),`
		3402	`o_exp_apply_token(o_make_tok(out_tdfint32(UL(tn))),{}),`
		3403	`o_exp_apply_token(`
		3404	`o_make_tok(out_tdfint32(UL(g_lastfield))),{}))));`
		3405	`INC_LIST;`
		3406	`(ZIc)->next = tokdecs;`
		3407	`tokdecs = (ZIb);`
		3408	`}`
		3409	`{`
		3410	`switch (CURRENT_TERMINAL) {`
		3411	`case 25:`
		3412	`{`
		3413	`ADVANCE_LEXER;`
		3414	`goto ZL2_field__list;`
		3415	`}`
		3416	`/UNREACHED/`
		3417	`default:`
		3418	`break;`
		3419	`}`
		3420	`}`
		3421	`}`
		3422	`return;`
		3423	`ZL1:;`
		3424	`SAVE_LEXER (130);`
		3425	`return;`
		3426	`}`
		3427
		3428	`static void`
		3429	`ZR675(void)`
		3430	`{`
		3431	`switch (CURRENT_TERMINAL) {`
		3432	`case 21:`
		3433	`{`
		3434	`ADVANCE_LEXER;`
		3435	`{`
		3436
		3437	`* g_shtokname = *(tokforcharsh(issigned));`
		3438	`}`
		3439	`}`
		3440	`break;`
		3441	`case 56:`
		3442	`{`
		3443	`ADVANCE_LEXER;`
		3444	`{`
		3445
		3446	`* g_shtokname = *(tokforintsh(issigned));`
		3447	`}`
		3448	`}`
		3449	`break;`
		3450	`case 64:`
		3451	`{`
		3452	`ADVANCE_LEXER;`
		3453	`{`
		3454
		3455	`* g_shtokname = *(tokforlongsh(issigned));`
		3456	`}`
		3457	`}`
		3458	`break;`
		3459	`case 97:`
		3460	`{`
		3461	`ADVANCE_LEXER;`
		3462	`{`
		3463
		3464	`* g_shtokname = *(tokforshortsh(issigned));`
		3465	`}`
		3466	`}`
		3467	`break;`
		3468	`case 130:`
		3469	`return;`
		3470	`default:`
		3471	`goto ZL1;`
		3472	`}`
		3473	`return;`
		3474	`ZL1:;`
		3475	`SAVE_LEXER (130);`
		3476	`return;`
		3477	`}`
		3478
		3479	`static void`
		3480	`ZR676(void)`
		3481	`{`
		3482	`switch (CURRENT_TERMINAL) {`
		3483	`case 24:`
		3484	`{`
		3485	`ADVANCE_LEXER;`
		3486	`read_shape ();`
		3487	`if ((CURRENT_TERMINAL) == 130) {`
		3488	`RESTORE_LEXER;`
		3489	`goto ZL1;`
		3490	`}`
		3491	`}`
		3492	`break;`
		3493	`case 86:`
		3494	`{`
		3495	`TDF ZIa;`
		3496	`TDF ZIb;`
		3497	`TDF ZIc;`
		3498	`PTR_TDF ZId;`
		3499
		3500	`ADVANCE_LEXER;`
		3501	`{`
		3502
		3503	`/* (ZIb), (ZIc) uninitialised */`
		3504	`SET_TDF((ZId), &(ZIa));`
		3505	`}`
		3506	`switch (CURRENT_TERMINAL) {`
		3507	`case 78:`
		3508	`break;`
		3509	`default:`
		3510	`goto ZL1;`
		3511	`}`
		3512	`ADVANCE_LEXER;`
		3513	`read_exp ();`
		3514	`if ((CURRENT_TERMINAL) == 130) {`
		3515	`RESTORE_LEXER;`
		3516	`goto ZL1;`
		3517	`}`
		3518	`{`
		3519
		3520	`RESET_TDF((ZId));`
		3521	`SET_TDF((ZId), &(ZIb));`
		3522	`}`
		3523	`switch (CURRENT_TERMINAL) {`
		3524	`case 25:`
		3525	`break;`
		3526	`default:`
		3527	`goto ZL1;`
		3528	`}`
		3529	`ADVANCE_LEXER;`
		3530	`read_shape ();`
		3531	`if ((CURRENT_TERMINAL) == 130) {`
		3532	`RESTORE_LEXER;`
		3533	`goto ZL1;`
		3534	`}`
		3535	`{`
		3536
		3537	`RESET_TDF((ZId));`
		3538	`SET_TDF((ZId), &(ZIc));`
		3539	`}`
		3540	`switch (CURRENT_TERMINAL) {`
		3541	`case 25:`
		3542	`break;`
		3543	`default:`
		3544	`goto ZL1;`
		3545	`}`
		3546	`ADVANCE_LEXER;`
		3547	`read_shape ();`
		3548	`if ((CURRENT_TERMINAL) == 130) {`
		3549	`RESTORE_LEXER;`
		3550	`goto ZL1;`
		3551	`}`
		3552	`{`
		3553
		3554	`RESET_TDF((ZId));`
		3555	`o_shape_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		3556	`append_TDF(&(ZIc),1));`
		3557	`}`
		3558	`switch (CURRENT_TERMINAL) {`
		3559	`case 29:`
		3560	`break;`
		3561	`default:`
		3562	`goto ZL1;`
		3563	`}`
		3564	`ADVANCE_LEXER;`
		3565	`}`
		3566	`break;`
		3567	`case 130:`
		3568	`return;`
		3569	`default:`
		3570	`goto ZL1;`
		3571	`}`
		3572	`return;`
		3573	`ZL1:;`
		3574	`SAVE_LEXER (130);`
		3575	`return;`
		3576	`}`
		3577
		3578	`static void`
		3579	`ZR677(TDF ZIa, TDF ZIb, PTR_TDF ZIc, PTR_Tagdec ZId, PTR_char ZIe, int ZIf)`
		3580	`{`
		3581	`switch (CURRENT_TERMINAL) {`
		3582	`case 36:`
		3583	`{`
		3584	`{`
		3585
		3586	`RESET_TDF((*ZIc));`
		3587	`if (!(ZId)->hassh)fail("No declaration shape for %s", (ZIe));`
		3588	`SET_TDF((ZIc), &(ZIa));`
		3589	`}`
		3590	`ADVANCE_LEXER;`
		3591	`read_exp ();`
		3592	`if ((CURRENT_TERMINAL) == 130) {`
		3593	`RESTORE_LEXER;`
		3594	`goto ZL1;`
		3595	`}`
		3596	`{`
		3597
		3598	`RESET_TDF((*ZIc));`
		3599	`o_make_var_tagdef(out_tdfint32(UL(non_local(&(*ZId)->idname.name, tag_ent))),`
		3600	`{},`
		3601	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		3602	`append_TDF(&(*ZIa), 1));`
		3603	`INC_LIST;`
		3604	`(*ZId)->isdeffed = 1;`
		3605	`}`
		3606	`}`
		3607	`break;`
		3608	`case 24:`
		3609	`{`
		3610	`{`
		3611
		3612	`RESET_TDF((*ZIc));`
		3613	`if ((ZId)->hassh)fail("Two declaration shapes for %s", (ZIe));`
		3614	`g_shtokname = &(*ZId)->sh.shtok;`
		3615	`}`
		3616	`ADVANCE_LEXER;`
		3617	`ZRshapetok ();`
		3618	`if ((CURRENT_TERMINAL) == 130) {`
		3619	`RESTORE_LEXER;`
		3620	`goto ZL1;`
		3621	`}`
		3622	`{`
		3623
		3624	`SET_TDF((ZIc), &(ZIa));`
		3625	`}`
		3626	`ZR680 (ZIa, ZIb, ZIc, ZId, ZIf);`
		3627	`if ((CURRENT_TERMINAL) == 130) {`
		3628	`RESTORE_LEXER;`
		3629	`goto ZL1;`
		3630	`}`
		3631	`}`
		3632	`break;`
		3633	`case 130:`
		3634	`return;`
		3635	`default:`
		3636	`goto ZL1;`
		3637	`}`
		3638	`return;`
		3639	`ZL1:;`
		3640	`SAVE_LEXER (130);`
		3641	`return;`
		3642	`}`
		3643
		3644	`static void`
		3645	`ZRrounding__mode__opt(void)`
		3646	`{`
		3647	`switch (CURRENT_TERMINAL) {`
		3648	`case 89: case 90: case 91:`
		3649	`{`
		3650	`read_rounding_mode ();`
		3651	`if ((CURRENT_TERMINAL) == 130) {`
		3652	`RESTORE_LEXER;`
		3653	`goto ZL1;`
		3654	`}`
		3655	`}`
		3656	`break;`
		3657	`default:`
		3658	`{`
		3659	`{`
		3660
		3661	`o_to_nearest;`
		3662	`}`
		3663	`}`
		3664	`break;`
		3665	`case 130:`
		3666	`return;`
		3667	`}`
		3668	`return;`
		3669	`ZL1:;`
		3670	`SAVE_LEXER (130);`
		3671	`return;`
		3672	`}`
		3673
		3674	`static void`
		3675	`ZR678(TDF ZIa, TDF ZIb, PTR_TDF ZIc, PTR_Tagdec ZId, PTR_char ZIe, int ZIf)`
		3676	`{`
		3677	`switch (CURRENT_TERMINAL) {`
		3678	`case 36:`
		3679	`{`
		3680	`{`
		3681
		3682	`RESET_TDF((*ZIc));`
		3683	`if (!(ZId)->hassh)fail("No declaration shape for %s", (ZIe));`
		3684	`SET_TDF((ZIc), &(ZIa));`
		3685	`}`
		3686	`ADVANCE_LEXER;`
		3687	`read_exp ();`
		3688	`if ((CURRENT_TERMINAL) == 130) {`
		3689	`RESTORE_LEXER;`
		3690	`goto ZL1;`
		3691	`}`
		3692	`{`
		3693
		3694	`RESET_TDF((*ZIc));`
		3695	`(*ZId)->iscommon = 1;`
		3696	`o_common_tagdef(out_tdfint32(UL(non_local(&(*ZId)->idname.name, tag_ent))), {},`
		3697	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		3698	`append_TDF(&(*ZIa), 1));`
		3699	`INC_LIST;`
		3700	`(*ZId)->isdeffed = 1;`
		3701	`}`
		3702	`}`
		3703	`break;`
		3704	`case 24:`
		3705	`{`
		3706	`{`
		3707
		3708	`RESET_TDF((*ZIc));`
		3709	`if ((ZId)->hassh)fail("Two declaration shapes for %s", (ZIe));`
		3710	`g_shtokname = &(*ZId)->sh.shtok;`
		3711	`}`
		3712	`ADVANCE_LEXER;`
		3713	`ZRshapetok ();`
		3714	`if ((CURRENT_TERMINAL) == 130) {`
		3715	`RESTORE_LEXER;`
		3716	`goto ZL1;`
		3717	`}`
		3718	`{`
		3719
		3720	`SET_TDF((ZIc), &(ZIa));`
		3721	`}`
		3722	`ZR681 (ZIa, ZIb, ZIc, ZId, ZIf);`
		3723	`if ((CURRENT_TERMINAL) == 130) {`
		3724	`RESTORE_LEXER;`
		3725	`goto ZL1;`
		3726	`}`
		3727	`}`
		3728	`break;`
		3729	`case 130:`
		3730	`return;`
		3731	`default:`
		3732	`goto ZL1;`
		3733	`}`
		3734	`return;`
		3735	`ZL1:;`
		3736	`SAVE_LEXER (130);`
		3737	`return;`
		3738	`}`
		3739
		3740	`static void`
		3741	`ZRnonst__shape(void)`
		3742	`{`
		3743	`if ((CURRENT_TERMINAL) == 130) {`
		3744	`return;`
		3745	`}`
		3746	`{`
		3747	`TDF ZIa;`
		3748	`PTR_TDF ZIb;`
		3749	`int ZIc;`
		3750
		3751	`{`
		3752
		3753	`(ZIc) = (current_TDF->first == current_TDF->last &&`
		3754	`current_TDF->first->usage == 0 &&`
		3755	`current_TDF->first->offst == 0);`
		3756	`if (!(ZIc)) { SET_TDF((ZIb), &(ZIa)); }`
		3757	`}`
		3758	`ZRnonst__shape__body ();`
		3759	`if ((CURRENT_TERMINAL) == 130) {`
		3760	`RESTORE_LEXER;`
		3761	`goto ZL1;`
		3762	`}`
		3763	`{`
		3764
		3765	`if (!(ZIc)) {`
		3766	`SET((ZIb));`
		3767	`RESET_TDF((ZIb));`
		3768	`append_TDF(&(ZIa),1);`
		3769	`}`
		3770	`}`
		3771	`}`
		3772	`return;`
		3773	`ZL1:;`
		3774	`SAVE_LEXER (130);`
		3775	`return;`
		3776	`}`
		3777
		3778	`static void`
		3779	`ZR679(TDF ZIa, TDF ZIb, PTR_TDF ZIc, PTR_Tagdec ZId, PTR_char ZIe, int ZIf)`
		3780	`{`
		3781	`switch (CURRENT_TERMINAL) {`
		3782	`case 36:`
		3783	`{`
		3784	`ADVANCE_LEXER;`
		3785	`{`
		3786
		3787	`RESET_TDF((*ZIc));`
		3788	`if (!(ZId)->hassh)fail("No declaration shape for %s", (ZIe));`
		3789	`SET_TDF((ZIc), &(ZIa));`
		3790	`}`
		3791	`read_exp ();`
		3792	`if ((CURRENT_TERMINAL) == 130) {`
		3793	`RESTORE_LEXER;`
		3794	`goto ZL1;`
		3795	`}`
		3796	`{`
		3797
		3798	`RESET_TDF((*ZIc));`
		3799	`o_make_id_tagdef(out_tdfint32(UL(non_local(&(*ZId)->idname.name, tag_ent))),`
		3800	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		3801	`append_TDF(&(*ZIa), 1));`
		3802	`INC_LIST;`
		3803	`(*ZId)->isdeffed = 1;`
		3804	`}`
		3805	`}`
		3806	`break;`
		3807	`case 24:`
		3808	`{`
		3809	`{`
		3810
		3811	`RESET_TDF((*ZIc));`
		3812	`if ((ZId)->hassh)fail("Two declaration shapes for %s", (ZIe));`
		3813	`g_shtokname = &(*ZId)->sh.shtok;`
		3814	`}`
		3815	`ADVANCE_LEXER;`
		3816	`ZRshapetok ();`
		3817	`if ((CURRENT_TERMINAL) == 130) {`
		3818	`RESTORE_LEXER;`
		3819	`goto ZL1;`
		3820	`}`
		3821	`{`
		3822
		3823	`SET_TDF((ZIc), &(ZIa));`
		3824	`}`
		3825	`switch (CURRENT_TERMINAL) {`
		3826	`case 36:`
		3827	`break;`
		3828	`default:`
		3829	`goto ZL1;`
		3830	`}`
		3831	`ADVANCE_LEXER;`
		3832	`read_exp ();`
		3833	`if ((CURRENT_TERMINAL) == 130) {`
		3834	`RESTORE_LEXER;`
		3835	`goto ZL1;`
		3836	`}`
		3837	`{`
		3838
		3839	`RESET_TDF((*ZIc));`
		3840	`o_make_id_tagdef(out_tdfint32(UL(local_name(&(*ZId)->idname.name, tag_ent))),`
		3841	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), (*ZIf))); },`
		3842	`append_TDF(&(*ZIa), 1));`
		3843	`INC_LIST;`
		3844	`SELECT_UNIT(tagdec_unit);`
		3845	`if (!(*ZIf)) {`
		3846	`o_make_id_tagdec(out_tdfint32(UL(non_local(&(*ZId)->idname.name,tag_ent))),`
		3847	`{},`
		3848	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		3849	`o_shape_apply_token(make_tok(&(*ZId)->sh.shtok), {}));`
		3850	`INC_LIST;`
		3851	`}`
		3852	`(ZId)->isdeffed=1; (ZId)->hassh =1;`
		3853	`if (!(ZIf)) { (ZId)->next = tagdecs; tagdecs = (*ZId); }`
		3854	`}`
		3855	`}`
		3856	`break;`
		3857	`case 130:`
		3858	`return;`
		3859	`default:`
		3860	`goto ZL1;`
		3861	`}`
		3862	`return;`
		3863	`ZL1:;`
		3864	`SAVE_LEXER (130);`
		3865	`return;`
		3866	`}`
		3867
		3868	`static void`
		3869	`ZRaccess__opt(void)`
		3870	`{`
		3871	`switch (CURRENT_TERMINAL) {`
		3872	`case 79:`
		3873	`{`
		3874	`ADVANCE_LEXER;`
		3875	`ZRaccess__list ();`
		3876	`switch (CURRENT_TERMINAL) {`
		3877	`case 30:`
		3878	`break;`
		3879	`case 130:`
		3880	`RESTORE_LEXER;`
		3881	`goto ZL1;`
		3882	`default:`
		3883	`goto ZL1;`
		3884	`}`
		3885	`ADVANCE_LEXER;`
		3886	`}`
		3887	`break;`
		3888	`case 130:`
		3889	`return;`
		3890	`default:`
		3891	`break;`
		3892	`}`
		3893	`return;`
		3894	`ZL1:;`
		3895	`SAVE_LEXER (130);`
		3896	`return;`
		3897	`}`
		3898
		3899	`void`
		3900	`read_error_code(void)`
		3901	`{`
		3902	`if ((CURRENT_TERMINAL) == 130) {`
		3903	`return;`
		3904	`}`
		3905	`{`
		3906	`int ZIa;`
		3907
		3908	`{`
		3909
		3910	`(ZIa) = lex_v.val.v;`
		3911	`}`
		3912	`switch (CURRENT_TERMINAL) {`
		3913	`case 37:`
		3914	`break;`
		3915	`default:`
		3916	`goto ZL1;`
		3917	`}`
		3918	`ADVANCE_LEXER;`
		3919	`{`
		3920
		3921	`(constructs[(ZIa)].f)();`
		3922	`}`
		3923	`}`
		3924	`return;`
		3925	`ZL1:;`
		3926	`{`
		3927	`{`
		3928
		3929	`fail("Syntax error");`
		3930	`}`
		3931	`}`
		3932	`}`
		3933
		3934	`static void`
		3935	`ZRpostlude__opt(void)`
		3936	`{`
		3937	`switch (CURRENT_TERMINAL) {`
		3938	`case 93:`
		3939	`{`
		3940	`ADVANCE_LEXER;`
		3941	`read_exp ();`
		3942	`if ((CURRENT_TERMINAL) == 130) {`
		3943	`RESTORE_LEXER;`
		3944	`goto ZL1;`
		3945	`}`
		3946	`}`
		3947	`break;`
		3948	`default:`
		3949	`{`
		3950	`{`
		3951
		3952	`o_make_top;`
		3953	`}`
		3954	`}`
		3955	`break;`
		3956	`case 130:`
		3957	`return;`
		3958	`}`
		3959	`return;`
		3960	`ZL1:;`
		3961	`SAVE_LEXER (130);`
		3962	`return;`
		3963	`}`
		3964
		3965	`static void`
		3966	`ZR680(TDF ZIa, TDF ZIb, PTR_TDF ZIc, PTR_Tagdec ZId, int *ZIf)`
		3967	`{`
		3968	`switch (CURRENT_TERMINAL) {`
		3969	`case 36:`
		3970	`{`
		3971	`ADVANCE_LEXER;`
		3972	`read_exp ();`
		3973	`if ((CURRENT_TERMINAL) == 130) {`
		3974	`RESTORE_LEXER;`
		3975	`goto ZL1;`
		3976	`}`
		3977	`{`
		3978
		3979	`RESET_TDF((*ZIc));`
		3980	`o_make_var_tagdef(out_tdfint32(UL(local_name(&(*ZId)->idname.name, tag_ent))),`
		3981	`{},`
		3982	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), (*ZIf))); },`
		3983	`append_TDF(&(*ZIa), 1));`
		3984	`INC_LIST;`
		3985	`SELECT_UNIT(tagdec_unit);`
		3986	`if (!(*ZIf)) {`
		3987	`o_make_var_tagdec(out_tdfint32(UL(non_local(&(*ZId)->idname.name,tag_ent))),`
		3988	`{},`
		3989	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		3990	`o_shape_apply_token(make_tok(&(*ZId)->sh.shtok), {}));`
		3991	`INC_LIST;`
		3992	`}`
		3993	`(ZId)->isdeffed=1; (ZId)->hassh =1;`
		3994	`if (!(ZIf)) { (ZId)->next = tagdecs; tagdecs = (*ZId); }`
		3995	`}`
		3996	`}`
		3997	`break;`
		3998	`default:`
		3999	`{`
		4000	`{`
		4001
		4002	`o_make_value(o_shape_apply_token(make_tok(&(*ZId)->sh.shtok), {}));`
		4003	`}`
		4004	`{`
		4005
		4006	`RESET_TDF((*ZIc));`
		4007	`o_make_var_tagdef(out_tdfint32(UL(local_name(&(*ZId)->idname.name, tag_ent))),`
		4008	`{},`
		4009	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), (*ZIf))); },`
		4010	`append_TDF(&(*ZIa), 1));`
		4011	`INC_LIST;`
		4012	`SELECT_UNIT(tagdec_unit);`
		4013	`if (!(*ZIf)) {`
		4014	`o_make_var_tagdec(out_tdfint32(UL(non_local(&(*ZId)->idname.name,tag_ent))),`
		4015	`{},`
		4016	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		4017	`o_shape_apply_token(make_tok(&(*ZId)->sh.shtok), {}));`
		4018	`INC_LIST;`
		4019	`}`
		4020	`(ZId)->isdeffed=1; (ZId)->hassh =1;`
		4021	`if (!(ZIf)) { (ZId)->next = tagdecs; tagdecs = (*ZId); }`
		4022	`}`
		4023	`}`
		4024	`break;`
		4025	`case 130:`
		4026	`return;`
		4027	`}`
		4028	`return;`
		4029	`ZL1:;`
		4030	`SAVE_LEXER (130);`
		4031	`return;`
		4032	`}`
		4033
		4034	`static void`
		4035	`ZRexponent__opt(void)`
		4036	`{`
		4037	`switch (CURRENT_TERMINAL) {`
		4038	`case 34:`
		4039	`{`
		4040	`ADVANCE_LEXER;`
		4041	`ZRsigned__nat__body ();`
		4042	`if ((CURRENT_TERMINAL) == 130) {`
		4043	`RESTORE_LEXER;`
		4044	`goto ZL1;`
		4045	`}`
		4046	`}`
		4047	`break;`
		4048	`default:`
		4049	`{`
		4050	`{`
		4051
		4052	`o_make_signed_nat(out_tdfbool(0), out_tdfint32(UL(0)));`
		4053	`}`
		4054	`}`
		4055	`break;`
		4056	`case 130:`
		4057	`return;`
		4058	`}`
		4059	`return;`
		4060	`ZL1:;`
		4061	`SAVE_LEXER (130);`
		4062	`return;`
		4063	`}`
		4064
		4065	`static void`
		4066	`ZR681(TDF ZIa, TDF ZIb, PTR_TDF ZIc, PTR_Tagdec ZId, int *ZIf)`
		4067	`{`
		4068	`switch (CURRENT_TERMINAL) {`
		4069	`case 36:`
		4070	`{`
		4071	`ADVANCE_LEXER;`
		4072	`read_exp ();`
		4073	`if ((CURRENT_TERMINAL) == 130) {`
		4074	`RESTORE_LEXER;`
		4075	`goto ZL1;`
		4076	`}`
		4077	`{`
		4078
		4079	`RESET_TDF((*ZIc));`
		4080	`(*ZId)->iscommon = 1;`
		4081	`o_common_tagdef(out_tdfint32(UL(local_name(&(*ZId)->idname.name, tag_ent))), {},`
		4082	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), (*ZIf))); },`
		4083	`append_TDF(&(*ZIa), 1));`
		4084	`INC_LIST;`
		4085	`SELECT_UNIT(tagdec_unit);`
		4086	`if (!(*ZIf)) {`
		4087	`o_common_tagdec(out_tdfint32(UL(non_local(&(*ZId)->idname.name,tag_ent))),`
		4088	`{},`
		4089	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		4090	`o_shape_apply_token(make_tok(&(*ZId)->sh.shtok), {}));`
		4091	`INC_LIST;`
		4092	`}`
		4093	`(ZId)->isdeffed=1; (ZId)->hassh =1;`
		4094	`if (!(ZIf)) { (ZId)->next = tagdecs; tagdecs = (*ZId); }`
		4095	`}`
		4096	`}`
		4097	`break;`
		4098	`default:`
		4099	`{`
		4100	`{`
		4101
		4102	`o_make_value(o_shape_apply_token(make_tok(&(*ZId)->sh.shtok), {}));`
		4103	`}`
		4104	`{`
		4105
		4106	`RESET_TDF((*ZIc));`
		4107	`(*ZId)->iscommon = 1;`
		4108	`o_common_tagdef(out_tdfint32(UL(local_name(&(*ZId)->idname.name, tag_ent))), {},`
		4109	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), (*ZIf))); },`
		4110	`append_TDF(&(*ZIa), 1));`
		4111	`INC_LIST;`
		4112	`SELECT_UNIT(tagdec_unit);`
		4113	`if (!(*ZIf)) {`
		4114	`o_common_tagdec(out_tdfint32(UL(non_local(&(*ZId)->idname.name,tag_ent))),`
		4115	`{},`
		4116	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		4117	`o_shape_apply_token(make_tok(&(*ZId)->sh.shtok), {}));`
		4118	`INC_LIST;`
		4119	`}`
		4120	`(ZId)->isdeffed=1; (ZId)->hassh =1;`
		4121	`if (!(ZIf)) { (ZId)->next = tagdecs; tagdecs = (*ZId); }`
		4122	`}`
		4123	`}`
		4124	`break;`
		4125	`case 130:`
		4126	`return;`
		4127	`}`
		4128	`return;`
		4129	`ZL1:;`
		4130	`SAVE_LEXER (130);`
		4131	`return;`
		4132	`}`
		4133
		4134	`static void`
		4135	`ZRclosed__exp(void)`
		4136	`{`
		4137	`switch (CURRENT_TERMINAL) {`
		4138	`case 58:`
		4139	`{`
		4140	`TDF ZIa;`
		4141	`TDF ZIb;`
		4142	`TDF ZIc;`
		4143	`PTR_TDF ZId;`
		4144	`PTR_Labdec ZIe;`
		4145
		4146	`ADVANCE_LEXER;`
		4147	`{`
		4148
		4149	`/* (ZIb) uninitialised */`
		4150	`(ZIe) = labdecs;`
		4151	`(ZIc) = g_lablist;`
		4152	`INIT_TDF(&g_lablist);`
		4153	`SET_TDF((ZId), &(ZIa));`
		4154	`}`
		4155	`switch (CURRENT_TERMINAL) {`
		4156	`case 76:`
		4157	`break;`
		4158	`default:`
		4159	`goto ZL1;`
		4160	`}`
		4161	`ADVANCE_LEXER;`
		4162	`ZRexp__sequence ();`
		4163	`if ((CURRENT_TERMINAL) == 130) {`
		4164	`RESTORE_LEXER;`
		4165	`goto ZL1;`
		4166	`}`
		4167	`{`
		4168
		4169	`RESET_TDF((ZId));`
		4170	`SET_TDF((ZId), &(ZIb));`
		4171	`}`
		4172	`switch (CURRENT_TERMINAL) {`
		4173	`case 11:`
		4174	`break;`
		4175	`default:`
		4176	`goto ZL1;`
		4177	`}`
		4178	`ADVANCE_LEXER;`
		4179	`ZRlabelled__list ();`
		4180	`switch (CURRENT_TERMINAL) {`
		4181	`case 20:`
		4182	`break;`
		4183	`case 130:`
		4184	`RESTORE_LEXER;`
		4185	`goto ZL1;`
		4186	`default:`
		4187	`goto ZL1;`
		4188	`}`
		4189	`ADVANCE_LEXER;`
		4190	`{`
		4191
		4192	`RESET_TDF((ZId));`
		4193	`o_labelled({ append_TDF(&g_lablist,1);`
		4194	`current_TDF->no = g_lablist.no;},`
		4195	`append_TDF(&(ZIa), 1),`
		4196	`{ append_TDF(&(ZIb),1);`
		4197	`current_TDF->no = g_lablist.no;});`
		4198	`tidy_labels((ZIe));`
		4199	`g_lablist = (ZIc);`
		4200	`}`
		4201	`}`
		4202	`break;`
		4203	`case 76:`
		4204	`{`
		4205	`ADVANCE_LEXER;`
		4206	`ZRexp__sequence ();`
		4207	`switch (CURRENT_TERMINAL) {`
		4208	`case 20:`
		4209	`break;`
		4210	`case 130:`
		4211	`RESTORE_LEXER;`
		4212	`goto ZL1;`
		4213	`default:`
		4214	`goto ZL1;`
		4215	`}`
		4216	`ADVANCE_LEXER;`
		4217	`}`
		4218	`break;`
		4219	`case 86:`
		4220	`{`
		4221	`TDF ZIa;`
		4222	`TDF ZIb;`
		4223	`TDF ZIc;`
		4224	`PTR_TDF ZId;`
		4225	`int ZIe;`
		4226	`PTR_Labdec ZIf;`
		4227
		4228	`ADVANCE_LEXER;`
		4229	`{`
		4230
		4231	`/* (ZIb), (ZIc) uninitialised */`
		4232	`(ZIe) = defaultlab;`
		4233	`(ZIf) = labdecs;`
		4234	`defaultlab = -1;`
		4235	`SET_TDF((ZId), &(ZIa));`
		4236	`}`
		4237	`switch (CURRENT_TERMINAL) {`
		4238	`case 76:`
		4239	`break;`
		4240	`default:`
		4241	`goto ZL1;`
		4242	`}`
		4243	`ADVANCE_LEXER;`
		4244	`ZRexp__sequence ();`
		4245	`if ((CURRENT_TERMINAL) == 130) {`
		4246	`RESTORE_LEXER;`
		4247	`goto ZL1;`
		4248	`}`
		4249	`{`
		4250
		4251	`RESET_TDF((ZId));`
		4252	`SET_TDF((ZId), &(ZIb));`
		4253	`}`
		4254	`switch (CURRENT_TERMINAL) {`
		4255	`case 11:`
		4256	`break;`
		4257	`default:`
		4258	`goto ZL1;`
		4259	`}`
		4260	`ADVANCE_LEXER;`
		4261	`ZRlabset__opt ();`
		4262	`if ((CURRENT_TERMINAL) == 130) {`
		4263	`RESTORE_LEXER;`
		4264	`goto ZL1;`
		4265	`}`
		4266	`{`
		4267
		4268	`(ZIc) = optlab;`
		4269	`defaultlab = (ZIe);`
		4270	`tidy_labels((ZIf));`
		4271	`}`
		4272	`ZRexp__sequence ();`
		4273	`if ((CURRENT_TERMINAL) == 130) {`
		4274	`RESTORE_LEXER;`
		4275	`goto ZL1;`
		4276	`}`
		4277	`{`
		4278
		4279	`INIT_TDF((ZId));`
		4280	`RESET_TDF((ZId));`
		4281	`o_conditional(append_TDF(&(ZIc),1),`
		4282	`append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		4283	`}`
		4284	`switch (CURRENT_TERMINAL) {`
		4285	`case 20:`
		4286	`break;`
		4287	`default:`
		4288	`goto ZL1;`
		4289	`}`
		4290	`ADVANCE_LEXER;`
		4291	`}`
		4292	`break;`
		4293	`case 88:`
		4294	`{`
		4295	`TDF ZIa;`
		4296	`TDF ZIb;`
		4297	`TDF ZIc;`
		4298	`PTR_TDF ZId;`
		4299	`PTR_Labdec ZIe;`
		4300	`int ZIf;`
		4301
		4302	`ADVANCE_LEXER;`
		4303	`{`
		4304
		4305	`/* (ZIb), (ZIc), (ZIf) uninitialised */`
		4306	`(ZIe) = labdecs;`
		4307	`SET_TDF((ZId), &(ZIa));`
		4308	`}`
		4309	`ZRrepeat__starter__opt ();`
		4310	`if ((CURRENT_TERMINAL) == 130) {`
		4311	`RESTORE_LEXER;`
		4312	`goto ZL1;`
		4313	`}`
		4314	`{`
		4315
		4316	`(ZIf) = defaultlab;`
		4317	`defaultlab = -1;`
		4318	`}`
		4319	`switch (CURRENT_TERMINAL) {`
		4320	`case 76:`
		4321	`break;`
		4322	`default:`
		4323	`goto ZL1;`
		4324	`}`
		4325	`ADVANCE_LEXER;`
		4326	`ZRlabset__opt ();`
		4327	`if ((CURRENT_TERMINAL) == 130) {`
		4328	`RESTORE_LEXER;`
		4329	`goto ZL1;`
		4330	`}`
		4331	`{`
		4332
		4333	`(ZIc) = optlab;`
		4334	`RESET_TDF((ZId));`
		4335	`SET_TDF((ZId), &(ZIb));`
		4336	`}`
		4337	`ZRexp__sequence ();`
		4338	`if ((CURRENT_TERMINAL) == 130) {`
		4339	`RESTORE_LEXER;`
		4340	`goto ZL1;`
		4341	`}`
		4342	`{`
		4343
		4344	`RESET_TDF((ZId));`
		4345	`o_repeat(append_TDF(&(ZIc),1), append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		4346	`tidy_labels((ZIe));`
		4347	`defaultlab = (ZIf);`
		4348	`}`
		4349	`switch (CURRENT_TERMINAL) {`
		4350	`case 20:`
		4351	`break;`
		4352	`default:`
		4353	`goto ZL1;`
		4354	`}`
		4355	`ADVANCE_LEXER;`
		4356	`}`
		4357	`break;`
		4358	`case 61: case 124:`
		4359	`{`
		4360	`PTR_Tagdec ZIa;`
		4361	`TDF ZIb;`
		4362	`TDF ZIc;`
		4363	`TDF ZId;`
		4364	`PTR_TDF ZIe;`
		4365	`Name ZIf;`
		4366	`int ZIg;`
		4367
		4368	`{`
		4369
		4370	`(ZIa) = localdecs;`
		4371	`}`
		4372	`ZRtag__intro ();`
		4373	`if ((CURRENT_TERMINAL) == 130) {`
		4374	`RESTORE_LEXER;`
		4375	`goto ZL1;`
		4376	`}`
		4377	`{`
		4378
		4379	`(ZIg) = localdecs->isvar;`
		4380	`(ZIb) = intro_acc;`
		4381	`(ZIc) = intro_init;`
		4382	`(ZIf) = localdecs->idname.name;`
		4383	`SET_TDF((ZIe), &(ZId));`
		4384	`}`
		4385	`ZRclosed__exp ();`
		4386	`if ((CURRENT_TERMINAL) == 130) {`
		4387	`RESTORE_LEXER;`
		4388	`goto ZL1;`
		4389	`}`
		4390	`{`
		4391
		4392	`RESET_TDF((ZIe));`
		4393	`if ((ZIg)) {`
		4394	`o_variable(if ((ZIb).no!=0) { OPTION(append_TDF(&(ZIb),1)); },`
		4395	`make_tag(&(ZIf)), append_TDF(&(ZIc),1),`
		4396	`append_TDF(&(ZId),1));`
		4397	`} else {`
		4398	`o_identify(if ((ZIb).no!=0) { OPTION(append_TDF(&(ZIb),1)); },`
		4399	`make_tag(&(ZIf)), append_TDF(&(ZIc),1),`
		4400	`append_TDF(&(ZId),1));`
		4401	`}`
		4402	`}`
		4403	`{`
		4404
		4405	`localdecs = (ZIa);`
		4406	`}`
		4407	`}`
		4408	`break;`
		4409	`case 130:`
		4410	`return;`
		4411	`default:`
		4412	`goto ZL1;`
		4413	`}`
		4414	`return;`
		4415	`ZL1:;`
		4416	`SAVE_LEXER (130);`
		4417	`return;`
		4418	`}`
		4419
		4420	`void`
		4421	`read_bool(void)`
		4422	`{`
		4423	`ZL2_bool:;`
		4424	`switch (CURRENT_TERMINAL) {`
		4425	`case 17:`
		4426	`{`
		4427	`ADVANCE_LEXER;`
		4428	`{`
		4429	`switch (CURRENT_TERMINAL) {`
		4430	`case 24:`
		4431	`{`
		4432	`ADVANCE_LEXER;`
		4433	`goto ZL2_bool;`
		4434	`}`
		4435	`/UNREACHED/`
		4436	`case 86:`
		4437	`{`
		4438	`TDF ZIa;`
		4439	`TDF ZIb;`
		4440	`TDF ZIc;`
		4441	`PTR_TDF ZId;`
		4442
		4443	`{`
		4444
		4445	`/* (ZIb), (ZIc) uninitialised */`
		4446	`SET_TDF((ZId), &(ZIa));`
		4447	`}`
		4448	`ADVANCE_LEXER;`
		4449	`switch (CURRENT_TERMINAL) {`
		4450	`case 78:`
		4451	`break;`
		4452	`default:`
		4453	`goto ZL1;`
		4454	`}`
		4455	`ADVANCE_LEXER;`
		4456	`read_exp ();`
		4457	`switch (CURRENT_TERMINAL) {`
		4458	`case 25:`
		4459	`break;`
		4460	`case 130:`
		4461	`RESTORE_LEXER;`
		4462	`goto ZL1;`
		4463	`default:`
		4464	`goto ZL1;`
		4465	`}`
		4466	`ADVANCE_LEXER;`
		4467	`{`
		4468
		4469	`RESET_TDF((ZId));`
		4470	`SET_TDF((ZId), &(ZIb));`
		4471	`}`
		4472	`read_bool ();`
		4473	`switch (CURRENT_TERMINAL) {`
		4474	`case 25:`
		4475	`break;`
		4476	`case 130:`
		4477	`RESTORE_LEXER;`
		4478	`goto ZL1;`
		4479	`default:`
		4480	`goto ZL1;`
		4481	`}`
		4482	`ADVANCE_LEXER;`
		4483	`{`
		4484
		4485	`RESET_TDF((ZId));`
		4486	`SET_TDF((ZId), &(ZIc));`
		4487	`}`
		4488	`read_bool ();`
		4489	`if ((CURRENT_TERMINAL) == 130) {`
		4490	`RESTORE_LEXER;`
		4491	`goto ZL1;`
		4492	`}`
		4493	`{`
		4494
		4495	`RESET_TDF((ZId));`
		4496	`o_bool_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		4497	`append_TDF(&(ZIc),1));`
		4498	`}`
		4499	`switch (CURRENT_TERMINAL) {`
		4500	`case 29:`
		4501	`break;`
		4502	`default:`
		4503	`goto ZL1;`
		4504	`}`
		4505	`ADVANCE_LEXER;`
		4506	`}`
		4507	`break;`
		4508	`default:`
		4509	`goto ZL1;`
		4510	`}`
		4511	`}`
		4512	`}`
		4513	`break;`
		4514	`case 16:`
		4515	`{`
		4516	`int ZIa;`
		4517
		4518	`{`
		4519
		4520	`(ZIa) = lex_v.val.v;`
		4521	`}`
		4522	`ADVANCE_LEXER;`
		4523	`{`
		4524
		4525	`(constructs[(ZIa)].f)();`
		4526	`}`
		4527	`}`
		4528	`break;`
		4529	`case 18:`
		4530	`{`
		4531	`PTR_Tokdec ZIa;`
		4532
		4533	`{`
		4534
		4535	`(ZIa) = lex_v.val.tokname;`
		4536	`(ZIa)->isused = 1;`
		4537	`}`
		4538	`ADVANCE_LEXER;`
		4539	`{`
		4540
		4541	`expand_tok((ZIa), &(ZIa)->sort);`
		4542	`}`
		4543	`}`
		4544	`break;`
		4545	`case 130:`
		4546	`return;`
		4547	`default:`
		4548	`goto ZL1;`
		4549	`}`
		4550	`return;`
		4551	`ZL1:;`
		4552	`{`
		4553	`{`
		4554
		4555	`fail("Syntax error");`
		4556	`}`
		4557	`}`
		4558	`}`
		4559
		4560	`static void`
		4561	`ZRvarintro__opt(void)`
		4562	`{`
		4563	`switch (CURRENT_TERMINAL) {`
		4564	`case 129:`
		4565	`{`
		4566	`ADVANCE_LEXER;`
		4567	`read_tag ();`
		4568	`switch (CURRENT_TERMINAL) {`
		4569	`case 24:`
		4570	`break;`
		4571	`case 130:`
		4572	`RESTORE_LEXER;`
		4573	`goto ZL1;`
		4574	`default:`
		4575	`goto ZL1;`
		4576	`}`
		4577	`ADVANCE_LEXER;`
		4578	`read_alignment ();`
		4579	`if ((CURRENT_TERMINAL) == 130) {`
		4580	`RESTORE_LEXER;`
		4581	`goto ZL1;`
		4582	`}`
		4583	`}`
		4584	`break;`
		4585	`case 130:`
		4586	`return;`
		4587	`default:`
		4588	`break;`
		4589	`}`
		4590	`return;`
		4591	`ZL1:;`
		4592	`SAVE_LEXER (130);`
		4593	`return;`
		4594	`}`
		4595
		4596	`void`
		4597	`read_ntest(void)`
		4598	`{`
		4599	`ZL2_ntest:;`
		4600	`switch (CURRENT_TERMINAL) {`
		4601	`case 74:`
		4602	`{`
		4603	`ADVANCE_LEXER;`
		4604	`{`
		4605	`switch (CURRENT_TERMINAL) {`
		4606	`case 24:`
		4607	`{`
		4608	`ADVANCE_LEXER;`
		4609	`goto ZL2_ntest;`
		4610	`}`
		4611	`/UNREACHED/`
		4612	`case 86:`
		4613	`{`
		4614	`TDF ZIa;`
		4615	`TDF ZIb;`
		4616	`TDF ZIc;`
		4617	`PTR_TDF ZId;`
		4618
		4619	`ADVANCE_LEXER;`
		4620	`{`
		4621
		4622	`/* (ZIb), (ZIc) uninitialised */`
		4623	`SET_TDF((ZId), &(ZIa));`
		4624	`}`
		4625	`switch (CURRENT_TERMINAL) {`
		4626	`case 78:`
		4627	`break;`
		4628	`default:`
		4629	`goto ZL1;`
		4630	`}`
		4631	`ADVANCE_LEXER;`
		4632	`read_exp ();`
		4633	`if ((CURRENT_TERMINAL) == 130) {`
		4634	`RESTORE_LEXER;`
		4635	`goto ZL1;`
		4636	`}`
		4637	`{`
		4638
		4639	`RESET_TDF((ZId));`
		4640	`SET_TDF((ZId), &(ZIb));`
		4641	`}`
		4642	`switch (CURRENT_TERMINAL) {`
		4643	`case 25:`
		4644	`break;`
		4645	`default:`
		4646	`goto ZL1;`
		4647	`}`
		4648	`ADVANCE_LEXER;`
		4649	`read_ntest ();`
		4650	`if ((CURRENT_TERMINAL) == 130) {`
		4651	`RESTORE_LEXER;`
		4652	`goto ZL1;`
		4653	`}`
		4654	`{`
		4655
		4656	`RESET_TDF((ZId));`
		4657	`SET_TDF((ZId), &(ZIc));`
		4658	`}`
		4659	`switch (CURRENT_TERMINAL) {`
		4660	`case 25:`
		4661	`break;`
		4662	`default:`
		4663	`goto ZL1;`
		4664	`}`
		4665	`ADVANCE_LEXER;`
		4666	`read_ntest ();`
		4667	`if ((CURRENT_TERMINAL) == 130) {`
		4668	`RESTORE_LEXER;`
		4669	`goto ZL1;`
		4670	`}`
		4671	`{`
		4672
		4673	`RESET_TDF((ZId));`
		4674	`o_ntest_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		4675	`append_TDF(&(ZIc),1));`
		4676	`}`
		4677	`switch (CURRENT_TERMINAL) {`
		4678	`case 29:`
		4679	`break;`
		4680	`default:`
		4681	`goto ZL1;`
		4682	`}`
		4683	`ADVANCE_LEXER;`
		4684	`}`
		4685	`break;`
		4686	`default:`
		4687	`goto ZL1;`
		4688	`}`
		4689	`}`
		4690	`}`
		4691	`break;`
		4692	`case 75:`
		4693	`{`
		4694	`PTR_Tokdec ZIa;`
		4695
		4696	`{`
		4697
		4698	`(ZIa) = lex_v.val.tokname;`
		4699	`(ZIa)->isused = 1;`
		4700	`}`
		4701	`ADVANCE_LEXER;`
		4702	`{`
		4703
		4704	`expand_tok((ZIa), &(ZIa)->sort);`
		4705	`}`
		4706	`}`
		4707	`break;`
		4708	`case 87:`
		4709	`{`
		4710	`{`
		4711
		4712	`char * n = lex_v.val.name;`
		4713	`if (strcmp(n,"!<") ==0) { o_not_less_than; }`
		4714	`else if (strcmp(n,"!<=") ==0) { o_not_less_than_or_equal; }`
		4715	`else if (strcmp(n,"!=") ==0) { o_not_equal; }`
		4716	`else if (strcmp(n,"!>") ==0) { o_not_greater_than; }`
		4717	`else if (strcmp(n,"!>=") ==0) { o_not_greater_than_or_equal; }`
		4718	`else if (strcmp(n,"!Comparable") ==0) { o_not_comparable; }`
		4719	`else if (strcmp(n,"<") ==0) { o_less_than; }`
		4720	`else if (strcmp(n,"<=") ==0) { o_less_than_or_equal; }`
		4721	`else if (strcmp(n,"==") ==0) { o_equal; }`
		4722	`else if (strcmp(n,">") ==0) { o_greater_than; }`
		4723	`else if (strcmp(n,">=") ==0) { o_greater_than_or_equal; }`
		4724	`else if (strcmp(n,"Comparable") ==0) { o_comparable; }`
		4725	`else { fail("%s is not a comparison", n); }`
		4726	`}`
		4727	`ADVANCE_LEXER;`
		4728	`}`
		4729	`break;`
		4730	`case 130:`
		4731	`return;`
		4732	`default:`
		4733	`goto ZL1;`
		4734	`}`
		4735	`return;`
		4736	`ZL1:;`
		4737	`{`
		4738	`{`
		4739
		4740	`fail("Syntax error");`
		4741	`}`
		4742	`}`
		4743	`}`
		4744
		4745	`void`
		4746	`read_bitfield_variety(void)`
		4747	`{`
		4748	`ZL2_bitfield__variety:;`
		4749	`switch (CURRENT_TERMINAL) {`
		4750	`case 14:`
		4751	`{`
		4752	`ADVANCE_LEXER;`
		4753	`{`
		4754	`switch (CURRENT_TERMINAL) {`
		4755	`case 24:`
		4756	`{`
		4757	`ADVANCE_LEXER;`
		4758	`goto ZL2_bitfield__variety;`
		4759	`}`
		4760	`/UNREACHED/`
		4761	`case 86:`
		4762	`{`
		4763	`TDF ZIa;`
		4764	`TDF ZIb;`
		4765	`TDF ZIc;`
		4766	`PTR_TDF ZId;`
		4767
		4768	`{`
		4769
		4770	`/* (ZIb), (ZIc) uninitialised */`
		4771	`SET_TDF((ZId), &(ZIa));`
		4772	`}`
		4773	`ADVANCE_LEXER;`
		4774	`switch (CURRENT_TERMINAL) {`
		4775	`case 78:`
		4776	`break;`
		4777	`default:`
		4778	`goto ZL1;`
		4779	`}`
		4780	`ADVANCE_LEXER;`
		4781	`read_exp ();`
		4782	`switch (CURRENT_TERMINAL) {`
		4783	`case 25:`
		4784	`break;`
		4785	`case 130:`
		4786	`RESTORE_LEXER;`
		4787	`goto ZL1;`
		4788	`default:`
		4789	`goto ZL1;`
		4790	`}`
		4791	`ADVANCE_LEXER;`
		4792	`{`
		4793
		4794	`RESET_TDF((ZId));`
		4795	`SET_TDF((ZId), &(ZIb));`
		4796	`}`
		4797	`read_bitfield_variety ();`
		4798	`switch (CURRENT_TERMINAL) {`
		4799	`case 25:`
		4800	`break;`
		4801	`case 130:`
		4802	`RESTORE_LEXER;`
		4803	`goto ZL1;`
		4804	`default:`
		4805	`goto ZL1;`
		4806	`}`
		4807	`ADVANCE_LEXER;`
		4808	`{`
		4809
		4810	`RESET_TDF((ZId));`
		4811	`SET_TDF((ZId), &(ZIc));`
		4812	`}`
		4813	`read_bitfield_variety ();`
		4814	`if ((CURRENT_TERMINAL) == 130) {`
		4815	`RESTORE_LEXER;`
		4816	`goto ZL1;`
		4817	`}`
		4818	`{`
		4819
		4820	`RESET_TDF((ZId));`
		4821	`o_bfvar_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		4822	`append_TDF(&(ZIc),1));`
		4823	`}`
		4824	`switch (CURRENT_TERMINAL) {`
		4825	`case 29:`
		4826	`break;`
		4827	`default:`
		4828	`goto ZL1;`
		4829	`}`
		4830	`ADVANCE_LEXER;`
		4831	`}`
		4832	`break;`
		4833	`default:`
		4834	`goto ZL1;`
		4835	`}`
		4836	`}`
		4837	`}`
		4838	`break;`
		4839	`case 16: case 17: case 18: case 22: case 55:`
		4840	`case 69: case 70: case 71: case 101: case 121:`
		4841	`{`
		4842	`TDF ZIa;`
		4843	`TDF ZIb;`
		4844	`PTR_TDF ZIc;`
		4845
		4846	`{`
		4847
		4848	`/* (ZIb) uninitialised */`
		4849	`SET_TDF((ZIc), &(ZIa));`
		4850	`}`
		4851	`ZRbitfield__sign ();`
		4852	`if ((CURRENT_TERMINAL) == 130) {`
		4853	`RESTORE_LEXER;`
		4854	`goto ZL1;`
		4855	`}`
		4856	`{`
		4857
		4858	`RESET_TDF((ZIc));`
		4859	`SET_TDF((ZIc), &(ZIb));`
		4860	`}`
		4861	`read_nat ();`
		4862	`if ((CURRENT_TERMINAL) == 130) {`
		4863	`RESTORE_LEXER;`
		4864	`goto ZL1;`
		4865	`}`
		4866	`{`
		4867
		4868	`RESET_TDF((ZIc));`
		4869	`o_bfvar_bits(append_TDF(&(ZIa),1), append_TDF(&(ZIb), 1));`
		4870	`}`
		4871	`}`
		4872	`break;`
		4873	`case 13:`
		4874	`{`
		4875	`int ZIa;`
		4876
		4877	`{`
		4878
		4879	`(ZIa) = lex_v.val.v;`
		4880	`}`
		4881	`ADVANCE_LEXER;`
		4882	`{`
		4883
		4884	`(constructs[(ZIa)].f)();`
		4885	`}`
		4886	`}`
		4887	`break;`
		4888	`case 15:`
		4889	`{`
		4890	`PTR_Tokdec ZIa;`
		4891
		4892	`{`
		4893
		4894	`(ZIa) = lex_v.val.tokname;`
		4895	`(ZIa)->isused = 1;`
		4896	`}`
		4897	`ADVANCE_LEXER;`
		4898	`{`
		4899
		4900	`expand_tok((ZIa), &(ZIa)->sort);`
		4901	`}`
		4902	`}`
		4903	`break;`
		4904	`case 130:`
		4905	`return;`
		4906	`default:`
		4907	`goto ZL1;`
		4908	`}`
		4909	`return;`
		4910	`ZL1:;`
		4911	`{`
		4912	`{`
		4913
		4914	`fail("Syntax error");`
		4915	`}`
		4916	`}`
		4917	`}`
		4918
		4919	`static void`
		4920	`ZRsigned__nat__body(void)`
		4921	`{`
		4922	`ZL2_signed__nat__body:;`
		4923	`switch (CURRENT_TERMINAL) {`
		4924	`case 68:`
		4925	`{`
		4926	`ADVANCE_LEXER;`
		4927	`ZR634 ();`
		4928	`if ((CURRENT_TERMINAL) == 130) {`
		4929	`RESTORE_LEXER;`
		4930	`goto ZL1;`
		4931	`}`
		4932	`}`
		4933	`break;`
		4934	`case 99:`
		4935	`{`
		4936	`ADVANCE_LEXER;`
		4937	`{`
		4938	`switch (CURRENT_TERMINAL) {`
		4939	`case 24:`
		4940	`{`
		4941	`ADVANCE_LEXER;`
		4942	`goto ZL2_signed__nat__body;`
		4943	`}`
		4944	`/UNREACHED/`
		4945	`case 86:`
		4946	`{`
		4947	`TDF ZIa;`
		4948	`TDF ZIb;`
		4949	`TDF ZIc;`
		4950	`PTR_TDF ZId;`
		4951
		4952	`ADVANCE_LEXER;`
		4953	`{`
		4954
		4955	`/* (ZIb), (ZIc) uninitialised */`
		4956	`SET_TDF((ZId), &(ZIa));`
		4957	`}`
		4958	`switch (CURRENT_TERMINAL) {`
		4959	`case 78:`
		4960	`break;`
		4961	`default:`
		4962	`goto ZL1;`
		4963	`}`
		4964	`ADVANCE_LEXER;`
		4965	`read_exp ();`
		4966	`if ((CURRENT_TERMINAL) == 130) {`
		4967	`RESTORE_LEXER;`
		4968	`goto ZL1;`
		4969	`}`
		4970	`{`
		4971
		4972	`RESET_TDF((ZId));`
		4973	`SET_TDF((ZId), &(ZIb));`
		4974	`}`
		4975	`switch (CURRENT_TERMINAL) {`
		4976	`case 25:`
		4977	`break;`
		4978	`default:`
		4979	`goto ZL1;`
		4980	`}`
		4981	`ADVANCE_LEXER;`
		4982	`ZRsigned__nat__body ();`
		4983	`if ((CURRENT_TERMINAL) == 130) {`
		4984	`RESTORE_LEXER;`
		4985	`goto ZL1;`
		4986	`}`
		4987	`{`
		4988
		4989	`RESET_TDF((ZId));`
		4990	`SET_TDF((ZId), &(ZIc));`
		4991	`}`
		4992	`switch (CURRENT_TERMINAL) {`
		4993	`case 25:`
		4994	`break;`
		4995	`default:`
		4996	`goto ZL1;`
		4997	`}`
		4998	`ADVANCE_LEXER;`
		4999	`ZRsigned__nat__body ();`
		5000	`if ((CURRENT_TERMINAL) == 130) {`
		5001	`RESTORE_LEXER;`
		5002	`goto ZL1;`
		5003	`}`
		5004	`{`
		5005
		5006	`RESET_TDF((ZId));`
		5007	`o_signed_nat_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		5008	`append_TDF(&(ZIc),1));`
		5009	`}`
		5010	`switch (CURRENT_TERMINAL) {`
		5011	`case 29:`
		5012	`break;`
		5013	`default:`
		5014	`goto ZL1;`
		5015	`}`
		5016	`ADVANCE_LEXER;`
		5017	`}`
		5018	`break;`
		5019	`default:`
		5020	`goto ZL1;`
		5021	`}`
		5022	`}`
		5023	`}`
		5024	`break;`
		5025	`case 22: case 55:`
		5026	`{`
		5027	`ZRinteger ();`
		5028	`if ((CURRENT_TERMINAL) == 130) {`
		5029	`RESTORE_LEXER;`
		5030	`goto ZL1;`
		5031	`}`
		5032	`{`
		5033
		5034	`o_make_signed_nat(out_tdfbool(0), out_tdfint32(intvalue));`
		5035	`}`
		5036	`}`
		5037	`break;`
		5038	`case 98:`
		5039	`{`
		5040	`int ZIa;`
		5041
		5042	`{`
		5043
		5044	`(ZIa) = lex_v.val.v;`
		5045	`}`
		5046	`ADVANCE_LEXER;`
		5047	`{`
		5048
		5049	`(constructs[(ZIa)].f)();`
		5050	`}`
		5051	`}`
		5052	`break;`
		5053	`case 100:`
		5054	`{`
		5055	`PTR_Tokdec ZIa;`
		5056
		5057	`{`
		5058
		5059	`(ZIa) = lex_v.val.tokname;`
		5060	`(ZIa)->isused = 1;`
		5061	`}`
		5062	`ADVANCE_LEXER;`
		5063	`{`
		5064
		5065	`expand_tok((ZIa), &(ZIa)->sort);`
		5066	`}`
		5067	`}`
		5068	`break;`
		5069	`case 62:`
		5070	`{`
		5071	`{`
		5072
		5073	`o_make_signed_nat(out_tdfbool(0), out_tdfint32(cLINE));`
		5074	`}`
		5075	`ADVANCE_LEXER;`
		5076	`}`
		5077	`break;`
		5078	`case 10:`
		5079	`{`
		5080	`TDF ZIa;`
		5081	`PTR_TDF ZIb;`
		5082
		5083	`{`
		5084
		5085	`SET_TDF((ZIb), &(ZIa));`
		5086	`if (strcmp(lex_v.val.name, "+"))fail("Only + or - on NATs");`
		5087	`}`
		5088	`ADVANCE_LEXER;`
		5089	`ZRnat__not__int ();`
		5090	`if ((CURRENT_TERMINAL) == 130) {`
		5091	`RESTORE_LEXER;`
		5092	`goto ZL1;`
		5093	`}`
		5094	`{`
		5095
		5096	`RESET_TDF((ZIb));`
		5097	`o_snat_from_nat(o_false, append_TDF(&(ZIa),1));`
		5098	`}`
		5099	`}`
		5100	`break;`
		5101	`case 130:`
		5102	`return;`
		5103	`default:`
		5104	`goto ZL1;`
		5105	`}`
		5106	`return;`
		5107	`ZL1:;`
		5108	`SAVE_LEXER (130);`
		5109	`return;`
		5110	`}`
		5111
		5112	`static void`
		5113	`ZRlabset__opt(void)`
		5114	`{`
		5115	`switch (CURRENT_TERMINAL) {`
		5116	`default:`
		5117	`{`
		5118	`{`
		5119
		5120	`TDF * hold;`
		5121	`SET_TDF(hold, &optlab);`
		5122	`if (defaultlab==-1)defaultlab = next_label();`
		5123	`o_make_label(out_tdfint32(UL(defaultlab)));`
		5124	`RESET_TDF(hold);`
		5125	`}`
		5126	`}`
		5127	`break;`
		5128	`case 24:`
		5129	`{`
		5130	`PTR_TDF ZIa;`
		5131
		5132	`{`
		5133
		5134	`SET_TDF((ZIa), &optlab);`
		5135	`g_labdec = (Labdec*)0;`
		5136	`if (defaultlab != -1) { fail("This conditional uses a default jump"); }`
		5137	`}`
		5138	`ADVANCE_LEXER;`
		5139	`read_label ();`
		5140	`switch (CURRENT_TERMINAL) {`
		5141	`case 24:`
		5142	`break;`
		5143	`case 130:`
		5144	`RESTORE_LEXER;`
		5145	`goto ZL1;`
		5146	`default:`
		5147	`goto ZL1;`
		5148	`}`
		5149	`ADVANCE_LEXER;`
		5150	`{`
		5151
		5152	`if (g_labdec != (Labdec*)0) {`
		5153	`if (g_labdec->declared) {`
		5154	`fail("Label %s set twice", g_labdec->idname.id);`
		5155	`}`
		5156	`g_labdec->declared = 1;`
		5157	`}`
		5158	`RESET_TDF((ZIa));`
		5159	`}`
		5160	`}`
		5161	`break;`
		5162	`case 130:`
		5163	`return;`
		5164	`}`
		5165	`return;`
		5166	`ZL1:;`
		5167	`SAVE_LEXER (130);`
		5168	`return;`
		5169	`}`
		5170
		5171	`static void`
		5172	`ZRkeep__item(void)`
		5173	`{`
		5174	`switch (CURRENT_TERMINAL) {`
		5175	`case 2: case 5: case 9: case 15: case 18:`
		5176	`case 40: case 43: case 49: case 60: case 71:`
		5177	`case 75: case 91: case 96: case 100: case 111:`
		5178	`case 120: case 128:`
		5179	`{`
		5180	`{`
		5181
		5182	`Tokdec * k = lex_v.val.tokname;`
		5183	`k->iskept = 1;`
		5184	`}`
		5185	`{`
		5186	`switch (CURRENT_TERMINAL) {`
		5187	`case 2:`
		5188	`{`
		5189	`ADVANCE_LEXER;`
		5190	`}`
		5191	`break;`
		5192	`case 5:`
		5193	`{`
		5194	`ADVANCE_LEXER;`
		5195	`}`
		5196	`break;`
		5197	`case 9:`
		5198	`{`
		5199	`ADVANCE_LEXER;`
		5200	`}`
		5201	`break;`
		5202	`case 15:`
		5203	`{`
		5204	`ADVANCE_LEXER;`
		5205	`}`
		5206	`break;`
		5207	`case 18:`
		5208	`{`
		5209	`ADVANCE_LEXER;`
		5210	`}`
		5211	`break;`
		5212	`case 40:`
		5213	`{`
		5214	`ADVANCE_LEXER;`
		5215	`}`
		5216	`break;`
		5217	`case 43:`
		5218	`{`
		5219	`ADVANCE_LEXER;`
		5220	`}`
		5221	`break;`
		5222	`case 49:`
		5223	`{`
		5224	`ADVANCE_LEXER;`
		5225	`}`
		5226	`break;`
		5227	`case 60:`
		5228	`{`
		5229	`ADVANCE_LEXER;`
		5230	`}`
		5231	`break;`
		5232	`case 71:`
		5233	`{`
		5234	`ADVANCE_LEXER;`
		5235	`}`
		5236	`break;`
		5237	`case 75:`
		5238	`{`
		5239	`ADVANCE_LEXER;`
		5240	`}`
		5241	`break;`
		5242	`case 91:`
		5243	`{`
		5244	`ADVANCE_LEXER;`
		5245	`}`
		5246	`break;`
		5247	`case 96:`
		5248	`{`
		5249	`ADVANCE_LEXER;`
		5250	`}`
		5251	`break;`
		5252	`case 100:`
		5253	`{`
		5254	`ADVANCE_LEXER;`
		5255	`}`
		5256	`break;`
		5257	`case 111:`
		5258	`{`
		5259	`ADVANCE_LEXER;`
		5260	`}`
		5261	`break;`
		5262	`case 120:`
		5263	`{`
		5264	`ADVANCE_LEXER;`
		5265	`}`
		5266	`break;`
		5267	`case 128:`
		5268	`{`
		5269	`ADVANCE_LEXER;`
		5270	`}`
		5271	`break;`
		5272	`default:`
		5273	`goto ZL1;`
		5274	`}`
		5275	`}`
		5276	`}`
		5277	`break;`
		5278	`case 54:`
		5279	`{`
		5280	`{`
		5281
		5282	`char * n = lex_v.val.name;`
		5283	`Tagdec * t = find_tag(n);`
		5284	`if (t != (Tagdec*)0) {`
		5285	`t->iskept = 1;`
		5286	`} else {`
		5287	`Al_tagdec * a = find_al_tag(n);`
		5288	`if (a == (Al_tagdec*)0) {`
		5289	`fail("Ident %s not declared",n);`
		5290	`}`
		5291	`a->iskept = 1;`
		5292	`}`
		5293	`}`
		5294	`ADVANCE_LEXER;`
		5295	`}`
		5296	`break;`
		5297	`case 130:`
		5298	`return;`
		5299	`default:`
		5300	`goto ZL1;`
		5301	`}`
		5302	`return;`
		5303	`ZL1:;`
		5304	`SAVE_LEXER (130);`
		5305	`return;`
		5306	`}`
		5307
		5308	`static void`
		5309	`ZRstruct__def(void)`
		5310	`{`
		5311	`if ((CURRENT_TERMINAL) == 130) {`
		5312	`return;`
		5313	`}`
		5314	`{`
		5315	`PTR_Tokdec ZIa;`
		5316
		5317	`switch (CURRENT_TERMINAL) {`
		5318	`case 108:`
		5319	`break;`
		5320	`default:`
		5321	`goto ZL1;`
		5322	`}`
		5323	`ADVANCE_LEXER;`
		5324	`{`
		5325
		5326	`char * n = lex_v.val.name;`
		5327	`(ZIa) = find_tok(n);`
		5328	`SELECT_UNIT(tokdef_unit);`
		5329	`if ((ZIa)!= (Tokdec*)0)fail("Struct name %s must be unique", n);`
		5330	`(ZIa) = MALLOC(Tokdec); NEW_IDNAME((ZIa)->idname, n, tok_ent);`
		5331	`(ZIa)->sort.ressort.sort = shape_sort; (ZIa)->sort.pars = (Tokpar*)0;`
		5332	`(ZIa)->isdeffed = 1; (ZIa)->isused=0; (ZIa)->iskept=0;`
		5333	`g_lastfield = -1;`
		5334	`}`
		5335	`switch (CURRENT_TERMINAL) {`
		5336	`case 54:`
		5337	`break;`
		5338	`default:`
		5339	`goto ZL1;`
		5340	`}`
		5341	`ADVANCE_LEXER;`
		5342	`switch (CURRENT_TERMINAL) {`
		5343	`case 78:`
		5344	`break;`
		5345	`default:`
		5346	`goto ZL1;`
		5347	`}`
		5348	`ADVANCE_LEXER;`
		5349	`ZRfield__list ();`
		5350	`if ((CURRENT_TERMINAL) == 130) {`
		5351	`RESTORE_LEXER;`
		5352	`goto ZL1;`
		5353	`}`
		5354	`{`
		5355
		5356	`o_make_tokdef(out_tdfint32(LOCNAME((ZIa)->idname)), {},`
		5357	`o_token_def(o_shape, {},`
		5358	`o_compound(o_offset_add(`
		5359	`o_exp_apply_token(`
		5360	`o_make_tok(out_tdfint32(UL(g_lastfield))),{}),`
		5361	`o_shape_offset(append_TDF(&g_lastshape, 1))))))`
		5362	`INC_LIST;`
		5363	`(ZIa)->next = tokdecs;`
		5364	`tokdecs = (ZIa);`
		5365	`}`
		5366	`switch (CURRENT_TERMINAL) {`
		5367	`case 29:`
		5368	`break;`
		5369	`default:`
		5370	`goto ZL1;`
		5371	`}`
		5372	`ADVANCE_LEXER;`
		5373	`}`
		5374	`return;`
		5375	`ZL1:;`
		5376	`SAVE_LEXER (130);`
		5377	`return;`
		5378	`}`
		5379
		5380	`static void`
		5381	`ZRnonst__shape__body(void)`
		5382	`{`
		5383	`switch (CURRENT_TERMINAL) {`
		5384	`case 83:`
		5385	`{`
		5386	`TDF ZIa;`
		5387	`PTR_TDF ZIb;`
		5388
		5389	`ADVANCE_LEXER;`
		5390	`{`
		5391
		5392	`SET_TDF((ZIb), &(ZIa));`
		5393	`}`
		5394	`read_shape ();`
		5395	`if ((CURRENT_TERMINAL) == 130) {`
		5396	`RESTORE_LEXER;`
		5397	`goto ZL1;`
		5398	`}`
		5399	`{`
		5400
		5401	`RESET_TDF((ZIb));`
		5402	`o_pointer(o_alignment(append_TDF(&(ZIa),1)));`
		5403	`}`
		5404	`}`
		5405	`break;`
		5406	`case 95:`
		5407	`{`
		5408	`ADVANCE_LEXER;`
		5409	`ZR676 ();`
		5410	`if ((CURRENT_TERMINAL) == 130) {`
		5411	`RESTORE_LEXER;`
		5412	`goto ZL1;`
		5413	`}`
		5414	`}`
		5415	`break;`
		5416	`case 94:`
		5417	`{`
		5418	`int ZIa;`
		5419
		5420	`{`
		5421
		5422	`(ZIa) = lex_v.val.v;`
		5423	`}`
		5424	`ADVANCE_LEXER;`
		5425	`{`
		5426
		5427	`(constructs[(ZIa)].f)();`
		5428	`}`
		5429	`}`
		5430	`break;`
		5431	`case 96:`
		5432	`{`
		5433	`PTR_Tokdec ZIa;`
		5434
		5435	`{`
		5436
		5437	`(ZIa) = lex_v.val.tokname;`
		5438	`(ZIa)->isused = 1;`
		5439	`}`
		5440	`ADVANCE_LEXER;`
		5441	`{`
		5442
		5443	`expand_tok((ZIa), &(ZIa)->sort);`
		5444	`}`
		5445	`}`
		5446	`break;`
		5447	`case 130:`
		5448	`return;`
		5449	`default:`
		5450	`goto ZL1;`
		5451	`}`
		5452	`return;`
		5453	`ZL1:;`
		5454	`SAVE_LEXER (130);`
		5455	`return;`
		5456	`}`
		5457
		5458	`void`
		5459	`read_tag(void)`
		5460	`{`
		5461	`ZL2_tag:;`
		5462	`switch (CURRENT_TERMINAL) {`
		5463	`case 110:`
		5464	`{`
		5465	`ADVANCE_LEXER;`
		5466	`switch (CURRENT_TERMINAL) {`
		5467	`case 24:`
		5468	`break;`
		5469	`default:`
		5470	`goto ZL1;`
		5471	`}`
		5472	`ADVANCE_LEXER;`
		5473	`goto ZL2_tag;`
		5474	`}`
		5475	`/UNREACHED/`
		5476	`case 109:`
		5477	`{`
		5478	`int ZIa;`
		5479
		5480	`{`
		5481
		5482	`(ZIa) = lex_v.val.v;`
		5483	`}`
		5484	`ADVANCE_LEXER;`
		5485	`{`
		5486
		5487	`(constructs[(ZIa)].f)();`
		5488	`}`
		5489	`}`
		5490	`break;`
		5491	`case 111:`
		5492	`{`
		5493	`PTR_Tokdec ZIa;`
		5494
		5495	`{`
		5496
		5497	`(ZIa) = lex_v.val.tokname;`
		5498	`(ZIa)->isused = 1;`
		5499	`}`
		5500	`ADVANCE_LEXER;`
		5501	`{`
		5502
		5503	`expand_tok((ZIa), &(ZIa)->sort);`
		5504	`}`
		5505	`}`
		5506	`break;`
		5507	`case 54:`
		5508	`{`
		5509	`{`
		5510
		5511	`char * n =lex_v.val.name;`
		5512	`Tagdec * x = find_tag(n);`
		5513	`if (x == (Tagdec*)0) { fail("Ident %s not declared", n); }`
		5514	`x->isused = 1;`
		5515	`make_tag(&x->idname.name);`
		5516	`}`
		5517	`ADVANCE_LEXER;`
		5518	`}`
		5519	`break;`
		5520	`case 130:`
		5521	`return;`
		5522	`default:`
		5523	`goto ZL1;`
		5524	`}`
		5525	`return;`
		5526	`ZL1:;`
		5527	`{`
		5528	`{`
		5529
		5530	`fail("Syntax error");`
		5531	`}`
		5532	`}`
		5533	`}`
		5534
		5535	`static void`
		5536	`ZRvariety__opt(void)`
		5537	`{`
		5538	`switch (CURRENT_TERMINAL) {`
		5539	`case 78:`
		5540	`{`
		5541	`ADVANCE_LEXER;`
		5542	`read_variety ();`
		5543	`switch (CURRENT_TERMINAL) {`
		5544	`case 29:`
		5545	`break;`
		5546	`case 130:`
		5547	`RESTORE_LEXER;`
		5548	`goto ZL1;`
		5549	`default:`
		5550	`goto ZL1;`
		5551	`}`
		5552	`ADVANCE_LEXER;`
		5553	`}`
		5554	`break;`
		5555	`default:`
		5556	`{`
		5557	`{`
		5558
		5559	`/* unsigned char */`
		5560	`o_var_limits(`
		5561	`o_make_signed_nat(out_tdfbool(0), out_tdfint32(UL(0))),`
		5562	`o_make_signed_nat(out_tdfbool(0), out_tdfint32(UL(255))));`
		5563	`}`
		5564	`}`
		5565	`break;`
		5566	`case 130:`
		5567	`return;`
		5568	`}`
		5569	`return;`
		5570	`ZL1:;`
		5571	`SAVE_LEXER (130);`
		5572	`return;`
		5573	`}`
		5574
		5575	`void`
		5576	`read_nat_option(void)`
		5577	`{`
		5578	`switch (CURRENT_TERMINAL) {`
		5579	`case 22: case 55: case 69: case 70: case 71:`
		5580	`{`
		5581	`TDF ZIa;`
		5582	`PTR_TDF ZIb;`
		5583
		5584	`{`
		5585
		5586	`SET_TDF((ZIb), &(ZIa));`
		5587	`}`
		5588	`read_nat ();`
		5589	`if ((CURRENT_TERMINAL) == 130) {`
		5590	`RESTORE_LEXER;`
		5591	`goto ZL1;`
		5592	`}`
		5593	`{`
		5594
		5595	`RESET_TDF((ZIb));`
		5596	`OPTION(append_TDF(&(ZIa),1));`
		5597	`}`
		5598	`}`
		5599	`break;`
		5600	`case 130:`
		5601	`return;`
		5602	`default:`
		5603	`break;`
		5604	`}`
		5605	`return;`
		5606	`ZL1:;`
		5607	`{`
		5608	`{`
		5609
		5610	`fail("Syntax error");`
		5611	`}`
		5612	`}`
		5613	`}`
		5614
		5615	`static void`
		5616	`ZRsortname__list__opt(void)`
		5617	`{`
		5618	`switch (CURRENT_TERMINAL) {`
		5619	`case 1: case 4: case 8: case 14: case 17:`
		5620	`case 39: case 42: case 48: case 59: case 70:`
		5621	`case 74: case 90: case 95: case 99: case 105:`
		5622	`case 110: case 116: case 119: case 127:`
		5623	`{`
		5624	`ZRsortname__list ();`
		5625	`if ((CURRENT_TERMINAL) == 130) {`
		5626	`RESTORE_LEXER;`
		5627	`goto ZL1;`
		5628	`}`
		5629	`}`
		5630	`break;`
		5631	`default:`
		5632	`{`
		5633	`{`
		5634
		5635	`g_tokpars = (Tokpar*)0;`
		5636	`}`
		5637	`}`
		5638	`break;`
		5639	`case 130:`
		5640	`return;`
		5641	`}`
		5642	`return;`
		5643	`ZL1:;`
		5644	`SAVE_LEXER (130);`
		5645	`return;`
		5646	`}`
		5647
		5648	`void`
		5649	`read_floating_variety(void)`
		5650	`{`
		5651	`ZL2_floating__variety:;`
		5652	`switch (CURRENT_TERMINAL) {`
		5653	`case 32:`
		5654	`{`
		5655	`ADVANCE_LEXER;`
		5656	`{`
		5657
		5658	`o_flvar_parms(o_make_nat(out_tdfint32(UL(2))),`
		5659	`o_make_nat(out_tdfint32(UL(MANT_DOUBLE))),`
		5660	`o_make_nat(out_tdfint32(UL(MINEXP_DOUBLE))),`
		5661	`o_make_nat(out_tdfint32(UL(MAXEXP_DOUBLE))));`
		5662	`}`
		5663	`}`
		5664	`break;`
		5665	`case 46:`
		5666	`{`
		5667	`ADVANCE_LEXER;`
		5668	`{`
		5669
		5670	`o_flvar_parms(o_make_nat(out_tdfint32(UL(2))),`
		5671	`o_make_nat(out_tdfint32(UL(MANT_FLOAT))),`
		5672	`o_make_nat(out_tdfint32(UL(MINEXP_FLOAT))),`
		5673	`o_make_nat(out_tdfint32(UL(MAXEXP_FLOAT))));`
		5674	`}`
		5675	`}`
		5676	`break;`
		5677	`case 48:`
		5678	`{`
		5679	`ADVANCE_LEXER;`
		5680	`{`
		5681	`switch (CURRENT_TERMINAL) {`
		5682	`case 24:`
		5683	`{`
		5684	`ADVANCE_LEXER;`
		5685	`goto ZL2_floating__variety;`
		5686	`}`
		5687	`/UNREACHED/`
		5688	`case 86:`
		5689	`{`
		5690	`TDF ZIa;`
		5691	`TDF ZIb;`
		5692	`TDF ZIc;`
		5693	`PTR_TDF ZId;`
		5694
		5695	`{`
		5696
		5697	`/* (ZIb), (ZIc) uninitialised */`
		5698	`SET_TDF((ZId), &(ZIa));`
		5699	`}`
		5700	`ADVANCE_LEXER;`
		5701	`switch (CURRENT_TERMINAL) {`
		5702	`case 78:`
		5703	`break;`
		5704	`default:`
		5705	`goto ZL1;`
		5706	`}`
		5707	`ADVANCE_LEXER;`
		5708	`read_exp ();`
		5709	`switch (CURRENT_TERMINAL) {`
		5710	`case 25:`
		5711	`break;`
		5712	`case 130:`
		5713	`RESTORE_LEXER;`
		5714	`goto ZL1;`
		5715	`default:`
		5716	`goto ZL1;`
		5717	`}`
		5718	`ADVANCE_LEXER;`
		5719	`{`
		5720
		5721	`RESET_TDF((ZId));`
		5722	`SET_TDF((ZId), &(ZIb));`
		5723	`}`
		5724	`read_floating_variety ();`
		5725	`switch (CURRENT_TERMINAL) {`
		5726	`case 25:`
		5727	`break;`
		5728	`case 130:`
		5729	`RESTORE_LEXER;`
		5730	`goto ZL1;`
		5731	`default:`
		5732	`goto ZL1;`
		5733	`}`
		5734	`ADVANCE_LEXER;`
		5735	`{`
		5736
		5737	`RESET_TDF((ZId));`
		5738	`SET_TDF((ZId), &(ZIc));`
		5739	`}`
		5740	`read_floating_variety ();`
		5741	`if ((CURRENT_TERMINAL) == 130) {`
		5742	`RESTORE_LEXER;`
		5743	`goto ZL1;`
		5744	`}`
		5745	`{`
		5746
		5747	`RESET_TDF((ZId));`
		5748	`o_flvar_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		5749	`append_TDF(&(ZIc),1));`
		5750	`}`
		5751	`switch (CURRENT_TERMINAL) {`
		5752	`case 29:`
		5753	`break;`
		5754	`default:`
		5755	`goto ZL1;`
		5756	`}`
		5757	`ADVANCE_LEXER;`
		5758	`}`
		5759	`break;`
		5760	`default:`
		5761	`goto ZL1;`
		5762	`}`
		5763	`}`
		5764	`}`
		5765	`break;`
		5766	`case 47:`
		5767	`{`
		5768	`int ZIa;`
		5769
		5770	`{`
		5771
		5772	`(ZIa) = lex_v.val.v;`
		5773	`}`
		5774	`ADVANCE_LEXER;`
		5775	`{`
		5776
		5777	`(constructs[(ZIa)].f)();`
		5778	`}`
		5779	`}`
		5780	`break;`
		5781	`case 49:`
		5782	`{`
		5783	`PTR_Tokdec ZIa;`
		5784
		5785	`{`
		5786
		5787	`(ZIa) = lex_v.val.tokname;`
		5788	`(ZIa)->isused = 1;`
		5789	`}`
		5790	`ADVANCE_LEXER;`
		5791	`{`
		5792
		5793	`expand_tok((ZIa), &(ZIa)->sort);`
		5794	`}`
		5795	`}`
		5796	`break;`
		5797	`case 130:`
		5798	`return;`
		5799	`default:`
		5800	`goto ZL1;`
		5801	`}`
		5802	`return;`
		5803	`ZL1:;`
		5804	`{`
		5805	`{`
		5806
		5807	`fail("Syntax error");`
		5808	`}`
		5809	`}`
		5810	`}`
		5811
		5812	`static void`
		5813	`ZRtagshacc(void)`
		5814	`{`
		5815	`if ((CURRENT_TERMINAL) == 130) {`
		5816	`return;`
		5817	`}`
		5818	`{`
		5819	`TDF ZIa;`
		5820	`PTR_TDF ZIb;`
		5821	`PTR_Tagdec ZIc;`
		5822	`int ZId;`
		5823
		5824	`{`
		5825
		5826	`/* (ZId) uninitialised */`
		5827	`char * n =lex_v.val.name;`
		5828	`(ZIc) = find_tag(n);`
		5829	`if ((ZIc) != (Tagdec*)0)fail("Ident %s already declared", n);`
		5830	`(ZIc) = MALLOC(Tagdec);`
		5831	`(ZIc)->hassh = 2; (ZIc)->isvar =1; (ZIc)->isdeffed = 1; (ZIc)->iskept=0;`
		5832	`NEW_IDNAME((ZIc)->idname, n, tag_ent);`
		5833	`g_has_vis =0;`
		5834	`SET_TDF((ZIb), &(ZIa));`
		5835	`}`
		5836	`switch (CURRENT_TERMINAL) {`
		5837	`case 54:`
		5838	`break;`
		5839	`default:`
		5840	`goto ZL1;`
		5841	`}`
		5842	`ADVANCE_LEXER;`
		5843	`ZRaccess__opt ();`
		5844	`if ((CURRENT_TERMINAL) == 130) {`
		5845	`RESTORE_LEXER;`
		5846	`goto ZL1;`
		5847	`}`
		5848	`{`
		5849
		5850	`RESET_TDF((ZIb));`
		5851	`SET_TDF((ZIb), &(ZIc)->sh.tdfsh);`
		5852	`(ZId) = g_has_vis;`
		5853	`}`
		5854	`switch (CURRENT_TERMINAL) {`
		5855	`case 24:`
		5856	`break;`
		5857	`default:`
		5858	`goto ZL1;`
		5859	`}`
		5860	`ADVANCE_LEXER;`
		5861	`read_shape ();`
		5862	`if ((CURRENT_TERMINAL) == 130) {`
		5863	`RESTORE_LEXER;`
		5864	`goto ZL1;`
		5865	`}`
		5866	`{`
		5867
		5868	`RESET_TDF((ZIb));`
		5869	`o_make_tagshacc(append_TDF(&(ZIc)->sh.tdfsh, 0),`
		5870	`if ((ZIa).no != 0) {OPTION(append_TDF(&(ZIa),1));},`
		5871	`make_tag(&(ZIc)->idname.name));`
		5872	`if ((ZId)) {`
		5873	`Tagdec * y = MALLOC(Tagdec);`
		5874	`y = (ZIc);`
		5875	`y->next = tagdecs;`
		5876	`tagdecs = y;`
		5877	`}`
		5878	`(ZIc)->next = localdecs;`
		5879	`localdecs = (ZIc);`
		5880	`}`
		5881	`}`
		5882	`return;`
		5883	`ZL1:;`
		5884	`SAVE_LEXER (130);`
		5885	`return;`
		5886	`}`
		5887
		5888	`static void`
		5889	`ZRelement__list__opt(void)`
		5890	`{`
		5891	`ZL2_element__list__opt:;`
		5892	`switch (CURRENT_TERMINAL) {`
		5893	`case 6: case 26: case 27: case 53: case 61:`
		5894	`case 81: case 106: case 108: case 113: case 114:`
		5895	`case 124: case 125:`
		5896	`{`
		5897	`ZRelement ();`
		5898	`switch (CURRENT_TERMINAL) {`
		5899	`case 93:`
		5900	`break;`
		5901	`case 130:`
		5902	`RESTORE_LEXER;`
		5903	`goto ZL1;`
		5904	`default:`
		5905	`goto ZL1;`
		5906	`}`
		5907	`ADVANCE_LEXER;`
		5908	`goto ZL2_element__list__opt;`
		5909	`}`
		5910	`/UNREACHED/`
		5911	`case 130:`
		5912	`return;`
		5913	`default:`
		5914	`break;`
		5915	`}`
		5916	`return;`
		5917	`ZL1:;`
		5918	`SAVE_LEXER (130);`
		5919	`return;`
		5920	`}`
		5921
		5922	`void`
		5923	`read_nat(void)`
		5924	`{`
		5925	`ZL2_nat:;`
		5926	`switch (CURRENT_TERMINAL) {`
		5927	`case 22: case 55:`
		5928	`{`
		5929	`ZRinteger ();`
		5930	`if ((CURRENT_TERMINAL) == 130) {`
		5931	`RESTORE_LEXER;`
		5932	`goto ZL1;`
		5933	`}`
		5934	`{`
		5935
		5936	`o_make_nat(out_tdfint32(intvalue));`
		5937	`}`
		5938	`}`
		5939	`break;`
		5940	`case 69: case 70: case 71:`
		5941	`{`
		5942	`ZRnat__not__int ();`
		5943	`if ((CURRENT_TERMINAL) == 130) {`
		5944	`RESTORE_LEXER;`
		5945	`goto ZL1;`
		5946	`}`
		5947	`}`
		5948	`break;`
		5949	`case 130:`
		5950	`return;`
		5951	`default:`
		5952	`goto ZL1;`
		5953	`}`
		5954	`return;`
		5955	`ZL1:;`
		5956	`{`
		5957	`{`
		5958
		5959	`fail("Syntax error");`
		5960	`}`
		5961	`}`
		5962	`}`
		5963
		5964	`void`
		5965	`read_alignment(void)`
		5966	`{`
		5967	`ZL2_alignment:;`
		5968	`switch (CURRENT_TERMINAL) {`
		5969	`case 8:`
		5970	`{`
		5971	`ADVANCE_LEXER;`
		5972	`{`
		5973	`switch (CURRENT_TERMINAL) {`
		5974	`case 24:`
		5975	`{`
		5976	`ADVANCE_LEXER;`
		5977	`goto ZL2_alignment;`
		5978	`}`
		5979	`/UNREACHED/`
		5980	`case 86:`
		5981	`{`
		5982	`TDF ZIa;`
		5983	`TDF ZIb;`
		5984	`TDF ZIc;`
		5985	`PTR_TDF ZId;`
		5986
		5987	`ADVANCE_LEXER;`
		5988	`{`
		5989
		5990	`/* (ZIb), (ZIc) uninitialised */`
		5991	`SET_TDF((ZId), &(ZIa));`
		5992	`}`
		5993	`switch (CURRENT_TERMINAL) {`
		5994	`case 78:`
		5995	`break;`
		5996	`default:`
		5997	`goto ZL1;`
		5998	`}`
		5999	`ADVANCE_LEXER;`
		6000	`read_exp ();`
		6001	`switch (CURRENT_TERMINAL) {`
		6002	`case 25:`
		6003	`break;`
		6004	`case 130:`
		6005	`RESTORE_LEXER;`
		6006	`goto ZL1;`
		6007	`default:`
		6008	`goto ZL1;`
		6009	`}`
		6010	`ADVANCE_LEXER;`
		6011	`{`
		6012
		6013	`RESET_TDF((ZId));`
		6014	`SET_TDF((ZId), &(ZIb));`
		6015	`}`
		6016	`read_alignment ();`
		6017	`switch (CURRENT_TERMINAL) {`
		6018	`case 25:`
		6019	`break;`
		6020	`case 130:`
		6021	`RESTORE_LEXER;`
		6022	`goto ZL1;`
		6023	`default:`
		6024	`goto ZL1;`
		6025	`}`
		6026	`ADVANCE_LEXER;`
		6027	`{`
		6028
		6029	`RESET_TDF((ZId));`
		6030	`SET_TDF((ZId), &(ZIc));`
		6031	`}`
		6032	`read_alignment ();`
		6033	`if ((CURRENT_TERMINAL) == 130) {`
		6034	`RESTORE_LEXER;`
		6035	`goto ZL1;`
		6036	`}`
		6037	`{`
		6038
		6039	`RESET_TDF((ZId));`
		6040	`o_alignment_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		6041	`append_TDF(&(ZIc),1));`
		6042	`}`
		6043	`switch (CURRENT_TERMINAL) {`
		6044	`case 29:`
		6045	`break;`
		6046	`default:`
		6047	`goto ZL1;`
		6048	`}`
		6049	`ADVANCE_LEXER;`
		6050	`}`
		6051	`break;`
		6052	`default:`
		6053	`goto ZL1;`
		6054	`}`
		6055	`}`
		6056	`}`
		6057	`break;`
		6058	`case 78:`
		6059	`{`
		6060	`ADVANCE_LEXER;`
		6061	`ZRalignment__list__opt ();`
		6062	`switch (CURRENT_TERMINAL) {`
		6063	`case 29:`
		6064	`break;`
		6065	`case 130:`
		6066	`RESTORE_LEXER;`
		6067	`goto ZL1;`
		6068	`default:`
		6069	`goto ZL1;`
		6070	`}`
		6071	`ADVANCE_LEXER;`
		6072	`}`
		6073	`break;`
		6074	`case 4: case 5: case 54:`
		6075	`{`
		6076	`TDF ZIa;`
		6077	`PTR_TDF ZIb;`
		6078
		6079	`{`
		6080
		6081	`SET_TDF((ZIb), &(ZIa));`
		6082	`}`
		6083	`read_al_tag ();`
		6084	`if ((CURRENT_TERMINAL) == 130) {`
		6085	`RESTORE_LEXER;`
		6086	`goto ZL1;`
		6087	`}`
		6088	`{`
		6089
		6090	`RESET_TDF((ZIb));`
		6091	`o_obtain_al_tag(append_TDF(&(ZIa), 1));`
		6092	`}`
		6093	`}`
		6094	`break;`
		6095	`case 7:`
		6096	`{`
		6097	`int ZIa;`
		6098
		6099	`{`
		6100
		6101	`(ZIa) = lex_v.val.v;`
		6102	`}`
		6103	`ADVANCE_LEXER;`
		6104	`{`
		6105
		6106	`(constructs[(ZIa)].f)();`
		6107	`}`
		6108	`}`
		6109	`break;`
		6110	`case 9:`
		6111	`{`
		6112	`PTR_Tokdec ZIa;`
		6113
		6114	`{`
		6115
		6116	`(ZIa) = lex_v.val.tokname;`
		6117	`(ZIa)->isused = 1;`
		6118	`}`
		6119	`ADVANCE_LEXER;`
		6120	`{`
		6121
		6122	`expand_tok((ZIa), &(ZIa)->sort);`
		6123	`}`
		6124	`}`
		6125	`break;`
		6126	`case 130:`
		6127	`return;`
		6128	`default:`
		6129	`goto ZL1;`
		6130	`}`
		6131	`return;`
		6132	`ZL1:;`
		6133	`{`
		6134	`{`
		6135
		6136	`fail("Syntax error");`
		6137	`}`
		6138	`}`
		6139	`}`
		6140
		6141	`static void`
		6142	`ZRvarpar__opt(void)`
		6143	`{`
		6144	`switch (CURRENT_TERMINAL) {`
		6145	`case 129:`
		6146	`{`
		6147	`ADVANCE_LEXER;`
		6148	`read_exp ();`
		6149	`if ((CURRENT_TERMINAL) == 130) {`
		6150	`RESTORE_LEXER;`
		6151	`goto ZL1;`
		6152	`}`
		6153	`{`
		6154
		6155	`current_TDF->no=1;`
		6156	`}`
		6157	`}`
		6158	`break;`
		6159	`default:`
		6160	`{`
		6161	`{`
		6162
		6163	`current_TDF->no=0;`
		6164	`}`
		6165	`}`
		6166	`break;`
		6167	`case 130:`
		6168	`return;`
		6169	`}`
		6170	`return;`
		6171	`ZL1:;`
		6172	`SAVE_LEXER (130);`
		6173	`return;`
		6174	`}`
		6175
		6176	`static void`
		6177	`ZRkeep__list(void)`
		6178	`{`
		6179	`if ((CURRENT_TERMINAL) == 130) {`
		6180	`return;`
		6181	`}`
		6182	`ZL2_keep__list:;`
		6183	`{`
		6184	`ZRkeep__item ();`
		6185	`{`
		6186	`switch (CURRENT_TERMINAL) {`
		6187	`case 25:`
		6188	`{`
		6189	`ADVANCE_LEXER;`
		6190	`goto ZL2_keep__list;`
		6191	`}`
		6192	`/UNREACHED/`
		6193	`case 130:`
		6194	`RESTORE_LEXER;`
		6195	`goto ZL1;`
		6196	`default:`
		6197	`break;`
		6198	`}`
		6199	`}`
		6200	`}`
		6201	`return;`
		6202	`ZL1:;`
		6203	`SAVE_LEXER (130);`
		6204	`return;`
		6205	`}`
		6206
		6207	`static void`
		6208	`ZRproc__def(void)`
		6209	`{`
		6210	`if ((CURRENT_TERMINAL) == 130) {`
		6211	`return;`
		6212	`}`
		6213	`{`
		6214	`TDF ZIa;`
		6215	`TDF ZIb;`
		6216	`PTR_TDF ZIc;`
		6217	`PTR_Tagdec ZId;`
		6218	`PTR_char ZIe;`
		6219	`int ZIf;`
		6220
		6221	`switch (CURRENT_TERMINAL) {`
		6222	`case 81:`
		6223	`break;`
		6224	`default:`
		6225	`goto ZL1;`
		6226	`}`
		6227	`ADVANCE_LEXER;`
		6228	`{`
		6229
		6230	`/* (ZIa) uninitialised */`
		6231	`(ZIe) =lex_v.val.name;`
		6232	`(ZId) = find_tag((ZIe));`
		6233	`SELECT_UNIT(tagdef_unit);`
		6234	`if ((ZId)!= (Tagdec*)0) {`
		6235	`if ((ZId)->isdeffed && !(ZId)->iscommon)fail("Tag %s defined twice", (ZIe));`
		6236	`if ((ZId)->isvar)fail("Tag %s declared as variable", (ZIe));`
		6237	`(ZIf) = 1;`
		6238	`} else {`
		6239	`(ZId) = MALLOC(Tagdec);`
		6240	`(ZId)->hassh = 0; (ZId)->isvar=0; (ZId)->iskept=0; (ZId)->iscommon = 0;`
		6241	`(ZId)->isused = 0;`
		6242	`NEW_IDNAME((ZId)->idname, (ZIe), tag_ent);`
		6243	`(ZIf) = 0;`
		6244	`}`
		6245	`SET_TDF((ZIc), &(ZIb));`
		6246	`}`
		6247	`switch (CURRENT_TERMINAL) {`
		6248	`case 54:`
		6249	`break;`
		6250	`default:`
		6251	`goto ZL1;`
		6252	`}`
		6253	`ADVANCE_LEXER;`
		6254	`switch (CURRENT_TERMINAL) {`
		6255	`case 36:`
		6256	`break;`
		6257	`default:`
		6258	`goto ZL1;`
		6259	`}`
		6260	`ADVANCE_LEXER;`
		6261	`{`
		6262
		6263	`RESET_TDF((ZIc));`
		6264	`SET_TDF((ZIc), &(ZIa));`
		6265	`}`
		6266	`ZRproc__def__body ();`
		6267	`if ((CURRENT_TERMINAL) == 130) {`
		6268	`RESTORE_LEXER;`
		6269	`goto ZL1;`
		6270	`}`
		6271	`{`
		6272
		6273	`RESET_TDF((ZIc));`
		6274	`o_make_id_tagdef(out_tdfint32(UL(local_name(&(ZId)->idname.name, tag_ent))),`
		6275	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), (ZIf))); },`
		6276	`append_TDF(&(ZIa), 1));`
		6277	`INC_LIST;`
		6278	`SELECT_UNIT(tagdec_unit);`
		6279	`if (!(ZIf)) {`
		6280	`o_make_id_tagdec(out_tdfint32(UL(non_local(&(ZId)->idname.name,tag_ent))),`
		6281	`{},`
		6282	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		6283	`o_proc);`
		6284	`INC_LIST;`
		6285	`}`
		6286	`(ZId)->isdeffed=1;`
		6287	`if (!(ZIf)) {(ZId)->next = tagdecs; tagdecs = (ZId);}`
		6288	`}`
		6289	`}`
		6290	`return;`
		6291	`ZL1:;`
		6292	`SAVE_LEXER (130);`
		6293	`return;`
		6294	`}`
		6295
		6296	`void`
		6297	`read_error_code_list(void)`
		6298	`{`
		6299	`if ((CURRENT_TERMINAL) == 130) {`
		6300	`return;`
		6301	`}`
		6302	`{`
		6303	`read_error_code ();`
		6304	`if ((CURRENT_TERMINAL) == 130) {`
		6305	`RESTORE_LEXER;`
		6306	`goto ZL1;`
		6307	`}`
		6308	`{`
		6309
		6310	`current_TDF->no = 1;`
		6311	`}`
		6312	`ZR625 ();`
		6313	`if ((CURRENT_TERMINAL) == 130) {`
		6314	`RESTORE_LEXER;`
		6315	`goto ZL1;`
		6316	`}`
		6317	`}`
		6318	`return;`
		6319	`ZL1:;`
		6320	`{`
		6321	`{`
		6322
		6323	`fail("Syntax error");`
		6324	`}`
		6325	`}`
		6326	`}`
		6327
		6328	`static void`
		6329	`ZRcallee__var__opt(void)`
		6330	`{`
		6331	`switch (CURRENT_TERMINAL) {`
		6332	`case 31:`
		6333	`{`
		6334	`ADVANCE_LEXER;`
		6335	`{`
		6336
		6337	`g_ce_v = 1;`
		6338	`}`
		6339	`}`
		6340	`break;`
		6341	`default:`
		6342	`{`
		6343	`{`
		6344
		6345	`g_ce_v = 0;`
		6346	`}`
		6347	`}`
		6348	`break;`
		6349	`case 130:`
		6350	`return;`
		6351	`}`
		6352	`}`
		6353
		6354	`static void`
		6355	`ZRtag__dec(void)`
		6356	`{`
		6357	`switch (CURRENT_TERMINAL) {`
		6358	`case 27:`
		6359	`{`
		6360	`TDF ZIa;`
		6361	`TDF ZIb;`
		6362	`PTR_TDF ZIc;`
		6363	`PTR_Tagdec ZId;`
		6364
		6365	`ADVANCE_LEXER;`
		6366	`{`
		6367
		6368	`/* (ZIb) uninitialised */`
		6369	`char * n =lex_v.val.name;`
		6370	`(ZId) = find_tag(n);`
		6371	`if ((ZId) != (Tagdec*)0)fail("Tag %s declared twice", n);`
		6372	`SELECT_UNIT(tagdec_unit);`
		6373	`(ZId) = MALLOC(Tagdec); NEW_IDNAME((ZId)->idname, n, tag_ent);`
		6374	`(ZId)->isdeffed = 0; (ZId)->hassh = 1; (ZId)->iskept=0; (ZId)->iscommon=0;`
		6375	`(ZId)->isused = 0;`
		6376	`SET_TDF((ZIc), &(ZIa));`
		6377	`}`
		6378	`switch (CURRENT_TERMINAL) {`
		6379	`case 54:`
		6380	`break;`
		6381	`default:`
		6382	`goto ZL1;`
		6383	`}`
		6384	`ADVANCE_LEXER;`
		6385	`ZRaccess__opt ();`
		6386	`if ((CURRENT_TERMINAL) == 130) {`
		6387	`RESTORE_LEXER;`
		6388	`goto ZL1;`
		6389	`}`
		6390	`{`
		6391
		6392	`RESET_TDF((ZIc));`
		6393	`SET_TDF((ZIc), &(ZIb));`
		6394	`}`
		6395	`ZRsignature__opt ();`
		6396	`if ((CURRENT_TERMINAL) == 130) {`
		6397	`RESTORE_LEXER;`
		6398	`goto ZL1;`
		6399	`}`
		6400	`{`
		6401
		6402	`g_shtokname = &(ZId)->sh.shtok;`
		6403	`}`
		6404	`switch (CURRENT_TERMINAL) {`
		6405	`case 24:`
		6406	`break;`
		6407	`default:`
		6408	`goto ZL1;`
		6409	`}`
		6410	`ADVANCE_LEXER;`
		6411	`ZRshapetok ();`
		6412	`if ((CURRENT_TERMINAL) == 130) {`
		6413	`RESTORE_LEXER;`
		6414	`goto ZL1;`
		6415	`}`
		6416	`{`
		6417
		6418	`RESET_TDF((ZIc));`
		6419	`(ZId)->iscommon = 1;`
		6420	`o_common_tagdec(out_tdfint32(LOCNAME((ZId)->idname)),`
		6421	`if ((ZIa).no !=0) { OPTION(append_TDF(&(ZIa), 1)); },`
		6422	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		6423	`o_shape_apply_token(make_tok(&(ZId)->sh.shtok), {}));`
		6424	`INC_LIST;`
		6425	`(ZId)->next = tagdecs;`
		6426	`(ZId)->isvar = 1;`
		6427	`tagdecs = (ZId);`
		6428	`}`
		6429	`}`
		6430	`break;`
		6431	`case 53:`
		6432	`{`
		6433	`TDF ZIa;`
		6434	`TDF ZIb;`
		6435	`PTR_TDF ZIc;`
		6436	`PTR_Tagdec ZId;`
		6437
		6438	`ADVANCE_LEXER;`
		6439	`{`
		6440
		6441	`/* (ZIb) uninitialised */`
		6442	`char * n =lex_v.val.name;`
		6443	`(ZId) = find_tag(n);`
		6444	`if ((ZId) != (Tagdec*)0)fail("Tag %s declared twice", n);`
		6445	`SELECT_UNIT(tagdec_unit);`
		6446	`(ZId) = MALLOC(Tagdec); NEW_IDNAME((ZId)->idname, n, tag_ent);`
		6447	`(ZId)->isdeffed = 0; (ZId)->hassh = 1; (ZId)->iskept=0; (ZId)->iscommon=0;`
		6448	`(ZId)->isused = 0;`
		6449	`SET_TDF((ZIc), &(ZIa));`
		6450	`}`
		6451	`switch (CURRENT_TERMINAL) {`
		6452	`case 54:`
		6453	`break;`
		6454	`default:`
		6455	`goto ZL1;`
		6456	`}`
		6457	`ADVANCE_LEXER;`
		6458	`ZRaccess__opt ();`
		6459	`if ((CURRENT_TERMINAL) == 130) {`
		6460	`RESTORE_LEXER;`
		6461	`goto ZL1;`
		6462	`}`
		6463	`{`
		6464
		6465	`RESET_TDF((ZIc));`
		6466	`SET_TDF((ZIc), &(ZIb));`
		6467	`}`
		6468	`ZRsignature__opt ();`
		6469	`if ((CURRENT_TERMINAL) == 130) {`
		6470	`RESTORE_LEXER;`
		6471	`goto ZL1;`
		6472	`}`
		6473	`{`
		6474
		6475	`g_shtokname = &(ZId)->sh.shtok;`
		6476	`}`
		6477	`switch (CURRENT_TERMINAL) {`
		6478	`case 24:`
		6479	`break;`
		6480	`default:`
		6481	`goto ZL1;`
		6482	`}`
		6483	`ADVANCE_LEXER;`
		6484	`ZRshapetok ();`
		6485	`if ((CURRENT_TERMINAL) == 130) {`
		6486	`RESTORE_LEXER;`
		6487	`goto ZL1;`
		6488	`}`
		6489	`{`
		6490
		6491	`RESET_TDF((ZIc));`
		6492	`o_make_id_tagdec(out_tdfint32(LOCNAME((ZId)->idname)),`
		6493	`if ((ZIa).no !=0) { OPTION(append_TDF(&(ZIa), 1)); },`
		6494	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		6495	`o_shape_apply_token(make_tok(&(ZId)->sh.shtok), {}));`
		6496	`INC_LIST;`
		6497	`(ZId)->next = tagdecs;`
		6498	`(ZId)->isvar = 0;`
		6499	`tagdecs = (ZId);`
		6500	`}`
		6501	`}`
		6502	`break;`
		6503	`case 125:`
		6504	`{`
		6505	`TDF ZIa;`
		6506	`TDF ZIb;`
		6507	`PTR_TDF ZIc;`
		6508	`PTR_Tagdec ZId;`
		6509
		6510	`ADVANCE_LEXER;`
		6511	`{`
		6512
		6513	`/* (ZIb) uninitialised */`
		6514	`char * n =lex_v.val.name;`
		6515	`(ZId) = find_tag(n);`
		6516	`if ((ZId) != (Tagdec*)0)fail("Tag %s declared twice", n);`
		6517	`SELECT_UNIT(tagdec_unit);`
		6518	`(ZId) = MALLOC(Tagdec); NEW_IDNAME((ZId)->idname, n, tag_ent);`
		6519	`(ZId)->isdeffed = 0; (ZId)->hassh = 1; (ZId)->iskept=0; (ZId)->iscommon=0;`
		6520	`(ZId)->isused = 0;`
		6521	`SET_TDF((ZIc), &(ZIa));`
		6522	`}`
		6523	`switch (CURRENT_TERMINAL) {`
		6524	`case 54:`
		6525	`break;`
		6526	`default:`
		6527	`goto ZL1;`
		6528	`}`
		6529	`ADVANCE_LEXER;`
		6530	`ZRaccess__opt ();`
		6531	`if ((CURRENT_TERMINAL) == 130) {`
		6532	`RESTORE_LEXER;`
		6533	`goto ZL1;`
		6534	`}`
		6535	`{`
		6536
		6537	`RESET_TDF((ZIc));`
		6538	`SET_TDF((ZIc), &(ZIb));`
		6539	`}`
		6540	`ZRsignature__opt ();`
		6541	`if ((CURRENT_TERMINAL) == 130) {`
		6542	`RESTORE_LEXER;`
		6543	`goto ZL1;`
		6544	`}`
		6545	`{`
		6546
		6547	`g_shtokname = &(ZId)->sh.shtok;`
		6548	`}`
		6549	`switch (CURRENT_TERMINAL) {`
		6550	`case 24:`
		6551	`break;`
		6552	`default:`
		6553	`goto ZL1;`
		6554	`}`
		6555	`ADVANCE_LEXER;`
		6556	`ZRshapetok ();`
		6557	`if ((CURRENT_TERMINAL) == 130) {`
		6558	`RESTORE_LEXER;`
		6559	`goto ZL1;`
		6560	`}`
		6561	`{`
		6562
		6563	`RESET_TDF((ZIc));`
		6564	`o_make_var_tagdec(out_tdfint32(LOCNAME((ZId)->idname)),`
		6565	`if ((ZIa).no !=0) { OPTION(append_TDF(&(ZIa), 1)); },`
		6566	`if ((ZIb).no !=0) { OPTION(append_TDF(&(ZIb), 1)); },`
		6567	`o_shape_apply_token(make_tok(&(ZId)->sh.shtok), {}));`
		6568	`INC_LIST;`
		6569	`(ZId)->next = tagdecs;`
		6570	`(ZId)->isvar = 1;`
		6571	`tagdecs = (ZId);`
		6572	`}`
		6573	`}`
		6574	`break;`
		6575	`case 130:`
		6576	`return;`
		6577	`default:`
		6578	`goto ZL1;`
		6579	`}`
		6580	`return;`
		6581	`ZL1:;`
		6582	`SAVE_LEXER (130);`
		6583	`return;`
		6584	`}`
		6585
		6586	`static void`
		6587	`ZRtag__intro(void)`
		6588	`{`
		6589	`switch (CURRENT_TERMINAL) {`
		6590	`case 61:`
		6591	`{`
		6592	`TDF ZIa;`
		6593	`TDF ZIb;`
		6594	`PTR_TDF ZIc;`
		6595	`PTR_Tagdec ZId;`
		6596	`int ZIe;`
		6597
		6598	`ADVANCE_LEXER;`
		6599	`{`
		6600
		6601	`/* (ZIb), (ZIe) uninitialised */`
		6602	`char* n = lex_v.val.name;`
		6603	`(ZId) = find_tag(n);`
		6604	`if ((ZId) != (Tagdec*)0) { fail("Tag %s declared twice", n); }`
		6605	`(ZId) = MALLOC(Tagdec); (ZId)->isdeffed = 1; (ZId)->hassh=0; (ZId)->iskept=0;`
		6606	`NEW_IDNAME((ZId)->idname, n, tag_ent);`
		6607	`g_has_vis = 0;`
		6608	`SET_TDF((ZIc), &(ZIa));`
		6609	`}`
		6610	`switch (CURRENT_TERMINAL) {`
		6611	`case 54:`
		6612	`break;`
		6613	`default:`
		6614	`goto ZL1;`
		6615	`}`
		6616	`ADVANCE_LEXER;`
		6617	`ZRaccess__opt ();`
		6618	`if ((CURRENT_TERMINAL) == 130) {`
		6619	`RESTORE_LEXER;`
		6620	`goto ZL1;`
		6621	`}`
		6622	`{`
		6623
		6624	`RESET_TDF((ZIc));`
		6625	`SET_TDF((ZIc), &(ZIb));`
		6626	`(ZIe) = g_has_vis;`
		6627	`}`
		6628	`switch (CURRENT_TERMINAL) {`
		6629	`case 36:`
		6630	`break;`
		6631	`default:`
		6632	`goto ZL1;`
		6633	`}`
		6634	`ADVANCE_LEXER;`
		6635	`read_exp ();`
		6636	`if ((CURRENT_TERMINAL) == 130) {`
		6637	`RESTORE_LEXER;`
		6638	`goto ZL1;`
		6639	`}`
		6640	`{`
		6641
		6642	`RESET_TDF((ZIc));`
		6643	`intro_acc = (ZIa);`
		6644	`intro_init = (ZIb);`
		6645	`(ZId)->isvar=0;`
		6646	`if ((ZIe)) {`
		6647	`Tagdec * y = MALLOC(Tagdec);`
		6648	`y = (ZId);`
		6649	`y->next = tagdecs;`
		6650	`tagdecs = y;`
		6651	`}`
		6652	`(ZId)->next = localdecs;`
		6653	`localdecs = (ZId);`
		6654	`}`
		6655	`}`
		6656	`break;`
		6657	`case 124:`
		6658	`{`
		6659	`TDF ZIa;`
		6660	`TDF ZIb;`
		6661	`PTR_TDF ZIc;`
		6662	`PTR_Tagdec ZId;`
		6663	`int ZIe;`
		6664
		6665	`ADVANCE_LEXER;`
		6666	`{`
		6667
		6668	`/* (ZIb), (ZIe) uninitialised */`
		6669	`char* n = lex_v.val.name;`
		6670	`(ZId) = find_tag(n);`
		6671	`if ((ZId) != (Tagdec*)0) { fail("Tag %s declared twice", n); }`
		6672	`(ZId) = MALLOC(Tagdec); (ZId)->isdeffed = 1; (ZId)->hassh=0; (ZId)->iskept=0;`
		6673	`NEW_IDNAME((ZId)->idname, n, tag_ent);`
		6674	`g_has_vis = 0;`
		6675	`SET_TDF((ZIc), &(ZIa));`
		6676	`}`
		6677	`switch (CURRENT_TERMINAL) {`
		6678	`case 54:`
		6679	`break;`
		6680	`default:`
		6681	`goto ZL1;`
		6682	`}`
		6683	`ADVANCE_LEXER;`
		6684	`ZRaccess__opt ();`
		6685	`ZR669 (&ZIa, &ZIb, &ZIc, &ZId, &ZIe);`
		6686	`if ((CURRENT_TERMINAL) == 130) {`
		6687	`RESTORE_LEXER;`
		6688	`goto ZL1;`
		6689	`}`
		6690	`}`
		6691	`break;`
		6692	`case 130:`
		6693	`return;`
		6694	`default:`
		6695	`goto ZL1;`
		6696	`}`
		6697	`return;`
		6698	`ZL1:;`
		6699	`SAVE_LEXER (130);`
		6700	`return;`
		6701	`}`
		6702
		6703	`void`
		6704	`read_exp(void)`
		6705	`{`
		6706	`if ((CURRENT_TERMINAL) == 130) {`
		6707	`return;`
		6708	`}`
		6709	`{`
		6710	`TDF ZIa;`
		6711	`PTR_TDF ZIb;`
		6712	`int ZIc;`
		6713	`unsigned_long ZId;`
		6714	`int ZIe;`
		6715
		6716	`{`
		6717
		6718	`(ZIc) = (current_TDF->first == current_TDF->last &&`
		6719	`current_TDF->first->usage == 0 &&`
		6720	`current_TDF->first->offst == 0);`
		6721	`(ZId) = cLINE;`
		6722	`(ZIe) = bind;`
		6723	`if (!(ZIc) \|\| line_no_tok != -1) { SET_TDF((ZIb), &(ZIa)); }`
		6724	`}`
		6725	`ZRexp__body ();`
		6726	`if ((CURRENT_TERMINAL) == 130) {`
		6727	`RESTORE_LEXER;`
		6728	`goto ZL1;`
		6729	`}`
		6730	`{`
		6731
		6732	`if (!(ZIc) \|\| line_no_tok != -1) {`
		6733	`SET((ZIb));`
		6734	`RESET_TDF((ZIb));`
		6735	`if (line_no_tok != -1) {`
		6736	`o_exp_apply_token(`
		6737	`o_make_tok(out_tdfint32(UL(cname_to_lname(line_no_tok,tok_ent)))),`
		6738	`{ append_TDF(&(ZIa),1);`
		6739	`o_make_sourcemark(FILENAME(),`
		6740	`o_make_nat(out_tdfint32((ZId))),`
		6741	`o_make_nat(out_tdfint32(UL((ZIe)))));`
		6742	`o_make_sourcemark(FILENAME(),`
		6743	`o_make_nat(out_tdfint32(cLINE)),`
		6744	`o_make_nat(out_tdfint32(UL(bind))));`
		6745	`});`
		6746	`} else append_TDF(&(ZIa),1);`
		6747	`}`
		6748	`}`
		6749	`}`
		6750	`return;`
		6751	`ZL1:;`
		6752	`{`
		6753	`{`
		6754
		6755	`fail("Syntax error");`
		6756	`}`
		6757	`}`
		6758	`}`
		6759
		6760	`static void`
		6761	`ZRtag__def(void)`
		6762	`{`
		6763	`switch (CURRENT_TERMINAL) {`
		6764	`case 26:`
		6765	`{`
		6766	`TDF ZIa;`
		6767	`TDF ZIb;`
		6768	`PTR_TDF ZIc;`
		6769	`PTR_Tagdec ZId;`
		6770	`PTR_char ZIe;`
		6771	`int ZIf;`
		6772
		6773	`ADVANCE_LEXER;`
		6774	`{`
		6775
		6776	`/* (ZIa) uninitialised */`
		6777	`(ZIe) =lex_v.val.name;`
		6778	`(ZId) = find_tag((ZIe));`
		6779	`SELECT_UNIT(tagdef_unit);`
		6780	`if ((ZId)!= (Tagdec*)0) {`
		6781	`if ((ZId)->isdeffed && !(ZId)->iscommon)fail("Tag %s defined twice", (ZIe));`
		6782	`if (!(ZId)->isvar)fail("Tag %s declared as non-variable", (ZIe));`
		6783	`(ZIf) = 1;`
		6784	`} else {`
		6785	`(ZId) = MALLOC(Tagdec);`
		6786	`(ZId)->hassh = 0; (ZId)->isvar=1; (ZId)->iskept=0; (ZId)->iscommon = 0;`
		6787	`(ZId)->isused=0;`
		6788	`NEW_IDNAME((ZId)->idname, (ZIe), tag_ent);`
		6789	`(ZIf)=0;`
		6790	`}`
		6791	`SET_TDF((ZIc), &(ZIb));`
		6792	`}`
		6793	`switch (CURRENT_TERMINAL) {`
		6794	`case 54:`
		6795	`break;`
		6796	`default:`
		6797	`goto ZL1;`
		6798	`}`
		6799	`ADVANCE_LEXER;`
		6800	`ZRsignature__opt ();`
		6801	`ZR678 (&ZIa, &ZIb, &ZIc, &ZId, &ZIe, &ZIf);`
		6802	`if ((CURRENT_TERMINAL) == 130) {`
		6803	`RESTORE_LEXER;`
		6804	`goto ZL1;`
		6805	`}`
		6806	`}`
		6807	`break;`
		6808	`case 61:`
		6809	`{`
		6810	`TDF ZIa;`
		6811	`TDF ZIb;`
		6812	`PTR_TDF ZIc;`
		6813	`PTR_Tagdec ZId;`
		6814	`PTR_char ZIe;`
		6815	`int ZIf;`
		6816
		6817	`ADVANCE_LEXER;`
		6818	`{`
		6819
		6820	`/* (ZIa) uninitialised */`
		6821	`(ZIe) =lex_v.val.name;`
		6822	`(ZId) = find_tag((ZIe));`
		6823	`SELECT_UNIT(tagdef_unit);`
		6824	`if ((ZId)!= (Tagdec*)0) {`
		6825	`if ((ZId)->isdeffed && !(ZId)->iscommon)fail("Tag %s defined twice", (ZIe));`
		6826	`if ((ZId)->isvar)fail("Tag %s declared as variable", (ZIe));`
		6827	`(ZIf) = 1;`
		6828	`} else {`
		6829	`(ZId) = MALLOC(Tagdec);`
		6830	`(ZId)->hassh = 0; (ZId)->isvar=0; (ZId)->iskept=0; (ZId)->iscommon = 0;`
		6831	`(ZId)->isused = 0;`
		6832	`NEW_IDNAME((ZId)->idname, (ZIe), tag_ent);`
		6833	`(ZIf) = 0;`
		6834	`}`
		6835	`SET_TDF((ZIc), &(ZIb));`
		6836	`}`
		6837	`switch (CURRENT_TERMINAL) {`
		6838	`case 54:`
		6839	`break;`
		6840	`default:`
		6841	`goto ZL1;`
		6842	`}`
		6843	`ADVANCE_LEXER;`
		6844	`ZRsignature__opt ();`
		6845	`ZR679 (&ZIa, &ZIb, &ZIc, &ZId, &ZIe, &ZIf);`
		6846	`if ((CURRENT_TERMINAL) == 130) {`
		6847	`RESTORE_LEXER;`
		6848	`goto ZL1;`
		6849	`}`
		6850	`}`
		6851	`break;`
		6852	`case 106:`
		6853	`{`
		6854	`TDF ZIa;`
		6855	`TDF ZIb;`
		6856	`PTR_TDF ZIc;`
		6857	`PTR_Tagdec ZId;`
		6858	`PTR_char ZIe;`
		6859	`int ZIf;`
		6860	`TDF ZIg;`
		6861	`PTR_char ZIh;`
		6862
		6863	`ADVANCE_LEXER;`
		6864	`{`
		6865
		6866	`/* (ZIa) uninitialised */`
		6867	`(ZIe) =lex_v.val.name;`
		6868	`(ZId) = find_tag((ZIe));`
		6869	`SELECT_UNIT(tagdef_unit);`
		6870	`if ((ZId)!= (Tagdec*)0) {`
		6871	`if ((ZId)->isdeffed && !(ZId)->iscommon)fail("Tag %s defined twice", (ZIe));`
		6872	`if (!(ZId)->isvar)fail("Tag %s declared as non-variable", (ZIe));`
		6873	`(ZIf) = 1;`
		6874	`} else {`
		6875	`(ZId) = MALLOC(Tagdec);`
		6876	`(ZId)->hassh = 0; (ZId)->isvar=1; (ZId)->iskept=0; (ZId)->iscommon = 0;`
		6877	`(ZId)->isused=0;`
		6878	`NEW_IDNAME((ZId)->idname, (ZIe), tag_ent);`
		6879	`(ZIf)=0;`
		6880	`}`
		6881	`SET_TDF((ZIc), &(ZIb));`
		6882	`}`
		6883	`switch (CURRENT_TERMINAL) {`
		6884	`case 54:`
		6885	`break;`
		6886	`default:`
		6887	`goto ZL1;`
		6888	`}`
		6889	`ADVANCE_LEXER;`
		6890	`ZRsignature__opt ();`
		6891	`if ((CURRENT_TERMINAL) == 130) {`
		6892	`RESTORE_LEXER;`
		6893	`goto ZL1;`
		6894	`}`
		6895	`{`
		6896
		6897	`RESET_TDF((ZIc));`
		6898	`SET_TDF((ZIc), &(ZIg));`
		6899	`}`
		6900	`ZRvariety__opt ();`
		6901	`switch (CURRENT_TERMINAL) {`
		6902	`case 36:`
		6903	`break;`
		6904	`case 130:`
		6905	`RESTORE_LEXER;`
		6906	`goto ZL1;`
		6907	`default:`
		6908	`goto ZL1;`
		6909	`}`
		6910	`ADVANCE_LEXER;`
		6911	`{`
		6912
		6913	`(ZIh) = lex_v.val.name;`
		6914	`if ((ZId)->hassh)fail("Two declaration shapes for %s", (ZIe));`
		6915	`RESET_TDF((ZIc));`
		6916	`SET_TDF((ZIc), &(ZIa));`
		6917	`o_make_nof_int(append_TDF(&(ZIg), 0),`
		6918	`o_make_string(out_tdfstring_bytes((ZIh), 8, UI(strlen((ZIh)) +1))));`
		6919	`}`
		6920	`switch (CURRENT_TERMINAL) {`
		6921	`case 85:`
		6922	`break;`
		6923	`default:`
		6924	`goto ZL1;`
		6925	`}`
		6926	`ADVANCE_LEXER;`
		6927	`{`
		6928
		6929	`RESET_TDF((ZIc));`
		6930	`o_make_var_tagdef(out_tdfint32(UL(local_name(&(ZId)->idname.name, tag_ent))),`
		6931	`{}, {}, append_TDF(&(ZIa), 1));`
		6932	`INC_LIST;`
		6933	`SELECT_UNIT(tagdec_unit);`
		6934	`if (!(ZIf)) {`
		6935	`o_make_var_tagdec(out_tdfint32(UL(non_local(&(ZId)->idname.name,tag_ent))),`
		6936	`{}, {},`
		6937	`o_nof(o_make_nat(out_tdfint32(UL(strlen((ZIh)) +1))),`
		6938	`o_integer(append_TDF(&(ZIg), 0))));`
		6939	`INC_LIST;`
		6940	`}`
		6941	`(ZId)->isdeffed=1;`
		6942	`if (!(ZIf)) { (ZId)->next = tagdecs; tagdecs = (ZId); }`
		6943	`}`
		6944	`}`
		6945	`break;`
		6946	`case 124:`
		6947	`{`
		6948	`TDF ZIa;`
		6949	`TDF ZIb;`
		6950	`PTR_TDF ZIc;`
		6951	`PTR_Tagdec ZId;`
		6952	`PTR_char ZIe;`
		6953	`int ZIf;`
		6954
		6955	`ADVANCE_LEXER;`
		6956	`{`
		6957
		6958	`/* (ZIa) uninitialised */`
		6959	`(ZIe) =lex_v.val.name;`
		6960	`(ZId) = find_tag((ZIe));`
		6961	`SELECT_UNIT(tagdef_unit);`
		6962	`if ((ZId)!= (Tagdec*)0) {`
		6963	`if ((ZId)->isdeffed && !(ZId)->iscommon)fail("Tag %s defined twice", (ZIe));`
		6964	`if (!(ZId)->isvar)fail("Tag %s declared as non-variable", (ZIe));`
		6965	`(ZIf) = 1;`
		6966	`} else {`
		6967	`(ZId) = MALLOC(Tagdec);`
		6968	`(ZId)->hassh = 0; (ZId)->isvar=1; (ZId)->iskept=0; (ZId)->iscommon = 0;`
		6969	`(ZId)->isused=0;`
		6970	`NEW_IDNAME((ZId)->idname, (ZIe), tag_ent);`
		6971	`(ZIf)=0;`
		6972	`}`
		6973	`SET_TDF((ZIc), &(ZIb));`
		6974	`}`
		6975	`switch (CURRENT_TERMINAL) {`
		6976	`case 54:`
		6977	`break;`
		6978	`default:`
		6979	`goto ZL1;`
		6980	`}`
		6981	`ADVANCE_LEXER;`
		6982	`ZRsignature__opt ();`
		6983	`ZR677 (&ZIa, &ZIb, &ZIc, &ZId, &ZIe, &ZIf);`
		6984	`if ((CURRENT_TERMINAL) == 130) {`
		6985	`RESTORE_LEXER;`
		6986	`goto ZL1;`
		6987	`}`
		6988	`}`
		6989	`break;`
		6990	`case 130:`
		6991	`return;`
		6992	`default:`
		6993	`goto ZL1;`
		6994	`}`
		6995	`return;`
		6996	`ZL1:;`
		6997	`SAVE_LEXER (130);`
		6998	`return;`
		6999	`}`
		7000
		7001	`static void`
		7002	`ZRotagexp__list__opt(void)`
		7003	`{`
		7004	`switch (CURRENT_TERMINAL) {`
		7005	`case 10: case 19: case 22: case 28: case 41:`
		7006	`case 42: case 43: case 44: case 45: case 52:`
		7007	`case 54: case 55: case 58: case 61: case 62:`
		7008	`case 68: case 76: case 77: case 78: case 79:`
		7009	`case 81: case 82: case 84: case 85: case 86:`
		7010	`case 88: case 98: case 99: case 100: case 102:`
		7011	`case 103: case 104: case 105: case 107: case 109:`
		7012	`case 110: case 111: case 124:`
		7013	`{`
		7014	`ZRotagexp__list ();`
		7015	`if ((CURRENT_TERMINAL) == 130) {`
		7016	`RESTORE_LEXER;`
		7017	`goto ZL1;`
		7018	`}`
		7019	`}`
		7020	`break;`
		7021	`default:`
		7022	`{`
		7023	`{`
		7024
		7025	`current_TDF->no = 0;`
		7026	`}`
		7027	`}`
		7028	`break;`
		7029	`case 130:`
		7030	`return;`
		7031	`}`
		7032	`return;`
		7033	`ZL1:;`
		7034	`SAVE_LEXER (130);`
		7035	`return;`
		7036	`}`
		7037
		7038	`static void`
		7039	`ZRtok__formal__list(void)`
		7040	`{`
		7041	`if ((CURRENT_TERMINAL) == 130) {`
		7042	`return;`
		7043	`}`
		7044	`{`
		7045	`PTR_Tokdec ZIa;`
		7046
		7047	`{`
		7048
		7049	`char * n = lex_v.val.name;`
		7050	`(ZIa) = find_tok(n);`
		7051	`if ((ZIa)!= (Tokdec*)0)fail("Token parameter name %s must be unique", n);`
		7052	`(ZIa) = MALLOC(Tokdec); NEW_IDNAME((ZIa)->idname, n, tok_ent);`
		7053	`(ZIa)->isdeffed = 1; (ZIa)->isused = 0; (ZIa)->iskept=0;`
		7054	`(ZIa)->next = (Tokdec*)0;`
		7055	`}`
		7056	`switch (CURRENT_TERMINAL) {`
		7057	`case 54:`
		7058	`break;`
		7059	`default:`
		7060	`goto ZL1;`
		7061	`}`
		7062	`ADVANCE_LEXER;`
		7063	`switch (CURRENT_TERMINAL) {`
		7064	`case 24:`
		7065	`break;`
		7066	`default:`
		7067	`goto ZL1;`
		7068	`}`
		7069	`ADVANCE_LEXER;`
		7070	`ZRfull__sortname ();`
		7071	`if ((CURRENT_TERMINAL) == 130) {`
		7072	`RESTORE_LEXER;`
		7073	`goto ZL1;`
		7074	`}`
		7075	`{`
		7076
		7077	`(ZIa)->sort.ressort = g_sname;`
		7078	`(ZIa)->sort.pars = (Tokpar)0; / no pars in formal pars */`
		7079	`g_tokformals = (ZIa);`
		7080	`}`
		7081	`ZR629 ();`
		7082	`if ((CURRENT_TERMINAL) == 130) {`
		7083	`RESTORE_LEXER;`
		7084	`goto ZL1;`
		7085	`}`
		7086	`}`
		7087	`return;`
		7088	`ZL1:;`
		7089	`SAVE_LEXER (130);`
		7090	`return;`
		7091	`}`
		7092
		7093	`static void`
		7094	`ZRuntidy__opt(void)`
		7095	`{`
		7096	`switch (CURRENT_TERMINAL) {`
		7097	`case 23:`
		7098	`{`
		7099	`ADVANCE_LEXER;`
		7100	`{`
		7101
		7102	`g_unt = 2;`
		7103	`}`
		7104	`}`
		7105	`break;`
		7106	`case 122:`
		7107	`{`
		7108	`ADVANCE_LEXER;`
		7109	`ZR657 ();`
		7110	`if ((CURRENT_TERMINAL) == 130) {`
		7111	`RESTORE_LEXER;`
		7112	`goto ZL1;`
		7113	`}`
		7114	`}`
		7115	`break;`
		7116	`default:`
		7117	`{`
		7118	`{`
		7119
		7120	`g_unt = 0;`
		7121	`}`
		7122	`}`
		7123	`break;`
		7124	`case 130:`
		7125	`return;`
		7126	`}`
		7127	`return;`
		7128	`ZL1:;`
		7129	`SAVE_LEXER (130);`
		7130	`return;`
		7131	`}`
		7132
		7133	`static void`
		7134	`ZRcaller__var__opt(void)`
		7135	`{`
		7136	`switch (CURRENT_TERMINAL) {`
		7137	`case 31:`
		7138	`{`
		7139	`ADVANCE_LEXER;`
		7140	`{`
		7141
		7142	`g_cr_v = 1;`
		7143	`}`
		7144	`}`
		7145	`break;`
		7146	`default:`
		7147	`{`
		7148	`{`
		7149
		7150	`g_cr_v = 0;`
		7151	`}`
		7152	`}`
		7153	`break;`
		7154	`case 130:`
		7155	`return;`
		7156	`}`
		7157	`}`
		7158
		7159	`static void`
		7160	`ZRproc__def__body(void)`
		7161	`{`
		7162	`switch (CURRENT_TERMINAL) {`
		7163	`case 50:`
		7164	`{`
		7165	`TDF ZIa;`
		7166	`TDF ZIb;`
		7167	`TDF ZIc;`
		7168	`TDF ZId;`
		7169	`PTR_TDF ZIe;`
		7170	`int ZIf;`
		7171	`int ZIg;`
		7172	`int ZIh;`
		7173	`PTR_Tagdec ZIi;`
		7174	`PTR_Labdec ZIj;`
		7175
		7176	`ADVANCE_LEXER;`
		7177	`{`
		7178
		7179	`/* (ZIb), (ZIc), (ZId) uninitialised */`
		7180	`/* (ZIf), (ZIg) (ZIh) uninitialised */`
		7181	`(ZIi) = localdecs;`
		7182	`(ZIj) = labdecs;`
		7183	`localdecs = (Tagdec*)0;`
		7184	`labdecs = (Labdec *)0;`
		7185	`SET_TDF((ZIe), &(ZIa));`
		7186	`}`
		7187	`read_shape ();`
		7188	`if ((CURRENT_TERMINAL) == 130) {`
		7189	`RESTORE_LEXER;`
		7190	`goto ZL1;`
		7191	`}`
		7192	`{`
		7193
		7194	`RESET_TDF((ZIe));`
		7195	`SET_TDF((ZIe), &(ZIb));`
		7196	`}`
		7197	`switch (CURRENT_TERMINAL) {`
		7198	`case 78:`
		7199	`break;`
		7200	`default:`
		7201	`goto ZL1;`
		7202	`}`
		7203	`ADVANCE_LEXER;`
		7204	`ZRtagshacc__list__opt ();`
		7205	`ZRcaller__var__opt ();`
		7206	`if ((CURRENT_TERMINAL) == 130) {`
		7207	`RESTORE_LEXER;`
		7208	`goto ZL1;`
		7209	`}`
		7210	`{`
		7211
		7212	`RESET_TDF((ZIe));`
		7213	`SET_TDF((ZIe), &(ZIc));`
		7214	`(ZIf) = g_cr_v;`
		7215	`}`
		7216	`switch (CURRENT_TERMINAL) {`
		7217	`case 93:`
		7218	`break;`
		7219	`default:`
		7220	`goto ZL1;`
		7221	`}`
		7222	`ADVANCE_LEXER;`
		7223	`ZRtagshacc__list__opt ();`
		7224	`ZRcallee__var__opt ();`
		7225	`if ((CURRENT_TERMINAL) == 130) {`
		7226	`RESTORE_LEXER;`
		7227	`goto ZL1;`
		7228	`}`
		7229	`{`
		7230
		7231	`RESET_TDF((ZIe));`
		7232	`SET_TDF((ZIe), &(ZId));`
		7233	`(ZIg) = g_ce_v;`
		7234	`}`
		7235	`switch (CURRENT_TERMINAL) {`
		7236	`case 29:`
		7237	`break;`
		7238	`default:`
		7239	`goto ZL1;`
		7240	`}`
		7241	`ADVANCE_LEXER;`
		7242	`ZRuntidy__opt ();`
		7243	`if ((CURRENT_TERMINAL) == 130) {`
		7244	`RESTORE_LEXER;`
		7245	`goto ZL1;`
		7246	`}`
		7247	`{`
		7248
		7249	`(ZIh) = g_unt;`
		7250	`}`
		7251	`ZRclosed__exp ();`
		7252	`if ((CURRENT_TERMINAL) == 130) {`
		7253	`RESTORE_LEXER;`
		7254	`goto ZL1;`
		7255	`}`
		7256	`{`
		7257
		7258	`RESET_TDF((ZIe));`
		7259	`o_make_general_proc(append_TDF(&(ZIa),1),`
		7260	`do_procprops((ZIf)+2(ZIg)+4(ZIh)),`
		7261	`{ append_TDF(&(ZIb),1);`
		7262	`current_TDF->no = (ZIb).no;},`
		7263	`{ append_TDF(&(ZIc),1);`
		7264	`current_TDF->no = (ZIc).no;},`
		7265	`append_TDF(&(ZId),1))`
		7266	`while (labdecs != (Labdec *)0) {`
		7267	`if (!labdecs->declared) {`
		7268	`fail("Label %s not declared", labdecs->idname.id);`
		7269	`}`
		7270	`labdecs = labdecs->next;`
		7271	`}`
		7272	`localdecs = (ZIi);`
		7273	`labdecs = (ZIj);`
		7274	`}`
		7275	`}`
		7276	`break;`
		7277	`case 21: case 32: case 46: case 56: case 64:`
		7278	`case 83: case 94: case 95: case 96: case 97:`
		7279	`case 101: case 121:`
		7280	`{`
		7281	`TDF ZIa;`
		7282	`TDF ZIb;`
		7283	`TDF ZIc;`
		7284	`TDF ZId;`
		7285	`PTR_TDF ZIe;`
		7286	`PTR_Tagdec ZIf;`
		7287	`PTR_Labdec ZIg;`
		7288
		7289	`{`
		7290
		7291	`/* (ZIa), (ZIb), (ZIc) uninitialised */`
		7292	`(ZIf) = localdecs;`
		7293	`(ZIg) = labdecs;`
		7294	`localdecs = (Tagdec*)0;`
		7295	`labdecs = (Labdec *)0;`
		7296	`SET_TDF((ZIe), &(ZId));`
		7297	`}`
		7298	`read_shape ();`
		7299	`if ((CURRENT_TERMINAL) == 130) {`
		7300	`RESTORE_LEXER;`
		7301	`goto ZL1;`
		7302	`}`
		7303	`{`
		7304
		7305	`RESET_TDF((ZIe));`
		7306	`SET_TDF((ZIe), &(ZIa))`
		7307	`}`
		7308	`switch (CURRENT_TERMINAL) {`
		7309	`case 78:`
		7310	`break;`
		7311	`default:`
		7312	`goto ZL1;`
		7313	`}`
		7314	`ADVANCE_LEXER;`
		7315	`ZRtagshacc__list__opt ();`
		7316	`if ((CURRENT_TERMINAL) == 130) {`
		7317	`RESTORE_LEXER;`
		7318	`goto ZL1;`
		7319	`}`
		7320	`{`
		7321
		7322	`RESET_TDF((ZIe));`
		7323	`SET_TDF((ZIe), &(ZIb));`
		7324	`}`
		7325	`ZRvarintro__opt ();`
		7326	`if ((CURRENT_TERMINAL) == 130) {`
		7327	`RESTORE_LEXER;`
		7328	`goto ZL1;`
		7329	`}`
		7330	`{`
		7331
		7332	`RESET_TDF((ZIe));`
		7333	`SET_TDF((ZIe), &(ZIc));`
		7334	`}`
		7335	`switch (CURRENT_TERMINAL) {`
		7336	`case 29:`
		7337	`break;`
		7338	`default:`
		7339	`goto ZL1;`
		7340	`}`
		7341	`ADVANCE_LEXER;`
		7342	`ZRclosed__exp ();`
		7343	`if ((CURRENT_TERMINAL) == 130) {`
		7344	`RESTORE_LEXER;`
		7345	`goto ZL1;`
		7346	`}`
		7347	`{`
		7348
		7349	`RESET_TDF((ZIe));`
		7350	`o_make_proc(append_TDF(&(ZId),1),`
		7351	`{ append_TDF(&(ZIa),1); current_TDF->no = (ZIa).no;},`
		7352	`if ((ZIb).no !=0) {OPTION(append_TDF(&(ZIb),1)); },`
		7353	`append_TDF(&(ZIc),1);)`
		7354	`while (labdecs != (Labdec *)0) {`
		7355	`if (!labdecs->declared) {`
		7356	`fail("Label %s not declared", labdecs->idname.id);`
		7357	`}`
		7358	`labdecs = labdecs->next;`
		7359	`}`
		7360	`localdecs = (ZIf);`
		7361	`labdecs = (ZIg);`
		7362	`}`
		7363	`}`
		7364	`break;`
		7365	`case 130:`
		7366	`return;`
		7367	`default:`
		7368	`goto ZL1;`
		7369	`}`
		7370	`return;`
		7371	`ZL1:;`
		7372	`SAVE_LEXER (130);`
		7373	`return;`
		7374	`}`
		7375
		7376	`static void`
		7377	`ZRlabelled__list(void)`
		7378	`{`
		7379	`if ((CURRENT_TERMINAL) == 130) {`
		7380	`return;`
		7381	`}`
		7382	`{`
		7383	`TDF ZIa;`
		7384	`PTR_TDF ZIb;`
		7385
		7386	`switch (CURRENT_TERMINAL) {`
		7387	`case 24:`
		7388	`break;`
		7389	`default:`
		7390	`goto ZL1;`
		7391	`}`
		7392	`ADVANCE_LEXER;`
		7393	`{`
		7394
		7395	`(ZIb) = current_TDF;`
		7396	`INIT_TDF(&(ZIa));`
		7397	`current_TDF = &g_lablist;`
		7398	`}`
		7399	`read_label ();`
		7400	`if ((CURRENT_TERMINAL) == 130) {`
		7401	`RESTORE_LEXER;`
		7402	`goto ZL1;`
		7403	`}`
		7404	`{`
		7405
		7406	`if (g_labdec != (Labdec*)0) {`
		7407	`if (g_labdec->declared) {`
		7408	`fail("Label %s set twice", g_labdec->idname.id);`
		7409	`}`
		7410	`g_labdec->declared = 1;`
		7411	`}`
		7412	`current_TDF = &(ZIa);`
		7413	`}`
		7414	`switch (CURRENT_TERMINAL) {`
		7415	`case 24:`
		7416	`break;`
		7417	`default:`
		7418	`goto ZL1;`
		7419	`}`
		7420	`ADVANCE_LEXER;`
		7421	`ZRexp__sequence ();`
		7422	`if ((CURRENT_TERMINAL) == 130) {`
		7423	`RESTORE_LEXER;`
		7424	`goto ZL1;`
		7425	`}`
		7426	`{`
		7427
		7428	`RESET_TDF((ZIb));`
		7429	`append_TDF(&(ZIa), 1);`
		7430	`}`
		7431	`ZR668 ();`
		7432	`if ((CURRENT_TERMINAL) == 130) {`
		7433	`RESTORE_LEXER;`
		7434	`goto ZL1;`
		7435	`}`
		7436	`}`
		7437	`return;`
		7438	`ZL1:;`
		7439	`SAVE_LEXER (130);`
		7440	`return;`
		7441	`}`
		7442
		7443	`static void`
		7444	`ZRoffset__exp__list(void)`
		7445	`{`
		7446	`if ((CURRENT_TERMINAL) == 130) {`
		7447	`return;`
		7448	`}`
		7449	`{`
		7450	`read_exp ();`
		7451	`switch (CURRENT_TERMINAL) {`
		7452	`case 24:`
		7453	`break;`
		7454	`case 130:`
		7455	`RESTORE_LEXER;`
		7456	`goto ZL1;`
		7457	`default:`
		7458	`goto ZL1;`
		7459	`}`
		7460	`ADVANCE_LEXER;`
		7461	`read_exp ();`
		7462	`ZR663 ();`
		7463	`if ((CURRENT_TERMINAL) == 130) {`
		7464	`RESTORE_LEXER;`
		7465	`goto ZL1;`
		7466	`}`
		7467	`}`
		7468	`return;`
		7469	`ZL1:;`
		7470	`SAVE_LEXER (130);`
		7471	`return;`
		7472	`}`
		7473
		7474	`static void`
		7475	`ZRbitfield__sign(void)`
		7476	`{`
		7477	`switch (CURRENT_TERMINAL) {`
		7478	`case 16: case 17: case 18:`
		7479	`{`
		7480	`read_bool ();`
		7481	`if ((CURRENT_TERMINAL) == 130) {`
		7482	`RESTORE_LEXER;`
		7483	`goto ZL1;`
		7484	`}`
		7485	`}`
		7486	`break;`
		7487	`default:`
		7488	`{`
		7489	`ZRvariety__sign ();`
		7490	`if ((CURRENT_TERMINAL) == 130) {`
		7491	`RESTORE_LEXER;`
		7492	`goto ZL1;`
		7493	`}`
		7494	`{`
		7495
		7496	`if (issigned) { o_true; }`
		7497	`else { o_false; }`
		7498	`}`
		7499	`}`
		7500	`break;`
		7501	`case 130:`
		7502	`return;`
		7503	`}`
		7504	`return;`
		7505	`ZL1:;`
		7506	`SAVE_LEXER (130);`
		7507	`return;`
		7508	`}`
		7509
		7510	`static void`
		7511	`ZRtok__dec(void)`
		7512	`{`
		7513	`if ((CURRENT_TERMINAL) == 130) {`
		7514	`return;`
		7515	`}`
		7516	`{`
		7517	`TDF ZIa;`
		7518	`PTR_TDF ZIb;`
		7519	`PTR_Tokdec ZIc;`
		7520
		7521	`switch (CURRENT_TERMINAL) {`
		7522	`case 113:`
		7523	`break;`
		7524	`default:`
		7525	`goto ZL1;`
		7526	`}`
		7527	`ADVANCE_LEXER;`
		7528	`{`
		7529
		7530	`char *n = lex_v.val.name;`
		7531	`(ZIc) = find_tok(n);`
		7532	`if ((ZIc) != (Tokdec *)0)fail("Token %s declared twice", n);`
		7533	`SELECT_UNIT(tokdec_unit);`
		7534	`(ZIc) = MALLOC(Tokdec);`
		7535	`NEW_IDNAME((ZIc)->idname, n, tok_ent);`
		7536	`SET_TDF((ZIb), &(ZIa));`
		7537	`}`
		7538	`switch (CURRENT_TERMINAL) {`
		7539	`case 54:`
		7540	`break;`
		7541	`default:`
		7542	`goto ZL1;`
		7543	`}`
		7544	`ADVANCE_LEXER;`
		7545	`ZRsignature__opt ();`
		7546	`switch (CURRENT_TERMINAL) {`
		7547	`case 24:`
		7548	`break;`
		7549	`case 130:`
		7550	`RESTORE_LEXER;`
		7551	`goto ZL1;`
		7552	`default:`
		7553	`goto ZL1;`
		7554	`}`
		7555	`ADVANCE_LEXER;`
		7556	`switch (CURRENT_TERMINAL) {`
		7557	`case 79:`
		7558	`break;`
		7559	`default:`
		7560	`goto ZL1;`
		7561	`}`
		7562	`ADVANCE_LEXER;`
		7563	`ZRsortname__list__opt ();`
		7564	`switch (CURRENT_TERMINAL) {`
		7565	`case 30:`
		7566	`break;`
		7567	`case 130:`
		7568	`RESTORE_LEXER;`
		7569	`goto ZL1;`
		7570	`default:`
		7571	`goto ZL1;`
		7572	`}`
		7573	`ADVANCE_LEXER;`
		7574	`ZRfull__sortname ();`
		7575	`if ((CURRENT_TERMINAL) == 130) {`
		7576	`RESTORE_LEXER;`
		7577	`goto ZL1;`
		7578	`}`
		7579	`{`
		7580
		7581	`RESET_TDF((ZIb));`
		7582	`(ZIc)->sort.ressort = g_sname;`
		7583	`(ZIc)->sort.pars = g_tokpars;`
		7584	`(ZIc)->next = tokdecs;`
		7585	`(ZIc)->isdeffed = 0; (ZIc)->isused = 0; (ZIc)->iskept=0; (ZIc)->isparam=0;`
		7586	`tokdecs = (ZIc);`
		7587	`o_make_tokdec(out_tdfint32(LOCNAME((ZIc)->idname)),`
		7588	`if ((ZIa).no != 0) { OPTION(append_TDF(&(ZIa), 1)); },`
		7589	`out_toksort(&(ZIc)->sort));`
		7590	`INC_LIST;`
		7591	`}`
		7592	`}`
		7593	`return;`
		7594	`ZL1:;`
		7595	`SAVE_LEXER (130);`
		7596	`return;`
		7597	`}`
		7598
		7599	`static void`
		7600	`ZRexp__comma__list(void)`
		7601	`{`
		7602	`if ((CURRENT_TERMINAL) == 130) {`
		7603	`return;`
		7604	`}`
		7605	`ZL2_exp__comma__list:;`
		7606	`{`
		7607	`read_exp ();`
		7608	`if ((CURRENT_TERMINAL) == 130) {`
		7609	`RESTORE_LEXER;`
		7610	`goto ZL1;`
		7611	`}`
		7612	`{`
		7613
		7614	`current_TDF->no++;`
		7615	`}`
		7616	`{`
		7617	`switch (CURRENT_TERMINAL) {`
		7618	`case 25:`
		7619	`{`
		7620	`ADVANCE_LEXER;`
		7621	`goto ZL2_exp__comma__list;`
		7622	`}`
		7623	`/UNREACHED/`
		7624	`default:`
		7625	`break;`
		7626	`}`
		7627	`}`
		7628	`}`
		7629	`return;`
		7630	`ZL1:;`
		7631	`SAVE_LEXER (130);`
		7632	`return;`
		7633	`}`
		7634
		7635	`static void`
		7636	`ZRexp__body(void)`
		7637	`{`
		7638	`if ((CURRENT_TERMINAL) == 130) {`
		7639	`return;`
		7640	`}`
		7641	`{`
		7642	`ZRunary__exp ();`
		7643	`ZR632 ();`
		7644	`if ((CURRENT_TERMINAL) == 130) {`
		7645	`RESTORE_LEXER;`
		7646	`goto ZL1;`
		7647	`}`
		7648	`}`
		7649	`return;`
		7650	`ZL1:;`
		7651	`SAVE_LEXER (130);`
		7652	`return;`
		7653	`}`
		7654
		7655	`static void`
		7656	`ZRtok__def(void)`
		7657	`{`
		7658	`if ((CURRENT_TERMINAL) == 130) {`
		7659	`return;`
		7660	`}`
		7661	`{`
		7662	`TDF ZIa;`
		7663	`TDF ZIb;`
		7664	`PTR_TDF ZIc;`
		7665	`PTR_Tokdec ZId;`
		7666	`int ZIe;`
		7667
		7668	`{`
		7669
		7670	`search_for_toks = 0;`
		7671	`}`
		7672	`switch (CURRENT_TERMINAL) {`
		7673	`case 114:`
		7674	`break;`
		7675	`default:`
		7676	`goto ZL1;`
		7677	`}`
		7678	`ADVANCE_LEXER;`
		7679	`{`
		7680
		7681	`char *n = lex_v.val.name;`
		7682	`(ZId) = find_tok(n);`
		7683	`(ZIa) = g_tok_defn;`
		7684	`SELECT_UNIT(tokdef_unit);`
		7685	`search_for_toks = 1;`
		7686	`if ((ZId) != (Tokdec *)0) {`
		7687	`if ((ZId)->isdeffed)fail("Token %s defined twice", n);`
		7688	`(ZIe) = 1;`
		7689	`} else {`
		7690	`(ZId) = MALLOC(Tokdec);`
		7691	`NEW_IDNAME((ZId)->idname, n, tok_ent);`
		7692	`(ZIe) = 0;`
		7693	`}`
		7694	`SET_TDF((ZIc), &(ZIb));`
		7695	`}`
		7696	`switch (CURRENT_TERMINAL) {`
		7697	`case 54:`
		7698	`break;`
		7699	`default:`
		7700	`goto ZL1;`
		7701	`}`
		7702	`ADVANCE_LEXER;`
		7703	`switch (CURRENT_TERMINAL) {`
		7704	`case 36:`
		7705	`break;`
		7706	`default:`
		7707	`goto ZL1;`
		7708	`}`
		7709	`ADVANCE_LEXER;`
		7710	`ZRtok__def__body ();`
		7711	`if ((CURRENT_TERMINAL) == 130) {`
		7712	`RESTORE_LEXER;`
		7713	`goto ZL1;`
		7714	`}`
		7715	`{`
		7716
		7717	`RESET_TDF((ZIc));`
		7718	`(ZId)->sort = g_toksort;`
		7719	`(ZId)->isdeffed =1; (ZId)->iskept=0; (ZId)->isparam = 0;`
		7720	`o_make_tokdef(out_tdfint32(UL(local_name(&(ZId)->idname.name,tok_ent))),`
		7721	`if ((ZIb).no != 0) { OPTION(append_TDF(&(ZIb), 1)); },`
		7722	`append_TDF(&g_tok_defn, 1));`
		7723	`INC_LIST;`
		7724	`if (!(ZIe)) { (ZId)->next = tokdecs; tokdecs = (ZId); (ZId)->isused=0; }`
		7725	`g_tok_defn = (ZIa);`
		7726	`}`
		7727	`}`
		7728	`return;`
		7729	`ZL1:;`
		7730	`SAVE_LEXER (130);`
		7731	`return;`
		7732	`}`
		7733
		7734	`static void`
		7735	`ZRunary__exp(void)`
		7736	`{`
		7737	`ZL2_unary__exp:;`
		7738	`switch (CURRENT_TERMINAL) {`
		7739	`case 19:`
		7740	`{`
		7741	`TDF ZIa;`
		7742	`TDF ZIb;`
		7743	`PTR_TDF ZIc;`
		7744
		7745	`ADVANCE_LEXER;`
		7746	`{`
		7747
		7748	`/* (ZIb) uninitialised */`
		7749	`SET_TDF((ZIc), &(ZIa));`
		7750	`}`
		7751	`read_exp ();`
		7752	`switch (CURRENT_TERMINAL) {`
		7753	`case 78:`
		7754	`break;`
		7755	`case 130:`
		7756	`RESTORE_LEXER;`
		7757	`goto ZL1;`
		7758	`default:`
		7759	`goto ZL1;`
		7760	`}`
		7761	`ADVANCE_LEXER;`
		7762	`{`
		7763
		7764	`RESET_TDF((ZIc));`
		7765	`SET_TDF((ZIc), &(ZIb));`
		7766	`}`
		7767	`ZRrange__label__list ();`
		7768	`if ((CURRENT_TERMINAL) == 130) {`
		7769	`RESTORE_LEXER;`
		7770	`goto ZL1;`
		7771	`}`
		7772	`{`
		7773
		7774	`RESET_TDF((ZIc));`
		7775	`o_case(o_false, append_TDF(&(ZIa),1),`
		7776	`{ append_TDF(&(ZIb),1); current_TDF->no = (ZIb).no; });`
		7777	`}`
		7778	`switch (CURRENT_TERMINAL) {`
		7779	`case 29:`
		7780	`break;`
		7781	`default:`
		7782	`goto ZL1;`
		7783	`}`
		7784	`ADVANCE_LEXER;`
		7785	`}`
		7786	`break;`
		7787	`case 28:`
		7788	`{`
		7789	`TDF ZIa;`
		7790	`TDF ZIb;`
		7791	`PTR_TDF ZIc;`
		7792
		7793	`ADVANCE_LEXER;`
		7794	`switch (CURRENT_TERMINAL) {`
		7795	`case 79:`
		7796	`break;`
		7797	`default:`
		7798	`goto ZL1;`
		7799	`}`
		7800	`ADVANCE_LEXER;`
		7801	`{`
		7802
		7803	`/* (ZIb) uninitialised */`
		7804	`SET_TDF((ZIc), &(ZIa));`
		7805	`}`
		7806	`read_exp ();`
		7807	`if ((CURRENT_TERMINAL) == 130) {`
		7808	`RESTORE_LEXER;`
		7809	`goto ZL1;`
		7810	`}`
		7811	`{`
		7812
		7813	`RESET_TDF((ZIc));`
		7814	`SET_TDF((ZIc), &(ZIb));`
		7815	`}`
		7816	`switch (CURRENT_TERMINAL) {`
		7817	`case 30:`
		7818	`break;`
		7819	`default:`
		7820	`goto ZL1;`
		7821	`}`
		7822	`ADVANCE_LEXER;`
		7823	`switch (CURRENT_TERMINAL) {`
		7824	`case 78:`
		7825	`break;`
		7826	`default:`
		7827	`goto ZL1;`
		7828	`}`
		7829	`ADVANCE_LEXER;`
		7830	`ZRoffset__exp__list ();`
		7831	`if ((CURRENT_TERMINAL) == 130) {`
		7832	`RESTORE_LEXER;`
		7833	`goto ZL1;`
		7834	`}`
		7835	`{`
		7836
		7837	`RESET_TDF((ZIc));`
		7838	`o_make_compound(append_TDF(&(ZIa),1),`
		7839	`{ append_TDF(&(ZIb),1); current_TDF->no = (ZIb).no; });`
		7840	`}`
		7841	`switch (CURRENT_TERMINAL) {`
		7842	`case 29:`
		7843	`break;`
		7844	`default:`
		7845	`goto ZL1;`
		7846	`}`
		7847	`ADVANCE_LEXER;`
		7848	`}`
		7849	`break;`
		7850	`case 42:`
		7851	`{`
		7852	`ADVANCE_LEXER;`
		7853	`{`
		7854	`switch (CURRENT_TERMINAL) {`
		7855	`case 24:`
		7856	`{`
		7857	`ADVANCE_LEXER;`
		7858	`goto ZL2_unary__exp;`
		7859	`}`
		7860	`/UNREACHED/`
		7861	`case 86:`
		7862	`{`
		7863	`TDF ZIa;`
		7864	`TDF ZIb;`
		7865	`TDF ZIc;`
		7866	`PTR_TDF ZId;`
		7867
		7868	`ADVANCE_LEXER;`
		7869	`{`
		7870
		7871	`/* (ZIb), (ZIc) uninitialised */`
		7872	`SET_TDF((ZId), &(ZIa));`
		7873	`}`
		7874	`switch (CURRENT_TERMINAL) {`
		7875	`case 78:`
		7876	`break;`
		7877	`default:`
		7878	`goto ZL1;`
		7879	`}`
		7880	`ADVANCE_LEXER;`
		7881	`read_exp ();`
		7882	`if ((CURRENT_TERMINAL) == 130) {`
		7883	`RESTORE_LEXER;`
		7884	`goto ZL1;`
		7885	`}`
		7886	`{`
		7887
		7888	`RESET_TDF((ZId));`
		7889	`SET_TDF((ZId), &(ZIb));`
		7890	`}`
		7891	`switch (CURRENT_TERMINAL) {`
		7892	`case 25:`
		7893	`break;`
		7894	`default:`
		7895	`goto ZL1;`
		7896	`}`
		7897	`ADVANCE_LEXER;`
		7898	`read_exp ();`
		7899	`if ((CURRENT_TERMINAL) == 130) {`
		7900	`RESTORE_LEXER;`
		7901	`goto ZL1;`
		7902	`}`
		7903	`{`
		7904
		7905	`RESET_TDF((ZId));`
		7906	`SET_TDF((ZId), &(ZIc));`
		7907	`}`
		7908	`switch (CURRENT_TERMINAL) {`
		7909	`case 25:`
		7910	`break;`
		7911	`default:`
		7912	`goto ZL1;`
		7913	`}`
		7914	`ADVANCE_LEXER;`
		7915	`read_exp ();`
		7916	`if ((CURRENT_TERMINAL) == 130) {`
		7917	`RESTORE_LEXER;`
		7918	`goto ZL1;`
		7919	`}`
		7920	`{`
		7921
		7922	`RESET_TDF((ZId));`
		7923	`o_exp_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		7924	`append_TDF(&(ZIc),1));`
		7925	`}`
		7926	`switch (CURRENT_TERMINAL) {`
		7927	`case 29:`
		7928	`break;`
		7929	`default:`
		7930	`goto ZL1;`
		7931	`}`
		7932	`ADVANCE_LEXER;`
		7933	`}`
		7934	`break;`
		7935	`default:`
		7936	`goto ZL1;`
		7937	`}`
		7938	`}`
		7939	`}`
		7940	`break;`
		7941	`case 45:`
		7942	`{`
		7943	`TDF ZIa;`
		7944	`TDF ZIb;`
		7945	`TDF ZIc;`
		7946	`PTR_TDF ZId;`
		7947	`int ZIe;`
		7948
		7949	`ADVANCE_LEXER;`
		7950	`{`
		7951
		7952	`query_t = lex_float__query;`
		7953	`}`
		7954	`switch (CURRENT_TERMINAL) {`
		7955	`case 78:`
		7956	`break;`
		7957	`default:`
		7958	`goto ZL1;`
		7959	`}`
		7960	`ADVANCE_LEXER;`
		7961	`{`
		7962
		7963	`/* (ZIb), (ZIc) uninitialised */`
		7964	`(ZIe) = query_t;`
		7965	`SET_TDF((ZId),&(ZIa));`
		7966	`}`
		7967	`read_exp ();`
		7968	`if ((CURRENT_TERMINAL) == 130) {`
		7969	`RESTORE_LEXER;`
		7970	`goto ZL1;`
		7971	`}`
		7972	`{`
		7973
		7974	`RESET_TDF((ZId));`
		7975	`SET_TDF((ZId),&(ZIb));`
		7976	`}`
		7977	`read_ntest ();`
		7978	`if ((CURRENT_TERMINAL) == 130) {`
		7979	`RESTORE_LEXER;`
		7980	`goto ZL1;`
		7981	`}`
		7982	`{`
		7983
		7984	`RESET_TDF((ZId));`
		7985	`SET_TDF((ZId), &(ZIc))`
		7986	`}`
		7987	`read_exp ();`
		7988	`ZRlabdest__opt ();`
		7989	`if ((CURRENT_TERMINAL) == 130) {`
		7990	`RESTORE_LEXER;`
		7991	`goto ZL1;`
		7992	`}`
		7993	`{`
		7994
		7995	`RESET_TDF((ZId));`
		7996	`switch ((ZIe)) {`
		7997	`case lex_query:`
		7998	`o_integer_test({}, append_TDF(&(ZIb),1), append_TDF(&optlab,1),`
		7999	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8000	`break;`
		8001	`case lex_float__query:`
		8002	`o_floating_test({}, o_impossible, append_TDF(&(ZIb),1),`
		8003	`append_TDF(&optlab,1),`
		8004	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8005	`break;`
		8006	`case lex_ptr__query:`
		8007	`o_pointer_test({}, append_TDF(&(ZIb),1),append_TDF(&optlab,1),`
		8008	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8009	`break;`
		8010	`case lex_proc__query:`
		8011	`o_proc_test({}, append_TDF(&(ZIb),1),append_TDF(&optlab,1),`
		8012	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1)`
		8013	`);`
		8014	`break;`
		8015	`case lex_offset__query:`
		8016	`o_offset_test({}, append_TDF(&(ZIb),1), append_TDF(&optlab,1),`
		8017	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1)`
		8018	`);`
		8019	`break;`
		8020	`default: fail("Don't understand test");`
		8021	`}`
		8022	`}`
		8023	`switch (CURRENT_TERMINAL) {`
		8024	`case 29:`
		8025	`break;`
		8026	`default:`
		8027	`goto ZL1;`
		8028	`}`
		8029	`ADVANCE_LEXER;`
		8030	`}`
		8031	`break;`
		8032	`case 52:`
		8033	`{`
		8034	`ADVANCE_LEXER;`
		8035	`{`
		8036
		8037	`o_fail_installer(read_string());`
		8038	`}`
		8039	`}`
		8040	`break;`
		8041	`case 58:`
		8042	`{`
		8043	`TDF ZIa;`
		8044	`TDF ZIb;`
		8045	`TDF ZIc;`
		8046	`PTR_TDF ZId;`
		8047	`PTR_Labdec ZIe;`
		8048
		8049	`ADVANCE_LEXER;`
		8050	`{`
		8051
		8052	`/* (ZIb) uninitialised */`
		8053	`(ZIe) = labdecs;`
		8054	`(ZIc) = g_lablist;`
		8055	`INIT_TDF(&g_lablist);`
		8056	`SET_TDF((ZId), &(ZIa));`
		8057	`}`
		8058	`switch (CURRENT_TERMINAL) {`
		8059	`case 76:`
		8060	`break;`
		8061	`default:`
		8062	`goto ZL1;`
		8063	`}`
		8064	`ADVANCE_LEXER;`
		8065	`ZRexp__sequence ();`
		8066	`if ((CURRENT_TERMINAL) == 130) {`
		8067	`RESTORE_LEXER;`
		8068	`goto ZL1;`
		8069	`}`
		8070	`{`
		8071
		8072	`RESET_TDF((ZId));`
		8073	`SET_TDF((ZId), &(ZIb));`
		8074	`}`
		8075	`switch (CURRENT_TERMINAL) {`
		8076	`case 11:`
		8077	`break;`
		8078	`default:`
		8079	`goto ZL1;`
		8080	`}`
		8081	`ADVANCE_LEXER;`
		8082	`ZRlabelled__list ();`
		8083	`switch (CURRENT_TERMINAL) {`
		8084	`case 20:`
		8085	`break;`
		8086	`case 130:`
		8087	`RESTORE_LEXER;`
		8088	`goto ZL1;`
		8089	`default:`
		8090	`goto ZL1;`
		8091	`}`
		8092	`ADVANCE_LEXER;`
		8093	`{`
		8094
		8095	`RESET_TDF((ZId));`
		8096	`o_labelled({ append_TDF(&g_lablist,1);`
		8097	`current_TDF->no = g_lablist.no;},`
		8098	`append_TDF(&(ZIa), 1),`
		8099	`{ append_TDF(&(ZIb),1);`
		8100	`current_TDF->no = g_lablist.no;});`
		8101	`tidy_labels((ZIe));`
		8102	`g_lablist = (ZIc);`
		8103	`}`
		8104	`}`
		8105	`break;`
		8106	`case 68:`
		8107	`{`
		8108	`ADVANCE_LEXER;`
		8109	`ZR645 ();`
		8110	`if ((CURRENT_TERMINAL) == 130) {`
		8111	`RESTORE_LEXER;`
		8112	`goto ZL1;`
		8113	`}`
		8114	`}`
		8115	`break;`
		8116	`case 76:`
		8117	`{`
		8118	`ADVANCE_LEXER;`
		8119	`ZRexp__sequence ();`
		8120	`switch (CURRENT_TERMINAL) {`
		8121	`case 20:`
		8122	`break;`
		8123	`case 130:`
		8124	`RESTORE_LEXER;`
		8125	`goto ZL1;`
		8126	`default:`
		8127	`goto ZL1;`
		8128	`}`
		8129	`ADVANCE_LEXER;`
		8130	`}`
		8131	`break;`
		8132	`case 77:`
		8133	`{`
		8134	`TDF ZIa;`
		8135	`TDF ZIb;`
		8136	`TDF ZIc;`
		8137	`PTR_TDF ZId;`
		8138	`int ZIe;`
		8139
		8140	`ADVANCE_LEXER;`
		8141	`{`
		8142
		8143	`query_t = lex_offset__query;`
		8144	`}`
		8145	`switch (CURRENT_TERMINAL) {`
		8146	`case 78:`
		8147	`break;`
		8148	`default:`
		8149	`goto ZL1;`
		8150	`}`
		8151	`ADVANCE_LEXER;`
		8152	`{`
		8153
		8154	`/* (ZIb), (ZIc) uninitialised */`
		8155	`(ZIe) = query_t;`
		8156	`SET_TDF((ZId),&(ZIa));`
		8157	`}`
		8158	`read_exp ();`
		8159	`if ((CURRENT_TERMINAL) == 130) {`
		8160	`RESTORE_LEXER;`
		8161	`goto ZL1;`
		8162	`}`
		8163	`{`
		8164
		8165	`RESET_TDF((ZId));`
		8166	`SET_TDF((ZId),&(ZIb));`
		8167	`}`
		8168	`read_ntest ();`
		8169	`if ((CURRENT_TERMINAL) == 130) {`
		8170	`RESTORE_LEXER;`
		8171	`goto ZL1;`
		8172	`}`
		8173	`{`
		8174
		8175	`RESET_TDF((ZId));`
		8176	`SET_TDF((ZId), &(ZIc))`
		8177	`}`
		8178	`read_exp ();`
		8179	`ZRlabdest__opt ();`
		8180	`if ((CURRENT_TERMINAL) == 130) {`
		8181	`RESTORE_LEXER;`
		8182	`goto ZL1;`
		8183	`}`
		8184	`{`
		8185
		8186	`RESET_TDF((ZId));`
		8187	`switch ((ZIe)) {`
		8188	`case lex_query:`
		8189	`o_integer_test({}, append_TDF(&(ZIb),1), append_TDF(&optlab,1),`
		8190	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8191	`break;`
		8192	`case lex_float__query:`
		8193	`o_floating_test({}, o_impossible, append_TDF(&(ZIb),1),`
		8194	`append_TDF(&optlab,1),`
		8195	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8196	`break;`
		8197	`case lex_ptr__query:`
		8198	`o_pointer_test({}, append_TDF(&(ZIb),1),append_TDF(&optlab,1),`
		8199	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8200	`break;`
		8201	`case lex_proc__query:`
		8202	`o_proc_test({}, append_TDF(&(ZIb),1),append_TDF(&optlab,1),`
		8203	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1)`
		8204	`);`
		8205	`break;`
		8206	`case lex_offset__query:`
		8207	`o_offset_test({}, append_TDF(&(ZIb),1), append_TDF(&optlab,1),`
		8208	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1)`
		8209	`);`
		8210	`break;`
		8211	`default: fail("Don't understand test");`
		8212	`}`
		8213	`}`
		8214	`switch (CURRENT_TERMINAL) {`
		8215	`case 29:`
		8216	`break;`
		8217	`default:`
		8218	`goto ZL1;`
		8219	`}`
		8220	`ADVANCE_LEXER;`
		8221	`}`
		8222	`break;`
		8223	`case 78:`
		8224	`{`
		8225	`ADVANCE_LEXER;`
		8226	`read_exp ();`
		8227	`switch (CURRENT_TERMINAL) {`
		8228	`case 29:`
		8229	`break;`
		8230	`case 130:`
		8231	`RESTORE_LEXER;`
		8232	`goto ZL1;`
		8233	`default:`
		8234	`goto ZL1;`
		8235	`}`
		8236	`ADVANCE_LEXER;`
		8237	`ZR646 ();`
		8238	`if ((CURRENT_TERMINAL) == 130) {`
		8239	`RESTORE_LEXER;`
		8240	`goto ZL1;`
		8241	`}`
		8242	`}`
		8243	`break;`
		8244	`case 79:`
		8245	`{`
		8246	`TDF ZIa;`
		8247	`TDF ZIb;`
		8248	`PTR_TDF ZIc;`
		8249
		8250	`ADVANCE_LEXER;`
		8251	`{`
		8252
		8253	`/* (ZIb) uninitialised */`
		8254	`SET_TDF((ZIc), &(ZIa));`
		8255	`}`
		8256	`read_variety ();`
		8257	`if ((CURRENT_TERMINAL) == 130) {`
		8258	`RESTORE_LEXER;`
		8259	`goto ZL1;`
		8260	`}`
		8261	`{`
		8262
		8263	`RESET_TDF((ZIc));`
		8264	`SET_TDF((ZIc), &(ZIb));`
		8265	`}`
		8266	`switch (CURRENT_TERMINAL) {`
		8267	`case 30:`
		8268	`break;`
		8269	`default:`
		8270	`goto ZL1;`
		8271	`}`
		8272	`ADVANCE_LEXER;`
		8273	`ZRunary__exp ();`
		8274	`if ((CURRENT_TERMINAL) == 130) {`
		8275	`RESTORE_LEXER;`
		8276	`goto ZL1;`
		8277	`}`
		8278	`{`
		8279
		8280	`RESET_TDF((ZIc));`
		8281	`o_change_variety(o_wrap, append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		8282	`}`
		8283	`}`
		8284	`break;`
		8285	`case 81:`
		8286	`{`
		8287	`ADVANCE_LEXER;`
		8288	`ZRproc__def__body ();`
		8289	`if ((CURRENT_TERMINAL) == 130) {`
		8290	`RESTORE_LEXER;`
		8291	`goto ZL1;`
		8292	`}`
		8293	`}`
		8294	`break;`
		8295	`case 82:`
		8296	`{`
		8297	`TDF ZIa;`
		8298	`TDF ZIb;`
		8299	`TDF ZIc;`
		8300	`PTR_TDF ZId;`
		8301	`int ZIe;`
		8302
		8303	`ADVANCE_LEXER;`
		8304	`{`
		8305
		8306	`query_t = lex_proc__query;`
		8307	`}`
		8308	`switch (CURRENT_TERMINAL) {`
		8309	`case 78:`
		8310	`break;`
		8311	`default:`
		8312	`goto ZL1;`
		8313	`}`
		8314	`ADVANCE_LEXER;`
		8315	`{`
		8316
		8317	`/* (ZIb), (ZIc) uninitialised */`
		8318	`(ZIe) = query_t;`
		8319	`SET_TDF((ZId),&(ZIa));`
		8320	`}`
		8321	`read_exp ();`
		8322	`if ((CURRENT_TERMINAL) == 130) {`
		8323	`RESTORE_LEXER;`
		8324	`goto ZL1;`
		8325	`}`
		8326	`{`
		8327
		8328	`RESET_TDF((ZId));`
		8329	`SET_TDF((ZId),&(ZIb));`
		8330	`}`
		8331	`read_ntest ();`
		8332	`if ((CURRENT_TERMINAL) == 130) {`
		8333	`RESTORE_LEXER;`
		8334	`goto ZL1;`
		8335	`}`
		8336	`{`
		8337
		8338	`RESET_TDF((ZId));`
		8339	`SET_TDF((ZId), &(ZIc))`
		8340	`}`
		8341	`read_exp ();`
		8342	`ZRlabdest__opt ();`
		8343	`if ((CURRENT_TERMINAL) == 130) {`
		8344	`RESTORE_LEXER;`
		8345	`goto ZL1;`
		8346	`}`
		8347	`{`
		8348
		8349	`RESET_TDF((ZId));`
		8350	`switch ((ZIe)) {`
		8351	`case lex_query:`
		8352	`o_integer_test({}, append_TDF(&(ZIb),1), append_TDF(&optlab,1),`
		8353	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8354	`break;`
		8355	`case lex_float__query:`
		8356	`o_floating_test({}, o_impossible, append_TDF(&(ZIb),1),`
		8357	`append_TDF(&optlab,1),`
		8358	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8359	`break;`
		8360	`case lex_ptr__query:`
		8361	`o_pointer_test({}, append_TDF(&(ZIb),1),append_TDF(&optlab,1),`
		8362	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8363	`break;`
		8364	`case lex_proc__query:`
		8365	`o_proc_test({}, append_TDF(&(ZIb),1),append_TDF(&optlab,1),`
		8366	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1)`
		8367	`);`
		8368	`break;`
		8369	`case lex_offset__query:`
		8370	`o_offset_test({}, append_TDF(&(ZIb),1), append_TDF(&optlab,1),`
		8371	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1)`
		8372	`);`
		8373	`break;`
		8374	`default: fail("Don't understand test");`
		8375	`}`
		8376	`}`
		8377	`switch (CURRENT_TERMINAL) {`
		8378	`case 29:`
		8379	`break;`
		8380	`default:`
		8381	`goto ZL1;`
		8382	`}`
		8383	`ADVANCE_LEXER;`
		8384	`}`
		8385	`break;`
		8386	`case 84:`
		8387	`{`
		8388	`TDF ZIa;`
		8389	`TDF ZIb;`
		8390	`TDF ZIc;`
		8391	`PTR_TDF ZId;`
		8392	`int ZIe;`
		8393
		8394	`ADVANCE_LEXER;`
		8395	`{`
		8396
		8397	`query_t = lex_ptr__query;`
		8398	`}`
		8399	`switch (CURRENT_TERMINAL) {`
		8400	`case 78:`
		8401	`break;`
		8402	`default:`
		8403	`goto ZL1;`
		8404	`}`
		8405	`ADVANCE_LEXER;`
		8406	`{`
		8407
		8408	`/* (ZIb), (ZIc) uninitialised */`
		8409	`(ZIe) = query_t;`
		8410	`SET_TDF((ZId),&(ZIa));`
		8411	`}`
		8412	`read_exp ();`
		8413	`if ((CURRENT_TERMINAL) == 130) {`
		8414	`RESTORE_LEXER;`
		8415	`goto ZL1;`
		8416	`}`
		8417	`{`
		8418
		8419	`RESET_TDF((ZId));`
		8420	`SET_TDF((ZId),&(ZIb));`
		8421	`}`
		8422	`read_ntest ();`
		8423	`if ((CURRENT_TERMINAL) == 130) {`
		8424	`RESTORE_LEXER;`
		8425	`goto ZL1;`
		8426	`}`
		8427	`{`
		8428
		8429	`RESET_TDF((ZId));`
		8430	`SET_TDF((ZId), &(ZIc))`
		8431	`}`
		8432	`read_exp ();`
		8433	`ZRlabdest__opt ();`
		8434	`if ((CURRENT_TERMINAL) == 130) {`
		8435	`RESTORE_LEXER;`
		8436	`goto ZL1;`
		8437	`}`
		8438	`{`
		8439
		8440	`RESET_TDF((ZId));`
		8441	`switch ((ZIe)) {`
		8442	`case lex_query:`
		8443	`o_integer_test({}, append_TDF(&(ZIb),1), append_TDF(&optlab,1),`
		8444	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8445	`break;`
		8446	`case lex_float__query:`
		8447	`o_floating_test({}, o_impossible, append_TDF(&(ZIb),1),`
		8448	`append_TDF(&optlab,1),`
		8449	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8450	`break;`
		8451	`case lex_ptr__query:`
		8452	`o_pointer_test({}, append_TDF(&(ZIb),1),append_TDF(&optlab,1),`
		8453	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1));`
		8454	`break;`
		8455	`case lex_proc__query:`
		8456	`o_proc_test({}, append_TDF(&(ZIb),1),append_TDF(&optlab,1),`
		8457	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1)`
		8458	`);`
		8459	`break;`
		8460	`case lex_offset__query:`
		8461	`o_offset_test({}, append_TDF(&(ZIb),1), append_TDF(&optlab,1),`
		8462	`append_TDF(&(ZIa), 1), append_TDF(&(ZIc),1)`
		8463	`);`
		8464	`break;`
		8465	`default: fail("Don't understand test");`
		8466	`}`
		8467	`}`
		8468	`switch (CURRENT_TERMINAL) {`
		8469	`case 29:`
		8470	`break;`
		8471	`default:`
		8472	`goto ZL1;`
		8473	`}`
		8474	`ADVANCE_LEXER;`
		8475	`}`
		8476	`break;`
		8477	`case 86:`
		8478	`{`
		8479	`ADVANCE_LEXER;`
		8480	`ZR648 ();`
		8481	`if ((CURRENT_TERMINAL) == 130) {`
		8482	`RESTORE_LEXER;`
		8483	`goto ZL1;`
		8484	`}`
		8485	`}`
		8486	`break;`
		8487	`case 88:`
		8488	`{`
		8489	`TDF ZIa;`
		8490	`TDF ZIb;`
		8491	`TDF ZIc;`
		8492	`PTR_TDF ZId;`
		8493	`PTR_Labdec ZIe;`
		8494	`int ZIf;`
		8495
		8496	`ADVANCE_LEXER;`
		8497	`{`
		8498
		8499	`/* (ZIb), (ZIc), (ZIf) uninitialised */`
		8500	`(ZIe) = labdecs;`
		8501	`SET_TDF((ZId), &(ZIa));`
		8502	`}`
		8503	`ZRrepeat__starter__opt ();`
		8504	`if ((CURRENT_TERMINAL) == 130) {`
		8505	`RESTORE_LEXER;`
		8506	`goto ZL1;`
		8507	`}`
		8508	`{`
		8509
		8510	`(ZIf) = defaultlab;`
		8511	`defaultlab = -1;`
		8512	`}`
		8513	`switch (CURRENT_TERMINAL) {`
		8514	`case 76:`
		8515	`break;`
		8516	`default:`
		8517	`goto ZL1;`
		8518	`}`
		8519	`ADVANCE_LEXER;`
		8520	`ZRlabset__opt ();`
		8521	`if ((CURRENT_TERMINAL) == 130) {`
		8522	`RESTORE_LEXER;`
		8523	`goto ZL1;`
		8524	`}`
		8525	`{`
		8526
		8527	`(ZIc) = optlab;`
		8528	`RESET_TDF((ZId));`
		8529	`SET_TDF((ZId), &(ZIb));`
		8530	`}`
		8531	`ZRexp__sequence ();`
		8532	`if ((CURRENT_TERMINAL) == 130) {`
		8533	`RESTORE_LEXER;`
		8534	`goto ZL1;`
		8535	`}`
		8536	`{`
		8537
		8538	`RESET_TDF((ZId));`
		8539	`o_repeat(append_TDF(&(ZIc),1), append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		8540	`tidy_labels((ZIe));`
		8541	`defaultlab = (ZIf);`
		8542	`}`
		8543	`switch (CURRENT_TERMINAL) {`
		8544	`case 20:`
		8545	`break;`
		8546	`default:`
		8547	`goto ZL1;`
		8548	`}`
		8549	`ADVANCE_LEXER;`
		8550	`}`
		8551	`break;`
		8552	`case 99:`
		8553	`{`
		8554	`TDF ZIa;`
		8555	`TDF ZIb;`
		8556
		8557	`ADVANCE_LEXER;`
		8558	`ZR633 ();`
		8559	`if ((CURRENT_TERMINAL) == 130) {`
		8560	`RESTORE_LEXER;`
		8561	`goto ZL1;`
		8562	`}`
		8563	`{`
		8564
		8565	`/* (ZIb) uninitialised */`
		8566	`(ZIa) = *current_TDF;`
		8567	`INIT_TDF(current_TDF);`
		8568	`}`
		8569	`switch (CURRENT_TERMINAL) {`
		8570	`case 78:`
		8571	`break;`
		8572	`default:`
		8573	`goto ZL1;`
		8574	`}`
		8575	`ADVANCE_LEXER;`
		8576	`read_variety ();`
		8577	`if ((CURRENT_TERMINAL) == 130) {`
		8578	`RESTORE_LEXER;`
		8579	`goto ZL1;`
		8580	`}`
		8581	`{`
		8582
		8583	`(ZIb) = *current_TDF;`
		8584	`INIT_TDF(current_TDF);`
		8585	`o_make_int(append_TDF(&(ZIb),1), append_TDF(&(ZIa),1));`
		8586	`}`
		8587	`switch (CURRENT_TERMINAL) {`
		8588	`case 29:`
		8589	`break;`
		8590	`default:`
		8591	`goto ZL1;`
		8592	`}`
		8593	`ADVANCE_LEXER;`
		8594	`}`
		8595	`break;`
		8596	`case 102:`
		8597	`{`
		8598	`TDF ZIa;`
		8599	`PTR_TDF ZIb;`
		8600
		8601	`ADVANCE_LEXER;`
		8602	`switch (CURRENT_TERMINAL) {`
		8603	`case 78:`
		8604	`break;`
		8605	`default:`
		8606	`goto ZL1;`
		8607	`}`
		8608	`ADVANCE_LEXER;`
		8609	`{`
		8610
		8611	`SET_TDF((ZIb), &(ZIa));`
		8612	`}`
		8613	`read_shape ();`
		8614	`if ((CURRENT_TERMINAL) == 130) {`
		8615	`RESTORE_LEXER;`
		8616	`goto ZL1;`
		8617	`}`
		8618	`{`
		8619
		8620	`RESET_TDF((ZIb));`
		8621	`o_offset_pad(o_alignment(append_TDF(&(ZIa), 0)),`
		8622	`o_shape_offset(append_TDF(&(ZIa), 1)));`
		8623	`}`
		8624	`switch (CURRENT_TERMINAL) {`
		8625	`case 29:`
		8626	`break;`
		8627	`default:`
		8628	`goto ZL1;`
		8629	`}`
		8630	`ADVANCE_LEXER;`
		8631	`}`
		8632	`break;`
		8633	`case 103:`
		8634	`{`
		8635	`ADVANCE_LEXER;`
		8636	`ZR647 ();`
		8637	`if ((CURRENT_TERMINAL) == 130) {`
		8638	`RESTORE_LEXER;`
		8639	`goto ZL1;`
		8640	`}`
		8641	`}`
		8642	`break;`
		8643	`case 22: case 55:`
		8644	`{`
		8645	`TDF ZIa;`
		8646	`TDF ZIb;`
		8647
		8648	`ZRinteger ();`
		8649	`if ((CURRENT_TERMINAL) == 130) {`
		8650	`RESTORE_LEXER;`
		8651	`goto ZL1;`
		8652	`}`
		8653	`{`
		8654
		8655	`o_make_signed_nat(out_tdfbool(0), out_tdfint32(intvalue));`
		8656	`}`
		8657	`{`
		8658
		8659	`/* (ZIb) uninitialised */`
		8660	`(ZIa) = *current_TDF;`
		8661	`INIT_TDF(current_TDF);`
		8662	`}`
		8663	`switch (CURRENT_TERMINAL) {`
		8664	`case 78:`
		8665	`break;`
		8666	`default:`
		8667	`goto ZL1;`
		8668	`}`
		8669	`ADVANCE_LEXER;`
		8670	`read_variety ();`
		8671	`if ((CURRENT_TERMINAL) == 130) {`
		8672	`RESTORE_LEXER;`
		8673	`goto ZL1;`
		8674	`}`
		8675	`{`
		8676
		8677	`(ZIb) = *current_TDF;`
		8678	`INIT_TDF(current_TDF);`
		8679	`o_make_int(append_TDF(&(ZIb),1), append_TDF(&(ZIa),1));`
		8680	`}`
		8681	`switch (CURRENT_TERMINAL) {`
		8682	`case 29:`
		8683	`break;`
		8684	`default:`
		8685	`goto ZL1;`
		8686	`}`
		8687	`ADVANCE_LEXER;`
		8688	`}`
		8689	`break;`
		8690	`case 54: case 109: case 110: case 111:`
		8691	`{`
		8692	`read_tag ();`
		8693	`if ((CURRENT_TERMINAL) == 130) {`
		8694	`RESTORE_LEXER;`
		8695	`goto ZL1;`
		8696	`}`
		8697	`{`
		8698
		8699	`TDF tg;`
		8700	`tg = *current_TDF;`
		8701	`INIT_TDF(current_TDF);`
		8702	`o_obtain_tag(append_TDF(&tg,1));`
		8703	`}`
		8704	`ZR646 ();`
		8705	`if ((CURRENT_TERMINAL) == 130) {`
		8706	`RESTORE_LEXER;`
		8707	`goto ZL1;`
		8708	`}`
		8709	`}`
		8710	`break;`
		8711	`case 61: case 124:`
		8712	`{`
		8713	`PTR_Tagdec ZIa;`
		8714	`TDF ZIb;`
		8715	`TDF ZIc;`
		8716	`TDF ZId;`
		8717	`PTR_TDF ZIe;`
		8718	`Name ZIf;`
		8719	`int ZIg;`
		8720
		8721	`{`
		8722
		8723	`(ZIa) = localdecs;`
		8724	`}`
		8725	`ZRtag__intro ();`
		8726	`if ((CURRENT_TERMINAL) == 130) {`
		8727	`RESTORE_LEXER;`
		8728	`goto ZL1;`
		8729	`}`
		8730	`{`
		8731
		8732	`(ZIg) = localdecs->isvar;`
		8733	`(ZIb) = intro_acc;`
		8734	`(ZIc) = intro_init;`
		8735	`(ZIf) = localdecs->idname.name;`
		8736	`SET_TDF((ZIe), &(ZId));`
		8737	`}`
		8738	`ZRclosed__exp ();`
		8739	`if ((CURRENT_TERMINAL) == 130) {`
		8740	`RESTORE_LEXER;`
		8741	`goto ZL1;`
		8742	`}`
		8743	`{`
		8744
		8745	`RESET_TDF((ZIe));`
		8746	`if ((ZIg)) {`
		8747	`o_variable(if ((ZIb).no!=0) { OPTION(append_TDF(&(ZIb),1)); },`
		8748	`make_tag(&(ZIf)), append_TDF(&(ZIc),1),`
		8749	`append_TDF(&(ZId),1));`
		8750	`} else {`
		8751	`o_identify(if ((ZIb).no!=0) { OPTION(append_TDF(&(ZIb),1)); },`
		8752	`make_tag(&(ZIf)), append_TDF(&(ZIc),1),`
		8753	`append_TDF(&(ZId),1));`
		8754	`}`
		8755	`}`
		8756	`{`
		8757
		8758	`localdecs = (ZIa);`
		8759	`}`
		8760	`}`
		8761	`break;`
		8762	`case 85: case 104: case 105: case 107:`
		8763	`{`
		8764	`TDF ZIa;`
		8765	`TDF ZIb;`
		8766	`PTR_TDF ZIc;`
		8767
		8768	`{`
		8769
		8770	`/* (ZIb) uninitialised */`
		8771	`SET_TDF((ZIc), &(ZIa));`
		8772	`}`
		8773	`read_string ();`
		8774	`if ((CURRENT_TERMINAL) == 130) {`
		8775	`RESTORE_LEXER;`
		8776	`goto ZL1;`
		8777	`}`
		8778	`{`
		8779
		8780	`RESET_TDF((ZIc));`
		8781	`SET_TDF((ZIc), &(ZIb));`
		8782	`}`
		8783	`switch (CURRENT_TERMINAL) {`
		8784	`case 78:`
		8785	`break;`
		8786	`default:`
		8787	`goto ZL1;`
		8788	`}`
		8789	`ADVANCE_LEXER;`
		8790	`read_variety ();`
		8791	`switch (CURRENT_TERMINAL) {`
		8792	`case 29:`
		8793	`break;`
		8794	`case 130:`
		8795	`RESTORE_LEXER;`
		8796	`goto ZL1;`
		8797	`default:`
		8798	`goto ZL1;`
		8799	`}`
		8800	`ADVANCE_LEXER;`
		8801	`{`
		8802
		8803	`RESET_TDF((ZIc));`
		8804	`o_make_nof_int(append_TDF(&(ZIb), 1), append_TDF(&(ZIa), 1););`
		8805	`}`
		8806	`}`
		8807	`break;`
		8808	`case 44:`
		8809	`{`
		8810	`TDF ZIa;`
		8811	`TDF ZIb;`
		8812	`TDF ZIc;`
		8813	`TDF ZId;`
		8814	`PTR_TDF ZIe;`
		8815	`int ZIf;`
		8816	`unsigned_long ZIg;`
		8817
		8818	`{`
		8819
		8820	`/* (ZIc), (ZId) uninitialised */`
		8821	`(ZIf) = 0;`
		8822	`(ZIg) = UL(radix);`
		8823	`SET_TDF((ZIe), &(ZIa));`
		8824	`out_tdfstring_bytes(fformat(lex_v.val.name,lnum), 8, UI(lnum));`
		8825	`RESET_TDF((ZIe));`
		8826	`SET_TDF((ZIe), &(ZIb));`
		8827	`}`
		8828	`ADVANCE_LEXER;`
		8829	`ZRexponent__opt ();`
		8830	`switch (CURRENT_TERMINAL) {`
		8831	`case 78:`
		8832	`break;`
		8833	`case 130:`
		8834	`RESTORE_LEXER;`
		8835	`goto ZL1;`
		8836	`default:`
		8837	`goto ZL1;`
		8838	`}`
		8839	`ADVANCE_LEXER;`
		8840	`{`
		8841
		8842	`RESET_TDF((ZIe));`
		8843	`SET_TDF((ZIe), &(ZIc));`
		8844	`}`
		8845	`read_floating_variety ();`
		8846	`if ((CURRENT_TERMINAL) == 130) {`
		8847	`RESTORE_LEXER;`
		8848	`goto ZL1;`
		8849	`}`
		8850	`{`
		8851
		8852	`RESET_TDF((ZIe));`
		8853	`SET_TDF((ZIe), &(ZId));`
		8854	`}`
		8855	`ZRrounding__mode__opt ();`
		8856	`if ((CURRENT_TERMINAL) == 130) {`
		8857	`RESTORE_LEXER;`
		8858	`goto ZL1;`
		8859	`}`
		8860	`{`
		8861
		8862	`RESET_TDF((ZIe));`
		8863	`o_make_floating(append_TDF(&(ZIc),1),`
		8864	`append_TDF(&(ZId),1),`
		8865	`if ((ZIf)) { o_true; } else { o_false; },`
		8866	`o_make_string(append_TDF(&(ZIa), 1)),`
		8867	`o_make_nat(out_tdfint32((ZIg))),`
		8868	`append_TDF(&(ZIb), 1));`
		8869	`}`
		8870	`switch (CURRENT_TERMINAL) {`
		8871	`case 29:`
		8872	`break;`
		8873	`default:`
		8874	`goto ZL1;`
		8875	`}`
		8876	`ADVANCE_LEXER;`
		8877	`}`
		8878	`break;`
		8879	`case 41: case 98:`
		8880	`{`
		8881	`int ZI642;`
		8882
		8883	`{`
		8884
		8885	`(ZI642) = lex_v.val.v;`
		8886	`}`
		8887	`ZR643 (&ZI642);`
		8888	`if ((CURRENT_TERMINAL) == 130) {`
		8889	`RESTORE_LEXER;`
		8890	`goto ZL1;`
		8891	`}`
		8892	`}`
		8893	`break;`
		8894	`case 43: case 100:`
		8895	`{`
		8896	`PTR_Tokdec ZI640;`
		8897
		8898	`{`
		8899
		8900	`(ZI640) = lex_v.val.tokname;`
		8901	`(ZI640)->isused = 1;`
		8902	`}`
		8903	`ZR641 (&ZI640);`
		8904	`if ((CURRENT_TERMINAL) == 130) {`
		8905	`RESTORE_LEXER;`
		8906	`goto ZL1;`
		8907	`}`
		8908	`}`
		8909	`break;`
		8910	`case 62:`
		8911	`{`
		8912	`TDF ZIa;`
		8913	`TDF ZIb;`
		8914
		8915	`{`
		8916
		8917	`o_make_signed_nat(out_tdfbool(0), out_tdfint32(cLINE));`
		8918	`}`
		8919	`ADVANCE_LEXER;`
		8920	`{`
		8921
		8922	`/* (ZIb) uninitialised */`
		8923	`(ZIa) = *current_TDF;`
		8924	`INIT_TDF(current_TDF);`
		8925	`}`
		8926	`switch (CURRENT_TERMINAL) {`
		8927	`case 78:`
		8928	`break;`
		8929	`default:`
		8930	`goto ZL1;`
		8931	`}`
		8932	`ADVANCE_LEXER;`
		8933	`read_variety ();`
		8934	`if ((CURRENT_TERMINAL) == 130) {`
		8935	`RESTORE_LEXER;`
		8936	`goto ZL1;`
		8937	`}`
		8938	`{`
		8939
		8940	`(ZIb) = *current_TDF;`
		8941	`INIT_TDF(current_TDF);`
		8942	`o_make_int(append_TDF(&(ZIb),1), append_TDF(&(ZIa),1));`
		8943	`}`
		8944	`switch (CURRENT_TERMINAL) {`
		8945	`case 29:`
		8946	`break;`
		8947	`default:`
		8948	`goto ZL1;`
		8949	`}`
		8950	`ADVANCE_LEXER;`
		8951	`}`
		8952	`break;`
		8953	`case 10:`
		8954	`{`
		8955	`TDF ZI637;`
		8956	`PTR_TDF ZI638;`
		8957	`TDF ZIa;`
		8958	`TDF ZIb;`
		8959
		8960	`{`
		8961
		8962	`SET_TDF((ZI638), &(ZI637));`
		8963	`if (strcmp(lex_v.val.name, "+"))fail("Only + or - on NATs");`
		8964	`}`
		8965	`ADVANCE_LEXER;`
		8966	`ZRnat__not__int ();`
		8967	`if ((CURRENT_TERMINAL) == 130) {`
		8968	`RESTORE_LEXER;`
		8969	`goto ZL1;`
		8970	`}`
		8971	`{`
		8972
		8973	`RESET_TDF((ZI638));`
		8974	`o_snat_from_nat(o_false, append_TDF(&(ZI637),1));`
		8975	`}`
		8976	`{`
		8977
		8978	`/* (ZIb) uninitialised */`
		8979	`(ZIa) = *current_TDF;`
		8980	`INIT_TDF(current_TDF);`
		8981	`}`
		8982	`switch (CURRENT_TERMINAL) {`
		8983	`case 78:`
		8984	`break;`
		8985	`default:`
		8986	`goto ZL1;`
		8987	`}`
		8988	`ADVANCE_LEXER;`
		8989	`read_variety ();`
		8990	`if ((CURRENT_TERMINAL) == 130) {`
		8991	`RESTORE_LEXER;`
		8992	`goto ZL1;`
		8993	`}`
		8994	`{`
		8995
		8996	`(ZIb) = *current_TDF;`
		8997	`INIT_TDF(current_TDF);`
		8998	`o_make_int(append_TDF(&(ZIb),1), append_TDF(&(ZIa),1));`
		8999	`}`
		9000	`switch (CURRENT_TERMINAL) {`
		9001	`case 29:`
		9002	`break;`
		9003	`default:`
		9004	`goto ZL1;`
		9005	`}`
		9006	`ADVANCE_LEXER;`
		9007	`}`
		9008	`break;`
		9009	`case 130:`
		9010	`return;`
		9011	`default:`
		9012	`goto ZL1;`
		9013	`}`
		9014	`return;`
		9015	`ZL1:;`
		9016	`SAVE_LEXER (130);`
		9017	`return;`
		9018	`}`
		9019
		9020	`static void`
		9021	`ZRtagshacc__list(void)`
		9022	`{`
		9023	`if ((CURRENT_TERMINAL) == 130) {`
		9024	`return;`
		9025	`}`
		9026	`ZL2_tagshacc__list:;`
		9027	`{`
		9028	`ZRtagshacc ();`
		9029	`if ((CURRENT_TERMINAL) == 130) {`
		9030	`RESTORE_LEXER;`
		9031	`goto ZL1;`
		9032	`}`
		9033	`{`
		9034
		9035	`current_TDF->no++;`
		9036	`}`
		9037	`{`
		9038	`switch (CURRENT_TERMINAL) {`
		9039	`case 25:`
		9040	`{`
		9041	`ADVANCE_LEXER;`
		9042	`goto ZL2_tagshacc__list;`
		9043	`}`
		9044	`/UNREACHED/`
		9045	`default:`
		9046	`break;`
		9047	`}`
		9048	`}`
		9049	`}`
		9050	`return;`
		9051	`ZL1:;`
		9052	`SAVE_LEXER (130);`
		9053	`return;`
		9054	`}`
		9055
		9056	`static void`
		9057	`ZRshapetok(void)`
		9058	`{`
		9059	`switch (CURRENT_TERMINAL) {`
		9060	`case 32:`
		9061	`{`
		9062	`ADVANCE_LEXER;`
		9063	`{`
		9064
		9065	`* g_shtokname = *(tokfordoublesh());`
		9066	`}`
		9067	`}`
		9068	`break;`
		9069	`case 46:`
		9070	`{`
		9071	`ADVANCE_LEXER;`
		9072	`{`
		9073
		9074	`* g_shtokname = *(tokforfloatsh());`
		9075	`}`
		9076	`}`
		9077	`break;`
		9078	`case 21: case 56: case 64: case 97: case 101:`
		9079	`case 121:`
		9080	`{`
		9081	`ZRvariety__sign ();`
		9082	`ZR675 ();`
		9083	`if ((CURRENT_TERMINAL) == 130) {`
		9084	`RESTORE_LEXER;`
		9085	`goto ZL1;`
		9086	`}`
		9087	`}`
		9088	`break;`
		9089	`case 83: case 94: case 95: case 96:`
		9090	`{`
		9091	`PTR_TDF ZIa;`
		9092	`TDF ZIb;`
		9093	`PTR_TDF ZIc;`
		9094	`int ZId;`
		9095
		9096	`{`
		9097
		9098	`(ZIa) = current_TDF;`
		9099	`(ZId) = current_Unit;`
		9100	`select_tokdef_unit();`
		9101	`* g_shtokname = next_name(tok_ent);`
		9102	`SET_TDF((ZIc), &(ZIb));`
		9103	`}`
		9104	`ZRnonst__shape ();`
		9105	`if ((CURRENT_TERMINAL) == 130) {`
		9106	`RESTORE_LEXER;`
		9107	`goto ZL1;`
		9108	`}`
		9109	`{`
		9110
		9111	`RESET_TDF((ZIc));`
		9112	`o_make_tokdef(out_tdfint32(UL(g_shtokname->unit_name)), {},`
		9113	`o_token_def(o_shape, {}, append_TDF(&(ZIb), 1)));`
		9114	`INC_LIST;`
		9115	`current_Unit = (ZId);`
		9116	`RESET_TDF((ZIa));`
		9117	`}`
		9118	`}`
		9119	`break;`
		9120	`case 130:`
		9121	`return;`
		9122	`default:`
		9123	`goto ZL1;`
		9124	`}`
		9125	`return;`
		9126	`ZL1:;`
		9127	`SAVE_LEXER (130);`
		9128	`return;`
		9129	`}`
		9130
		9131	`static void`
		9132	`ZRalignment__list(void)`
		9133	`{`
		9134	`if ((CURRENT_TERMINAL) == 130) {`
		9135	`return;`
		9136	`}`
		9137	`{`
		9138	`read_alignment ();`
		9139	`ZR622 ();`
		9140	`if ((CURRENT_TERMINAL) == 130) {`
		9141	`RESTORE_LEXER;`
		9142	`goto ZL1;`
		9143	`}`
		9144	`}`
		9145	`return;`
		9146	`ZL1:;`
		9147	`SAVE_LEXER (130);`
		9148	`return;`
		9149	`}`
		9150
		9151	`void`
		9152	`read_error_treatment(void)`
		9153	`{`
		9154	`ZL2_error__treatment:;`
		9155	`switch (CURRENT_TERMINAL) {`
		9156	`case 39:`
		9157	`{`
		9158	`ADVANCE_LEXER;`
		9159	`{`
		9160	`switch (CURRENT_TERMINAL) {`
		9161	`case 24:`
		9162	`{`
		9163	`ADVANCE_LEXER;`
		9164	`goto ZL2_error__treatment;`
		9165	`}`
		9166	`/UNREACHED/`
		9167	`case 86:`
		9168	`{`
		9169	`TDF ZIa;`
		9170	`TDF ZIb;`
		9171	`TDF ZIc;`
		9172	`PTR_TDF ZId;`
		9173
		9174	`{`
		9175
		9176	`/* (ZIb), (ZIc) uninitialised */`
		9177	`SET_TDF((ZId), &(ZIa));`
		9178	`}`
		9179	`ADVANCE_LEXER;`
		9180	`switch (CURRENT_TERMINAL) {`
		9181	`case 78:`
		9182	`break;`
		9183	`default:`
		9184	`goto ZL1;`
		9185	`}`
		9186	`ADVANCE_LEXER;`
		9187	`read_exp ();`
		9188	`switch (CURRENT_TERMINAL) {`
		9189	`case 25:`
		9190	`break;`
		9191	`case 130:`
		9192	`RESTORE_LEXER;`
		9193	`goto ZL1;`
		9194	`default:`
		9195	`goto ZL1;`
		9196	`}`
		9197	`ADVANCE_LEXER;`
		9198	`{`
		9199
		9200	`RESET_TDF((ZId));`
		9201	`SET_TDF((ZId), &(ZIb));`
		9202	`}`
		9203	`read_error_treatment ();`
		9204	`switch (CURRENT_TERMINAL) {`
		9205	`case 25:`
		9206	`break;`
		9207	`case 130:`
		9208	`RESTORE_LEXER;`
		9209	`goto ZL1;`
		9210	`default:`
		9211	`goto ZL1;`
		9212	`}`
		9213	`ADVANCE_LEXER;`
		9214	`{`
		9215
		9216	`RESET_TDF((ZId));`
		9217	`SET_TDF((ZId), &(ZIc));`
		9218	`}`
		9219	`read_error_treatment ();`
		9220	`if ((CURRENT_TERMINAL) == 130) {`
		9221	`RESTORE_LEXER;`
		9222	`goto ZL1;`
		9223	`}`
		9224	`{`
		9225
		9226	`RESET_TDF((ZId));`
		9227	`o_errt_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		9228	`append_TDF(&(ZIc),1));`
		9229	`}`
		9230	`switch (CURRENT_TERMINAL) {`
		9231	`case 29:`
		9232	`break;`
		9233	`default:`
		9234	`goto ZL1;`
		9235	`}`
		9236	`ADVANCE_LEXER;`
		9237	`}`
		9238	`break;`
		9239	`default:`
		9240	`goto ZL1;`
		9241	`}`
		9242	`}`
		9243	`}`
		9244	`break;`
		9245	`case 79:`
		9246	`{`
		9247	`TDF ZIa;`
		9248	`PTR_TDF ZIb;`
		9249
		9250	`ADVANCE_LEXER;`
		9251	`{`
		9252
		9253	`SET_TDF((ZIb), &(ZIa));`
		9254	`}`
		9255	`read_error_code_list ();`
		9256	`if ((CURRENT_TERMINAL) == 130) {`
		9257	`RESTORE_LEXER;`
		9258	`goto ZL1;`
		9259	`}`
		9260	`{`
		9261
		9262	`RESET_TDF((ZIb));`
		9263	`o_trap({append_TDF(&(ZIa),1); current_TDF->no = (ZIa).no; });`
		9264	`}`
		9265	`switch (CURRENT_TERMINAL) {`
		9266	`case 30:`
		9267	`break;`
		9268	`default:`
		9269	`goto ZL1;`
		9270	`}`
		9271	`ADVANCE_LEXER;`
		9272	`}`
		9273	`break;`
		9274	`case 54: case 59: case 60:`
		9275	`{`
		9276	`TDF ZIa;`
		9277	`PTR_TDF ZIb;`
		9278
		9279	`{`
		9280
		9281	`SET_TDF((ZIb), &(ZIa));`
		9282	`}`
		9283	`read_label ();`
		9284	`if ((CURRENT_TERMINAL) == 130) {`
		9285	`RESTORE_LEXER;`
		9286	`goto ZL1;`
		9287	`}`
		9288	`{`
		9289
		9290	`RESET_TDF((ZIb));`
		9291	`o_error_jump(append_TDF(&(ZIa),1));`
		9292	`}`
		9293	`}`
		9294	`break;`
		9295	`case 38:`
		9296	`{`
		9297	`int ZIa;`
		9298
		9299	`{`
		9300
		9301	`(ZIa) = lex_v.val.v;`
		9302	`}`
		9303	`ADVANCE_LEXER;`
		9304	`{`
		9305
		9306	`(constructs[(ZIa)].f)();`
		9307	`}`
		9308	`}`
		9309	`break;`
		9310	`case 40:`
		9311	`{`
		9312	`PTR_Tokdec ZIa;`
		9313
		9314	`{`
		9315
		9316	`(ZIa) = lex_v.val.tokname;`
		9317	`(ZIa)->isused = 1;`
		9318	`}`
		9319	`ADVANCE_LEXER;`
		9320	`{`
		9321
		9322	`expand_tok((ZIa), &(ZIa)->sort);`
		9323	`}`
		9324	`}`
		9325	`break;`
		9326	`case 130:`
		9327	`return;`
		9328	`default:`
		9329	`goto ZL1;`
		9330	`}`
		9331	`return;`
		9332	`ZL1:;`
		9333	`{`
		9334	`{`
		9335
		9336	`fail("Syntax error");`
		9337	`}`
		9338	`}`
		9339	`}`
		9340
		9341	`static void`
		9342	`ZRcallee(void)`
		9343	`{`
		9344	`switch (CURRENT_TERMINAL) {`
		9345	`case 33:`
		9346	`{`
		9347	`TDF ZIa;`
		9348	`TDF ZIb;`
		9349	`PTR_TDF ZIc;`
		9350
		9351	`ADVANCE_LEXER;`
		9352	`{`
		9353
		9354	`/* (ZIb) uninitialised */`
		9355	`SET_TDF((ZIc), &(ZIa));`
		9356	`}`
		9357	`switch (CURRENT_TERMINAL) {`
		9358	`case 78:`
		9359	`break;`
		9360	`default:`
		9361	`goto ZL1;`
		9362	`}`
		9363	`ADVANCE_LEXER;`
		9364	`read_exp ();`
		9365	`if ((CURRENT_TERMINAL) == 130) {`
		9366	`RESTORE_LEXER;`
		9367	`goto ZL1;`
		9368	`}`
		9369	`{`
		9370
		9371	`RESET_TDF((ZIc));`
		9372	`SET_TDF((ZIc), &(ZIb));`
		9373	`}`
		9374	`switch (CURRENT_TERMINAL) {`
		9375	`case 25:`
		9376	`break;`
		9377	`default:`
		9378	`goto ZL1;`
		9379	`}`
		9380	`ADVANCE_LEXER;`
		9381	`read_exp ();`
		9382	`if ((CURRENT_TERMINAL) == 130) {`
		9383	`RESTORE_LEXER;`
		9384	`goto ZL1;`
		9385	`}`
		9386	`{`
		9387
		9388	`RESET_TDF((ZIc));`
		9389	`o_make_dynamic_callees(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1));`
		9390	`}`
		9391	`switch (CURRENT_TERMINAL) {`
		9392	`case 29:`
		9393	`break;`
		9394	`default:`
		9395	`goto ZL1;`
		9396	`}`
		9397	`ADVANCE_LEXER;`
		9398	`}`
		9399	`break;`
		9400	`case 92:`
		9401	`{`
		9402	`ADVANCE_LEXER;`
		9403	`{`
		9404
		9405	`o_same_callees;`
		9406	`}`
		9407	`}`
		9408	`break;`
		9409	`default:`
		9410	`{`
		9411	`TDF ZIa;`
		9412	`PTR_TDF ZIb;`
		9413
		9414	`{`
		9415
		9416	`SET_TDF((ZIb), &(ZIa));`
		9417	`}`
		9418	`read_exp_list ();`
		9419	`if ((CURRENT_TERMINAL) == 130) {`
		9420	`RESTORE_LEXER;`
		9421	`goto ZL1;`
		9422	`}`
		9423	`{`
		9424
		9425	`RESET_TDF((ZIb));`
		9426	`o_make_callee_list({ append_TDF(&(ZIa),1); current_TDF->no = (ZIa).no;});`
		9427	`}`
		9428	`}`
		9429	`break;`
		9430	`case 130:`
		9431	`return;`
		9432	`}`
		9433	`return;`
		9434	`ZL1:;`
		9435	`SAVE_LEXER (130);`
		9436	`return;`
		9437	`}`
		9438
		9439	`void`
		9440	`read_al_tag(void)`
		9441	`{`
		9442	`ZL2_al__tag:;`
		9443	`switch (CURRENT_TERMINAL) {`
		9444	`case 4:`
		9445	`{`
		9446	`ADVANCE_LEXER;`
		9447	`switch (CURRENT_TERMINAL) {`
		9448	`case 24:`
		9449	`break;`
		9450	`default:`
		9451	`goto ZL1;`
		9452	`}`
		9453	`ADVANCE_LEXER;`
		9454	`goto ZL2_al__tag;`
		9455	`}`
		9456	`/UNREACHED/`
		9457	`case 54:`
		9458	`{`
		9459	`{`
		9460
		9461	`char * n =lex_v.val.name;`
		9462	`Al_tagdec * x = find_al_tag(n);`
		9463	`if (x== (Al_tagdec*)0) {`
		9464	`x= MALLOC(Al_tagdec);`
		9465	`x->isdeffed =0; x->iskept=0;`
		9466	`NEW_IDNAME(x->idname, n, al_tag_ent);`
		9467	`x->next = al_tagdecs;`
		9468	`al_tagdecs = x;`
		9469	`}`
		9470	`x->isused =1;`
		9471	`make_al_tag(&x->idname.name);`
		9472	`}`
		9473	`ADVANCE_LEXER;`
		9474	`}`
		9475	`break;`
		9476	`case 5:`
		9477	`{`
		9478	`PTR_Tokdec ZIa;`
		9479
		9480	`{`
		9481
		9482	`(ZIa) = lex_v.val.tokname;`
		9483	`(ZIa)->isused = 1;`
		9484	`}`
		9485	`ADVANCE_LEXER;`
		9486	`{`
		9487
		9488	`expand_tok((ZIa), &(ZIa)->sort);`
		9489	`}`
		9490	`}`
		9491	`break;`
		9492	`case 130:`
		9493	`return;`
		9494	`default:`
		9495	`goto ZL1;`
		9496	`}`
		9497	`return;`
		9498	`ZL1:;`
		9499	`{`
		9500	`{`
		9501
		9502	`fail("Syntax error");`
		9503	`}`
		9504	`}`
		9505	`}`
		9506
		9507	`void`
		9508	`read_exp_list(void)`
		9509	`{`
		9510	`if ((CURRENT_TERMINAL) == 130) {`
		9511	`return;`
		9512	`}`
		9513	`{`
		9514	`{`
		9515
		9516	`current_TDF->no=0;`
		9517	`}`
		9518	`ZR656 ();`
		9519	`if ((CURRENT_TERMINAL) == 130) {`
		9520	`RESTORE_LEXER;`
		9521	`goto ZL1;`
		9522	`}`
		9523	`}`
		9524	`return;`
		9525	`ZL1:;`
		9526	`{`
		9527	`{`
		9528
		9529	`fail("Syntax error");`
		9530	`}`
		9531	`}`
		9532	`}`
		9533
		9534	`static void`
		9535	`ZRelement(void)`
		9536	`{`
		9537	`switch (CURRENT_TERMINAL) {`
		9538	`case 6:`
		9539	`{`
		9540	`ZRal__tag__def ();`
		9541	`if ((CURRENT_TERMINAL) == 130) {`
		9542	`RESTORE_LEXER;`
		9543	`goto ZL1;`
		9544	`}`
		9545	`}`
		9546	`break;`
		9547	`case 81:`
		9548	`{`
		9549	`ZRproc__def ();`
		9550	`if ((CURRENT_TERMINAL) == 130) {`
		9551	`RESTORE_LEXER;`
		9552	`goto ZL1;`
		9553	`}`
		9554	`}`
		9555	`break;`
		9556	`case 108:`
		9557	`{`
		9558	`ZRstruct__def ();`
		9559	`if ((CURRENT_TERMINAL) == 130) {`
		9560	`RESTORE_LEXER;`
		9561	`goto ZL1;`
		9562	`}`
		9563	`}`
		9564	`break;`
		9565	`case 27: case 53: case 125:`
		9566	`{`
		9567	`ZRtag__dec ();`
		9568	`if ((CURRENT_TERMINAL) == 130) {`
		9569	`RESTORE_LEXER;`
		9570	`goto ZL1;`
		9571	`}`
		9572	`}`
		9573	`break;`
		9574	`case 26: case 61: case 106: case 124:`
		9575	`{`
		9576	`ZRtag__def ();`
		9577	`if ((CURRENT_TERMINAL) == 130) {`
		9578	`RESTORE_LEXER;`
		9579	`goto ZL1;`
		9580	`}`
		9581	`}`
		9582	`break;`
		9583	`case 113:`
		9584	`{`
		9585	`ZRtok__dec ();`
		9586	`if ((CURRENT_TERMINAL) == 130) {`
		9587	`RESTORE_LEXER;`
		9588	`goto ZL1;`
		9589	`}`
		9590	`}`
		9591	`break;`
		9592	`case 114:`
		9593	`{`
		9594	`ZRtok__def ();`
		9595	`if ((CURRENT_TERMINAL) == 130) {`
		9596	`RESTORE_LEXER;`
		9597	`goto ZL1;`
		9598	`}`
		9599	`}`
		9600	`break;`
		9601	`case 130:`
		9602	`return;`
		9603	`default:`
		9604	`goto ZL1;`
		9605	`}`
		9606	`return;`
		9607	`ZL1:;`
		9608	`SAVE_LEXER (130);`
		9609	`return;`
		9610	`}`
		9611
		9612	`static void`
		9613	`ZR622(void)`
		9614	`{`
		9615	`ZL2_622:;`
		9616	`switch (CURRENT_TERMINAL) {`
		9617	`case 25:`
		9618	`{`
		9619	`TDF ZIa;`
		9620	`PTR_TDF ZIb;`
		9621
		9622	`{`
		9623
		9624	`(ZIb) = current_TDF;`
		9625	`(ZIa) = *current_TDF;`
		9626	`INIT_TDF(current_TDF);`
		9627	`}`
		9628	`ADVANCE_LEXER;`
		9629	`read_alignment ();`
		9630	`if ((CURRENT_TERMINAL) == 130) {`
		9631	`RESTORE_LEXER;`
		9632	`goto ZL1;`
		9633	`}`
		9634	`{`
		9635
		9636	`TDF second;`
		9637	`second = *current_TDF;`
		9638	`INIT_TDF((ZIb));`
		9639	`RESET_TDF((ZIb));`
		9640	`o_unite_alignments(append_TDF(&(ZIa),1), append_TDF(&second,1));`
		9641	`}`
		9642	`goto ZL2_622;`
		9643	`}`
		9644	`/UNREACHED/`
		9645	`case 130:`
		9646	`return;`
		9647	`default:`
		9648	`break;`
		9649	`}`
		9650	`return;`
		9651	`ZL1:;`
		9652	`SAVE_LEXER (130);`
		9653	`return;`
		9654	`}`
		9655
		9656	`static void`
		9657	`ZRtok__def__body(void)`
		9658	`{`
		9659	`if ((CURRENT_TERMINAL) == 130) {`
		9660	`return;`
		9661	`}`
		9662	`{`
		9663	`PTR_Tokdec ZIa;`
		9664
		9665	`{`
		9666
		9667	`(ZIa) = g_tokformals;`
		9668	`}`
		9669	`switch (CURRENT_TERMINAL) {`
		9670	`case 79:`
		9671	`break;`
		9672	`default:`
		9673	`goto ZL1;`
		9674	`}`
		9675	`ADVANCE_LEXER;`
		9676	`ZRtok__formal__list__opt ();`
		9677	`switch (CURRENT_TERMINAL) {`
		9678	`case 30:`
		9679	`break;`
		9680	`case 130:`
		9681	`RESTORE_LEXER;`
		9682	`goto ZL1;`
		9683	`default:`
		9684	`goto ZL1;`
		9685	`}`
		9686	`ADVANCE_LEXER;`
		9687	`ZRfull__sortname ();`
		9688	`if ((CURRENT_TERMINAL) == 130) {`
		9689	`RESTORE_LEXER;`
		9690	`goto ZL1;`
		9691	`}`
		9692	`{`
		9693
		9694	`Tokdec * old_tokdecs = tokdecs;`
		9695	`Tokdec * tokformals = g_tokformals;`
		9696	`TDF * hold = current_TDF;`
		9697	`Tokpar * tp = (Tokpar*)0;`
		9698	`Sort sn;`
		9699	`Tokdec * tfrev = (Tokdec*)0;`
		9700	`while (g_tokformals != (Tokdec)0) { / the wrong way round!! */`
		9701	`Tokdec * x = MALLOC(Tokdec);`
		9702	`x = g_tokformals;`
		9703	`x->next = tfrev;`
		9704	`tfrev = x;`
		9705	`g_tokformals = g_tokformals->next;`
		9706	`}`
		9707	`sn = g_sname;`
		9708	`current_TDF = &g_tok_defn;`
		9709	`INIT_TDF(current_TDF);`
		9710	`o_token_def(out_sort(&sn),`
		9711	`{`
		9712	`while (tfrev != (Tokdec*)0) {`
		9713	`Tokdec * x = tfrev->next;`
		9714	`LIST_ELEM(`
		9715	`o_make_tokformals(`
		9716	`out_sort(&tfrev->sort.ressort),`
		9717	`out_tdfint32(LOCNAME(tfrev->idname))));`
		9718	`tfrev->isparam = 1;`
		9719	`tfrev->next = tokdecs;`
		9720	`tokdecs = tfrev;`
		9721	`tfrev = x;`
		9722	`}`
		9723	`},`
		9724	`analyse_sort(sn.sort));`
		9725	`g_toksort.ressort = sn;`
		9726	`while (tokformals != (Tokdec*)0) {`
		9727	`Tokpar * p = MALLOC(Tokpar);`
		9728	`p->par = tokformals->sort.ressort;`
		9729	`p->next = tp;`
		9730	`tokformals = tokformals->next;`
		9731	`tp = p;`
		9732	`}`
		9733	`g_toksort.pars = tp;`
		9734	`RESET_TDF(hold);`
		9735	`tokdecs = old_tokdecs;`
		9736	`g_tokformals = (ZIa);`
		9737	`}`
		9738	`}`
		9739	`return;`
		9740	`ZL1:;`
		9741	`SAVE_LEXER (130);`
		9742	`return;`
		9743	`}`
		9744
		9745	`static void`
		9746	`ZRinteger(void)`
		9747	`{`
		9748	`switch (CURRENT_TERMINAL) {`
		9749	`case 55:`
		9750	`{`
		9751	`{`
		9752
		9753	`intvalue = UL(stoi(lex_v.val.name, lnum));`
		9754	`}`
		9755	`ADVANCE_LEXER;`
		9756	`}`
		9757	`break;`
		9758	`case 22:`
		9759	`{`
		9760	`{`
		9761
		9762	`intvalue = UL(lex_v.val.v);`
		9763	`}`
		9764	`ADVANCE_LEXER;`
		9765	`}`
		9766	`break;`
		9767	`case 130:`
		9768	`return;`
		9769	`default:`
		9770	`goto ZL1;`
		9771	`}`
		9772	`return;`
		9773	`ZL1:;`
		9774	`SAVE_LEXER (130);`
		9775	`return;`
		9776	`}`
		9777
		9778	`void`
		9779	`read_transfer_mode(void)`
		9780	`{`
		9781	`ZL2_transfer__mode:;`
		9782	`switch (CURRENT_TERMINAL) {`
		9783	`case 119:`
		9784	`{`
		9785	`ADVANCE_LEXER;`
		9786	`{`
		9787	`switch (CURRENT_TERMINAL) {`
		9788	`case 24:`
		9789	`{`
		9790	`ADVANCE_LEXER;`
		9791	`goto ZL2_transfer__mode;`
		9792	`}`
		9793	`/UNREACHED/`
		9794	`case 86:`
		9795	`{`
		9796	`TDF ZIa;`
		9797	`TDF ZIb;`
		9798	`TDF ZIc;`
		9799	`PTR_TDF ZId;`
		9800
		9801	`ADVANCE_LEXER;`
		9802	`{`
		9803
		9804	`/* (ZIb), (ZIc) uninitialised */`
		9805	`SET_TDF((ZId), &(ZIa));`
		9806	`}`
		9807	`switch (CURRENT_TERMINAL) {`
		9808	`case 78:`
		9809	`break;`
		9810	`default:`
		9811	`goto ZL1;`
		9812	`}`
		9813	`ADVANCE_LEXER;`
		9814	`read_exp ();`
		9815	`if ((CURRENT_TERMINAL) == 130) {`
		9816	`RESTORE_LEXER;`
		9817	`goto ZL1;`
		9818	`}`
		9819	`{`
		9820
		9821	`RESET_TDF((ZId));`
		9822	`SET_TDF((ZId), &(ZIb));`
		9823	`}`
		9824	`switch (CURRENT_TERMINAL) {`
		9825	`case 25:`
		9826	`break;`
		9827	`default:`
		9828	`goto ZL1;`
		9829	`}`
		9830	`ADVANCE_LEXER;`
		9831	`read_transfer_mode ();`
		9832	`if ((CURRENT_TERMINAL) == 130) {`
		9833	`RESTORE_LEXER;`
		9834	`goto ZL1;`
		9835	`}`
		9836	`{`
		9837
		9838	`RESET_TDF((ZId));`
		9839	`SET_TDF((ZId), &(ZIc));`
		9840	`}`
		9841	`switch (CURRENT_TERMINAL) {`
		9842	`case 25:`
		9843	`break;`
		9844	`default:`
		9845	`goto ZL1;`
		9846	`}`
		9847	`ADVANCE_LEXER;`
		9848	`read_transfer_mode ();`
		9849	`if ((CURRENT_TERMINAL) == 130) {`
		9850	`RESTORE_LEXER;`
		9851	`goto ZL1;`
		9852	`}`
		9853	`{`
		9854
		9855	`RESET_TDF((ZId));`
		9856	`o_transfer_mode_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		9857	`append_TDF(&(ZIc),1));`
		9858	`}`
		9859	`switch (CURRENT_TERMINAL) {`
		9860	`case 29:`
		9861	`break;`
		9862	`default:`
		9863	`goto ZL1;`
		9864	`}`
		9865	`ADVANCE_LEXER;`
		9866	`}`
		9867	`break;`
		9868	`default:`
		9869	`goto ZL1;`
		9870	`}`
		9871	`}`
		9872	`}`
		9873	`break;`
		9874	`case 118:`
		9875	`{`
		9876	`int ZIa;`
		9877
		9878	`{`
		9879
		9880	`(ZIa) = lex_v.val.v;`
		9881	`}`
		9882	`ADVANCE_LEXER;`
		9883	`{`
		9884
		9885	`(constructs[(ZIa)].f)();`
		9886	`}`
		9887	`}`
		9888	`break;`
		9889	`case 120:`
		9890	`{`
		9891	`PTR_Tokdec ZIa;`
		9892
		9893	`{`
		9894
		9895	`(ZIa) = lex_v.val.tokname;`
		9896	`(ZIa)->isused = 1;`
		9897	`}`
		9898	`ADVANCE_LEXER;`
		9899	`{`
		9900
		9901	`expand_tok((ZIa), &(ZIa)->sort);`
		9902	`}`
		9903	`}`
		9904	`break;`
		9905	`case 130:`
		9906	`return;`
		9907	`default:`
		9908	`goto ZL1;`
		9909	`}`
		9910	`return;`
		9911	`ZL1:;`
		9912	`{`
		9913	`{`
		9914
		9915	`fail("Syntax error");`
		9916	`}`
		9917	`}`
		9918	`}`
		9919
		9920	`void`
		9921	`read_rounding_mode(void)`
		9922	`{`
		9923	`ZL2_rounding__mode:;`
		9924	`switch (CURRENT_TERMINAL) {`
		9925	`case 90:`
		9926	`{`
		9927	`ADVANCE_LEXER;`
		9928	`{`
		9929	`switch (CURRENT_TERMINAL) {`
		9930	`case 24:`
		9931	`{`
		9932	`ADVANCE_LEXER;`
		9933	`goto ZL2_rounding__mode;`
		9934	`}`
		9935	`/UNREACHED/`
		9936	`case 86:`
		9937	`{`
		9938	`TDF ZIa;`
		9939	`TDF ZIb;`
		9940	`TDF ZIc;`
		9941	`PTR_TDF ZId;`
		9942
		9943	`ADVANCE_LEXER;`
		9944	`{`
		9945
		9946	`/* (ZIb), (ZIc) uninitialised */`
		9947	`SET_TDF((ZId), &(ZIa));`
		9948	`}`
		9949	`switch (CURRENT_TERMINAL) {`
		9950	`case 78:`
		9951	`break;`
		9952	`default:`
		9953	`goto ZL1;`
		9954	`}`
		9955	`ADVANCE_LEXER;`
		9956	`read_exp ();`
		9957	`switch (CURRENT_TERMINAL) {`
		9958	`case 25:`
		9959	`break;`
		9960	`case 130:`
		9961	`RESTORE_LEXER;`
		9962	`goto ZL1;`
		9963	`default:`
		9964	`goto ZL1;`
		9965	`}`
		9966	`ADVANCE_LEXER;`
		9967	`{`
		9968
		9969	`RESET_TDF((ZId));`
		9970	`SET_TDF((ZId), &(ZIb));`
		9971	`}`
		9972	`read_rounding_mode ();`
		9973	`switch (CURRENT_TERMINAL) {`
		9974	`case 25:`
		9975	`break;`
		9976	`case 130:`
		9977	`RESTORE_LEXER;`
		9978	`goto ZL1;`
		9979	`default:`
		9980	`goto ZL1;`
		9981	`}`
		9982	`ADVANCE_LEXER;`
		9983	`{`
		9984
		9985	`RESET_TDF((ZId));`
		9986	`SET_TDF((ZId), &(ZIc));`
		9987	`}`
		9988	`read_rounding_mode ();`
		9989	`if ((CURRENT_TERMINAL) == 130) {`
		9990	`RESTORE_LEXER;`
		9991	`goto ZL1;`
		9992	`}`
		9993	`{`
		9994
		9995	`RESET_TDF((ZId));`
		9996	`o_rounding_mode_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		9997	`append_TDF(&(ZIc),1));`
		9998	`}`
		9999	`switch (CURRENT_TERMINAL) {`
		10000	`case 29:`
		10001	`break;`
		10002	`default:`
		10003	`goto ZL1;`
		10004	`}`
		10005	`ADVANCE_LEXER;`
		10006	`}`
		10007	`break;`
		10008	`default:`
		10009	`goto ZL1;`
		10010	`}`
		10011	`}`
		10012	`}`
		10013	`break;`
		10014	`case 89:`
		10015	`{`
		10016	`int ZIa;`
		10017
		10018	`{`
		10019
		10020	`(ZIa) = lex_v.val.v;`
		10021	`}`
		10022	`ADVANCE_LEXER;`
		10023	`{`
		10024
		10025	`(constructs[(ZIa)].f)();`
		10026	`}`
		10027	`}`
		10028	`break;`
		10029	`case 91:`
		10030	`{`
		10031	`PTR_Tokdec ZIa;`
		10032
		10033	`{`
		10034
		10035	`(ZIa) = lex_v.val.tokname;`
		10036	`(ZIa)->isused = 1;`
		10037	`}`
		10038	`ADVANCE_LEXER;`
		10039	`{`
		10040
		10041	`expand_tok((ZIa), &(ZIa)->sort);`
		10042	`}`
		10043	`}`
		10044	`break;`
		10045	`case 130:`
		10046	`return;`
		10047	`default:`
		10048	`goto ZL1;`
		10049	`}`
		10050	`return;`
		10051	`ZL1:;`
		10052	`{`
		10053	`{`
		10054
		10055	`fail("Syntax error");`
		10056	`}`
		10057	`}`
		10058	`}`
		10059
		10060	`static void`
		10061	`ZR625(void)`
		10062	`{`
		10063	`ZL2_625:;`
		10064	`switch (CURRENT_TERMINAL) {`
		10065	`case 25:`
		10066	`{`
		10067	`ADVANCE_LEXER;`
		10068	`read_error_code ();`
		10069	`if ((CURRENT_TERMINAL) == 130) {`
		10070	`RESTORE_LEXER;`
		10071	`goto ZL1;`
		10072	`}`
		10073	`{`
		10074
		10075	`current_TDF->no++;`
		10076	`}`
		10077	`goto ZL2_625;`
		10078	`}`
		10079	`/UNREACHED/`
		10080	`case 130:`
		10081	`return;`
		10082	`default:`
		10083	`break;`
		10084	`}`
		10085	`return;`
		10086	`ZL1:;`
		10087	`SAVE_LEXER (130);`
		10088	`return;`
		10089	`}`
		10090
		10091	`static void`
		10092	`ZR626(void)`
		10093	`{`
		10094	`ZL2_626:;`
		10095	`switch (CURRENT_TERMINAL) {`
		10096	`case 25:`
		10097	`{`
		10098	`{`
		10099
		10100	`current_TDF->no++;`
		10101	`}`
		10102	`ADVANCE_LEXER;`
		10103	`ZRotagexp ();`
		10104	`if ((CURRENT_TERMINAL) == 130) {`
		10105	`RESTORE_LEXER;`
		10106	`goto ZL1;`
		10107	`} else {`
		10108	`goto ZL2_626;`
		10109	`}`
		10110	`}`
		10111	`/UNREACHED/`
		10112	`case 130:`
		10113	`return;`
		10114	`default:`
		10115	`break;`
		10116	`}`
		10117	`return;`
		10118	`ZL1:;`
		10119	`SAVE_LEXER (130);`
		10120	`return;`
		10121	`}`
		10122
		10123	`void`
		10124	`read_access(void)`
		10125	`{`
		10126	`ZL2_access:;`
		10127	`switch (CURRENT_TERMINAL) {`
		10128	`case 1:`
		10129	`{`
		10130	`ADVANCE_LEXER;`
		10131	`{`
		10132	`switch (CURRENT_TERMINAL) {`
		10133	`case 24:`
		10134	`{`
		10135	`ADVANCE_LEXER;`
		10136	`goto ZL2_access;`
		10137	`}`
		10138	`/UNREACHED/`
		10139	`case 86:`
		10140	`{`
		10141	`TDF ZIa;`
		10142	`TDF ZIb;`
		10143	`TDF ZIc;`
		10144	`PTR_TDF ZId;`
		10145
		10146	`ADVANCE_LEXER;`
		10147	`{`
		10148
		10149	`/* (ZIb), (ZIc) uninitialised */`
		10150	`SET_TDF((ZId), &(ZIa));`
		10151	`}`
		10152	`switch (CURRENT_TERMINAL) {`
		10153	`case 78:`
		10154	`break;`
		10155	`default:`
		10156	`goto ZL1;`
		10157	`}`
		10158	`ADVANCE_LEXER;`
		10159	`read_exp ();`
		10160	`if ((CURRENT_TERMINAL) == 130) {`
		10161	`RESTORE_LEXER;`
		10162	`goto ZL1;`
		10163	`}`
		10164	`{`
		10165
		10166	`RESET_TDF((ZId));`
		10167	`SET_TDF((ZId), &(ZIb));`
		10168	`}`
		10169	`switch (CURRENT_TERMINAL) {`
		10170	`case 25:`
		10171	`break;`
		10172	`default:`
		10173	`goto ZL1;`
		10174	`}`
		10175	`ADVANCE_LEXER;`
		10176	`read_access ();`
		10177	`switch (CURRENT_TERMINAL) {`
		10178	`case 25:`
		10179	`break;`
		10180	`case 130:`
		10181	`RESTORE_LEXER;`
		10182	`goto ZL1;`
		10183	`default:`
		10184	`goto ZL1;`
		10185	`}`
		10186	`ADVANCE_LEXER;`
		10187	`{`
		10188
		10189	`RESET_TDF((ZId));`
		10190	`SET_TDF((ZId), &(ZIc));`
		10191	`}`
		10192	`read_access ();`
		10193	`if ((CURRENT_TERMINAL) == 130) {`
		10194	`RESTORE_LEXER;`
		10195	`goto ZL1;`
		10196	`}`
		10197	`{`
		10198
		10199	`RESET_TDF((ZId));`
		10200	`o_access_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		10201	`append_TDF(&(ZIc),1));`
		10202	`}`
		10203	`switch (CURRENT_TERMINAL) {`
		10204	`case 29:`
		10205	`break;`
		10206	`default:`
		10207	`goto ZL1;`
		10208	`}`
		10209	`ADVANCE_LEXER;`
		10210	`}`
		10211	`break;`
		10212	`default:`
		10213	`goto ZL1;`
		10214	`}`
		10215	`}`
		10216	`}`
		10217	`break;`
		10218	`case 0:`
		10219	`{`
		10220	`int ZIa;`
		10221
		10222	`{`
		10223
		10224	`(ZIa) = lex_v.val.v;`
		10225	`}`
		10226	`ADVANCE_LEXER;`
		10227	`{`
		10228
		10229	`if (strcmp(constructs[(ZIa)].name, "visible") ==0) { g_has_vis = 1; }`
		10230	`}`
		10231	`{`
		10232
		10233	`(constructs[(ZIa)].f)();`
		10234	`}`
		10235	`}`
		10236	`break;`
		10237	`case 2:`
		10238	`{`
		10239	`PTR_Tokdec ZIa;`
		10240
		10241	`{`
		10242
		10243	`(ZIa) = lex_v.val.tokname;`
		10244	`(ZIa)->isused = 1;`
		10245	`}`
		10246	`ADVANCE_LEXER;`
		10247	`{`
		10248
		10249	`expand_tok((ZIa), &(ZIa)->sort);`
		10250	`}`
		10251	`}`
		10252	`break;`
		10253	`case 130:`
		10254	`return;`
		10255	`default:`
		10256	`goto ZL1;`
		10257	`}`
		10258	`return;`
		10259	`ZL1:;`
		10260	`{`
		10261	`{`
		10262
		10263	`fail("Syntax error");`
		10264	`}`
		10265	`}`
		10266	`}`
		10267
		10268	`static void`
		10269	`ZR627(void)`
		10270	`{`
		10271	`ZL2_627:;`
		10272	`switch (CURRENT_TERMINAL) {`
		10273	`case 25:`
		10274	`{`
		10275	`TDF ZIa;`
		10276	`TDF ZIb;`
		10277	`PTR_TDF ZIc;`
		10278
		10279	`{`
		10280
		10281	`(ZIc) = current_TDF;`
		10282	`(ZIa) = *current_TDF;`
		10283	`INIT_TDF(&(ZIb));`
		10284	`RESET_TDF(&(ZIb));`
		10285	`}`
		10286	`ADVANCE_LEXER;`
		10287	`read_access ();`
		10288	`if ((CURRENT_TERMINAL) == 130) {`
		10289	`RESTORE_LEXER;`
		10290	`goto ZL1;`
		10291	`}`
		10292	`{`
		10293
		10294	`INIT_TDF((ZIc));`
		10295	`RESET_TDF((ZIc));`
		10296	`o_add_accesses(append_TDF(&(ZIa),1), append_TDF(&(ZIb), 1));`
		10297	`current_TDF->no = 1;`
		10298	`}`
		10299	`goto ZL2_627;`
		10300	`}`
		10301	`/UNREACHED/`
		10302	`case 130:`
		10303	`return;`
		10304	`default:`
		10305	`break;`
		10306	`}`
		10307	`return;`
		10308	`ZL1:;`
		10309	`SAVE_LEXER (130);`
		10310	`return;`
		10311	`}`
		10312
		10313	`static void`
		10314	`ZR628(void)`
		10315	`{`
		10316	`ZL2_628:;`
		10317	`switch (CURRENT_TERMINAL) {`
		10318	`case 93:`
		10319	`{`
		10320	`TDF ZIa;`
		10321	`PTR_TDF ZIb;`
		10322
		10323	`{`
		10324
		10325	`SET_TDF((ZIb), &(ZIa));`
		10326	`}`
		10327	`ADVANCE_LEXER;`
		10328	`{`
		10329	`switch (CURRENT_TERMINAL) {`
		10330	`case 10: case 19: case 22: case 28: case 41:`
		10331	`case 42: case 43: case 44: case 45: case 52:`
		10332	`case 54: case 55: case 58: case 61: case 62:`
		10333	`case 68: case 76: case 77: case 78: case 79:`
		10334	`case 81: case 82: case 84: case 85: case 86:`
		10335	`case 88: case 98: case 99: case 100: case 102:`
		10336	`case 103: case 104: case 105: case 107: case 109:`
		10337	`case 110: case 111: case 124:`
		10338	`{`
		10339	`read_exp ();`
		10340	`if ((CURRENT_TERMINAL) == 130) {`
		10341	`RESTORE_LEXER;`
		10342	`goto ZL1;`
		10343	`}`
		10344	`{`
		10345
		10346	`RESET_TDF((ZIb));`
		10347	`if (lex_v.t == lex_semi) {`
		10348	`current_TDF->no +=1;`
		10349	`append_TDF(&(ZIa),1);`
		10350	`} else {`
		10351	`TDF stats;`
		10352	`stats = *current_TDF;`
		10353	`INIT_TDF(current_TDF);`
		10354	`o_sequence(`
		10355	`{ append_TDF(&stats,1); current_TDF->no = stats.no; },`
		10356	`append_TDF(&(ZIa),1));`
		10357	`/* cheats LIST in o_sequence */`
		10358	`}`
		10359	`}`
		10360	`goto ZL2_628;`
		10361	`}`
		10362	`/UNREACHED/`
		10363	`default:`
		10364	`{`
		10365	`{`
		10366
		10367	`o_make_top;`
		10368	`}`
		10369	`{`
		10370
		10371	`RESET_TDF((ZIb));`
		10372	`if (lex_v.t == lex_semi) {`
		10373	`current_TDF->no +=1;`
		10374	`append_TDF(&(ZIa),1);`
		10375	`} else {`
		10376	`TDF stats;`
		10377	`stats = *current_TDF;`
		10378	`INIT_TDF(current_TDF);`
		10379	`o_sequence(`
		10380	`{ append_TDF(&stats,1); current_TDF->no = stats.no; },`
		10381	`append_TDF(&(ZIa),1));`
		10382	`/* cheats LIST in o_sequence */`
		10383	`}`
		10384	`}`
		10385	`goto ZL2_628;`
		10386	`}`
		10387	`/UNREACHED/`
		10388	`}`
		10389	`}`
		10390	`}`
		10391	`/UNREACHED/`
		10392	`case 130:`
		10393	`return;`
		10394	`default:`
		10395	`break;`
		10396	`}`
		10397	`return;`
		10398	`ZL1:;`
		10399	`SAVE_LEXER (130);`
		10400	`return;`
		10401	`}`
		10402
		10403	`static void`
		10404	`ZR629(void)`
		10405	`{`
		10406	`ZL2_629:;`
		10407	`switch (CURRENT_TERMINAL) {`
		10408	`case 25:`
		10409	`{`
		10410	`PTR_Tokdec ZIa;`
		10411
		10412	`ADVANCE_LEXER;`
		10413	`{`
		10414
		10415	`char * n = lex_v.val.name;`
		10416	`(ZIa) = find_tok(n);`
		10417	`if ((ZIa)!= (Tokdec*)0)fail("Token parameter name %s must be unique", n);`
		10418	`(ZIa) = MALLOC(Tokdec); NEW_IDNAME((ZIa)->idname, n, tok_ent);`
		10419	`(ZIa)->isdeffed = 1; (ZIa)->isused = 0; (ZIa)->iskept=0;`
		10420	`(ZIa)->next = (Tokdec*)0;`
		10421	`}`
		10422	`switch (CURRENT_TERMINAL) {`
		10423	`case 54:`
		10424	`break;`
		10425	`default:`
		10426	`goto ZL1;`
		10427	`}`
		10428	`ADVANCE_LEXER;`
		10429	`switch (CURRENT_TERMINAL) {`
		10430	`case 24:`
		10431	`break;`
		10432	`default:`
		10433	`goto ZL1;`
		10434	`}`
		10435	`ADVANCE_LEXER;`
		10436	`ZRfull__sortname ();`
		10437	`if ((CURRENT_TERMINAL) == 130) {`
		10438	`RESTORE_LEXER;`
		10439	`goto ZL1;`
		10440	`}`
		10441	`{`
		10442
		10443	`(ZIa)->sort.ressort = g_sname;`
		10444	`(ZIa)->sort.pars = (Tokpar)0; / no pars in formal pars */`
		10445	`(ZIa)->next = g_tokformals;`
		10446	`g_tokformals = (ZIa);`
		10447	`}`
		10448	`goto ZL2_629;`
		10449	`}`
		10450	`/UNREACHED/`
		10451	`case 130:`
		10452	`return;`
		10453	`default:`
		10454	`break;`
		10455	`}`
		10456	`return;`
		10457	`ZL1:;`
		10458	`SAVE_LEXER (130);`
		10459	`return;`
		10460	`}`
		10461
		10462	`static void`
		10463	`ZR630(void)`
		10464	`{`
		10465	`switch (CURRENT_TERMINAL) {`
		10466	`case 35:`
		10467	`{`
		10468	`ADVANCE_LEXER;`
		10469	`{`
		10470
		10471	`int i;`
		10472	`for (i=0; i<NO_OF_ENTITIES; i++) {`
		10473	`INIT_TDF(lk_externs+i);`
		10474	`}`
		10475	`}`
		10476	`{`
		10477
		10478	`CONT_STREAM(&units[tld2_unit].tdf, out_tdfint32(UL(1)));`
		10479	`if (line_no_tok != -1) {`
		10480	`current_TDF = lk_externs+tok_ent;`
		10481	`o_make_linkextern(`
		10482	`out_tdfint32(UL(line_no_tok)),`
		10483	`o_string_extern(`
		10484	`{ out_tdfident_bytes("~exp_to_source"); }));`
		10485	`current_TDF->no++;`
		10486	`CONT_STREAM(&units[tld2_unit].tdf, out_tdfint32(UL(3)));`
		10487	`}`
		10488	`{`
		10489	`Tokdec * k = tokdecs;`
		10490	`while (k != (Tokdec*)0) {`
		10491	`if (!k->isdeffed \|\| k->iskept) {`
		10492	`int capname = capsule_name(&k->idname.name, tok_ent);`
		10493	`char * n = k->idname.id;`
		10494	`current_TDF = lk_externs+tok_ent;`
		10495	`o_make_linkextern(out_tdfint32(UL(capname)),`
		10496	`o_string_extern({ out_tdfident_bytes(n); }));`
		10497	`current_TDF->no++;`
		10498	`CONT_STREAM(&units[tld2_unit].tdf,`
		10499	`{ int i = k->isused + 2 + 4*k->isdeffed;`
		10500	`out_tdfint32(UL(i)); });`
		10501	`}`
		10502	`k = k->next;`
		10503	`}`
		10504	`}`
		10505	`{`
		10506	`Tagdec * k = tagdecs;`
		10507	`while (k != (Tagdec*)0) {`
		10508	`if (!k->isdeffed \|\| k->iskept) {`
		10509	`int capname = capsule_name(&k->idname.name, tag_ent);`
		10510	`char * n = k->idname.id;`
		10511	`current_TDF = lk_externs+tag_ent;`
		10512	`o_make_linkextern(out_tdfint32(UL(capname)),`
		10513	`o_string_extern({ out_tdfident_bytes(n); }));`
		10514	`current_TDF->no++;`
		10515	`CONT_STREAM(&units[tld2_unit].tdf,`
		10516	`{ int i = k->isused + 2 + ((k->iscommon)?8:(4*k->isdeffed));`
		10517	`out_tdfint32(UL(i)); });`
		10518	`}`
		10519	`k = k->next;`
		10520	`}`
		10521	`}`
		10522	`{`
		10523	`Al_tagdec * k = al_tagdecs;`
		10524	`while (k != (Al_tagdec*)0) {`
		10525	`if (!k->isdeffed \|\| k->iskept) {`
		10526	`int capname = capsule_name(&k->idname.name, al_tag_ent);`
		10527	`char * n = k->idname.id;`
		10528	`current_TDF = lk_externs+al_tag_ent;`
		10529	`o_make_linkextern(out_tdfint32(UL(capname)),`
		10530	`o_string_extern({ out_tdfident_bytes(n); }));`
		10531	`current_TDF->no++;`
		10532	`CONT_STREAM(&units[tld2_unit].tdf,`
		10533	`{ int i = k->isused + 2 + 4*k->isdeffed;`
		10534	`out_tdfint32(UL(i)); });`
		10535	`}`
		10536	`k = k->next;`
		10537	`}`
		10538	`}`
		10539	`{`
		10540	`int i;`
		10541	`TDF caps;`
		10542	`add_extra_toks();`
		10543	`INIT_TDF(&caps);`
		10544	`RESET_TDF(&caps);`
		10545	`if (do_pp)success();`
		10546	`if (HAS_MAGIC) {`
		10547	`out_basic_int(UL('T'), UI(8));`
		10548	`out_basic_int(UL('D'), UI(8));`
		10549	`out_basic_int(UL('F'), UI(8));`
		10550	`out_basic_int(UL('C'), UI(8));`
		10551	`out_tdfint32(MAJOR_NO);`
		10552	`out_tdfint32(MINOR_NO);`
		10553	`byte_align();`
		10554	`}`
		10555	`o_make_capsule(`
		10556	`{`
		10557	`for (i=0; i<NO_OF_UNITS; i++) {`
		10558	`if (units[i].present) {`
		10559	`char* n;`
		10560	`n = unit_names[i];`
		10561	`LIST_ELEM({ out_tdfident_bytes(n); });`
		10562	`}`
		10563	`}`
		10564	`},`
		10565	`{`
		10566	`for (i=0; i<NO_OF_ENTITIES; i++) {`
		10567	`char* n;`
		10568	`n = ent_names[i];`
		10569	`LIST_ELEM(`
		10570	`o_make_capsule_link(`
		10571	`{ out_tdfident_bytes(n);},`
		10572	`out_tdfint32(UL(capsule_names[i]))))`
		10573	`}`
		10574	`},`
		10575	`{`
		10576	`for (i=0; i<NO_OF_ENTITIES; i++) {`
		10577	`TDF * lks = lk_externs+i;`
		10578	`LIST_ELEM(`
		10579	`o_make_extern_link(`
		10580	`{ append_TDF(lks,1); current_TDF->no = lks->no; });`
		10581	`)`
		10582	`}`
		10583	`},`
		10584	`{`
		10585	`for (i=0; i<NO_OF_UNITS; i++) {`
		10586	`if (units[i].present) {`
		10587	`LIST_ELEM(`
		10588	`o_make_group(LIST_ELEM(make_unit(i))););`
		10589	`}`
		10590	`}`
		10591	`}`
		10592	`);`
		10593	`make_tdf_file(&caps, out_file);`
		10594	`}`
		10595	`}`
		10596	`}`
		10597	`break;`
		10598	`case 57:`
		10599	`{`
		10600	`ADVANCE_LEXER;`
		10601	`switch (CURRENT_TERMINAL) {`
		10602	`case 78:`
		10603	`break;`
		10604	`default:`
		10605	`goto ZL1;`
		10606	`}`
		10607	`ADVANCE_LEXER;`
		10608	`{`
		10609
		10610	`int i;`
		10611	`for (i=0; i<NO_OF_ENTITIES; i++) {`
		10612	`INIT_TDF(lk_externs+i);`
		10613	`}`
		10614	`}`
		10615	`ZRkeep__list__opt ();`
		10616	`switch (CURRENT_TERMINAL) {`
		10617	`case 29:`
		10618	`break;`
		10619	`case 130:`
		10620	`RESTORE_LEXER;`
		10621	`goto ZL1;`
		10622	`default:`
		10623	`goto ZL1;`
		10624	`}`
		10625	`ADVANCE_LEXER;`
		10626	`switch (CURRENT_TERMINAL) {`
		10627	`case 35:`
		10628	`break;`
		10629	`default:`
		10630	`goto ZL1;`
		10631	`}`
		10632	`ADVANCE_LEXER;`
		10633	`{`
		10634
		10635	`CONT_STREAM(&units[tld2_unit].tdf, out_tdfint32(UL(1)));`
		10636	`if (line_no_tok != -1) {`
		10637	`current_TDF = lk_externs+tok_ent;`
		10638	`o_make_linkextern(`
		10639	`out_tdfint32(UL(line_no_tok)),`
		10640	`o_string_extern(`
		10641	`{ out_tdfident_bytes("~exp_to_source"); }));`
		10642	`current_TDF->no++;`
		10643	`CONT_STREAM(&units[tld2_unit].tdf, out_tdfint32(UL(3)));`
		10644	`}`
		10645	`{`
		10646	`Tokdec * k = tokdecs;`
		10647	`while (k != (Tokdec*)0) {`
		10648	`if (!k->isdeffed \|\| k->iskept) {`
		10649	`int capname = capsule_name(&k->idname.name, tok_ent);`
		10650	`char * n = k->idname.id;`
		10651	`current_TDF = lk_externs+tok_ent;`
		10652	`o_make_linkextern(out_tdfint32(UL(capname)),`
		10653	`o_string_extern({ out_tdfident_bytes(n); }));`
		10654	`current_TDF->no++;`
		10655	`CONT_STREAM(&units[tld2_unit].tdf,`
		10656	`{ int i = k->isused + 2 + 4*k->isdeffed;`
		10657	`out_tdfint32(UL(i)); });`
		10658	`}`
		10659	`k = k->next;`
		10660	`}`
		10661	`}`
		10662	`{`
		10663	`Tagdec * k = tagdecs;`
		10664	`while (k != (Tagdec*)0) {`
		10665	`if (!k->isdeffed \|\| k->iskept) {`
		10666	`int capname = capsule_name(&k->idname.name, tag_ent);`
		10667	`char * n = k->idname.id;`
		10668	`current_TDF = lk_externs+tag_ent;`
		10669	`o_make_linkextern(out_tdfint32(UL(capname)),`
		10670	`o_string_extern({ out_tdfident_bytes(n); }));`
		10671	`current_TDF->no++;`
		10672	`CONT_STREAM(&units[tld2_unit].tdf,`
		10673	`{ int i = k->isused + 2 + ((k->iscommon)?8:(4*k->isdeffed));`
		10674	`out_tdfint32(UL(i)); });`
		10675	`}`
		10676	`k = k->next;`
		10677	`}`
		10678	`}`
		10679	`{`
		10680	`Al_tagdec * k = al_tagdecs;`
		10681	`while (k != (Al_tagdec*)0) {`
		10682	`if (!k->isdeffed \|\| k->iskept) {`
		10683	`int capname = capsule_name(&k->idname.name, al_tag_ent);`
		10684	`char * n = k->idname.id;`
		10685	`current_TDF = lk_externs+al_tag_ent;`
		10686	`o_make_linkextern(out_tdfint32(UL(capname)),`
		10687	`o_string_extern({ out_tdfident_bytes(n); }));`
		10688	`current_TDF->no++;`
		10689	`CONT_STREAM(&units[tld2_unit].tdf,`
		10690	`{ int i = k->isused + 2 + 4*k->isdeffed;`
		10691	`out_tdfint32(UL(i)); });`
		10692	`}`
		10693	`k = k->next;`
		10694	`}`
		10695	`}`
		10696	`{`
		10697	`int i;`
		10698	`TDF caps;`
		10699	`add_extra_toks();`
		10700	`INIT_TDF(&caps);`
		10701	`RESET_TDF(&caps);`
		10702	`if (do_pp)success();`
		10703	`if (HAS_MAGIC) {`
		10704	`out_basic_int(UL('T'), UI(8));`
		10705	`out_basic_int(UL('D'), UI(8));`
		10706	`out_basic_int(UL('F'), UI(8));`
		10707	`out_basic_int(UL('C'), UI(8));`
		10708	`out_tdfint32(MAJOR_NO);`
		10709	`out_tdfint32(MINOR_NO);`
		10710	`byte_align();`
		10711	`}`
		10712	`o_make_capsule(`
		10713	`{`
		10714	`for (i=0; i<NO_OF_UNITS; i++) {`
		10715	`if (units[i].present) {`
		10716	`char* n;`
		10717	`n = unit_names[i];`
		10718	`LIST_ELEM({ out_tdfident_bytes(n); });`
		10719	`}`
		10720	`}`
		10721	`},`
		10722	`{`
		10723	`for (i=0; i<NO_OF_ENTITIES; i++) {`
		10724	`char* n;`
		10725	`n = ent_names[i];`
		10726	`LIST_ELEM(`
		10727	`o_make_capsule_link(`
		10728	`{ out_tdfident_bytes(n);},`
		10729	`out_tdfint32(UL(capsule_names[i]))))`
		10730	`}`
		10731	`},`
		10732	`{`
		10733	`for (i=0; i<NO_OF_ENTITIES; i++) {`
		10734	`TDF * lks = lk_externs+i;`
		10735	`LIST_ELEM(`
		10736	`o_make_extern_link(`
		10737	`{ append_TDF(lks,1); current_TDF->no = lks->no; });`
		10738	`)`
		10739	`}`
		10740	`},`
		10741	`{`
		10742	`for (i=0; i<NO_OF_UNITS; i++) {`
		10743	`if (units[i].present) {`
		10744	`LIST_ELEM(`
		10745	`o_make_group(LIST_ELEM(make_unit(i))););`
		10746	`}`
		10747	`}`
		10748	`}`
		10749	`);`
		10750	`make_tdf_file(&caps, out_file);`
		10751	`}`
		10752	`}`
		10753	`}`
		10754	`break;`
		10755	`case 130:`
		10756	`return;`
		10757	`default:`
		10758	`goto ZL1;`
		10759	`}`
		10760	`return;`
		10761	`ZL1:;`
		10762	`SAVE_LEXER (130);`
		10763	`return;`
		10764	`}`
		10765
		10766	`static void`
		10767	`ZR632(void)`
		10768	`{`
		10769	`switch (CURRENT_TERMINAL) {`
		10770	`case 3: case 10: case 36: case 63: case 68:`
		10771	`case 103:`
		10772	`{`
		10773	`TDF ZIa;`
		10774	`TDF ZIb;`
		10775	`PTR_TDF ZIc;`
		10776	`PTR_char ZId;`
		10777
		10778	`{`
		10779
		10780	`(ZId) = lex_v.val.name;`
		10781	`(ZIa) = *current_TDF;`
		10782	`SET_TDF((ZIc), &(ZIb));`
		10783	`}`
		10784	`ZR672 (&ZIa, &ZIb, &ZIc, &ZId);`
		10785	`if ((CURRENT_TERMINAL) == 130) {`
		10786	`RESTORE_LEXER;`
		10787	`goto ZL1;`
		10788	`}`
		10789	`}`
		10790	`break;`
		10791	`case 130:`
		10792	`return;`
		10793	`default:`
		10794	`break;`
		10795	`}`
		10796	`return;`
		10797	`ZL1:;`
		10798	`SAVE_LEXER (130);`
		10799	`return;`
		10800	`}`
		10801
		10802	`static void`
		10803	`ZRkeep__list__opt(void)`
		10804	`{`
		10805	`switch (CURRENT_TERMINAL) {`
		10806	`case 2: case 5: case 9: case 15: case 18:`
		10807	`case 40: case 43: case 49: case 54: case 60:`
		10808	`case 71: case 75: case 91: case 96: case 100:`
		10809	`case 111: case 120: case 128:`
		10810	`{`
		10811	`ZRkeep__list ();`
		10812	`if ((CURRENT_TERMINAL) == 130) {`
		10813	`RESTORE_LEXER;`
		10814	`goto ZL1;`
		10815	`}`
		10816	`}`
		10817	`break;`
		10818	`case 130:`
		10819	`return;`
		10820	`default:`
		10821	`break;`
		10822	`}`
		10823	`return;`
		10824	`ZL1:;`
		10825	`SAVE_LEXER (130);`
		10826	`return;`
		10827	`}`
		10828
		10829	`static void`
		10830	`ZR633(void)`
		10831	`{`
		10832	`ZL2_633:;`
		10833	`switch (CURRENT_TERMINAL) {`
		10834	`case 24:`
		10835	`{`
		10836	`ADVANCE_LEXER;`
		10837	`ZRsigned__nat__body ();`
		10838	`if ((CURRENT_TERMINAL) == 130) {`
		10839	`RESTORE_LEXER;`
		10840	`goto ZL1;`
		10841	`}`
		10842	`}`
		10843	`break;`
		10844	`case 86:`
		10845	`{`
		10846	`TDF ZIa;`
		10847	`TDF ZIb;`
		10848	`TDF ZIc;`
		10849	`PTR_TDF ZId;`
		10850
		10851	`ADVANCE_LEXER;`
		10852	`{`
		10853
		10854	`/* (ZIb), (ZIc) uninitialised */`
		10855	`SET_TDF((ZId), &(ZIa));`
		10856	`}`
		10857	`switch (CURRENT_TERMINAL) {`
		10858	`case 78:`
		10859	`break;`
		10860	`default:`
		10861	`goto ZL1;`
		10862	`}`
		10863	`ADVANCE_LEXER;`
		10864	`read_exp ();`
		10865	`if ((CURRENT_TERMINAL) == 130) {`
		10866	`RESTORE_LEXER;`
		10867	`goto ZL1;`
		10868	`}`
		10869	`{`
		10870
		10871	`RESET_TDF((ZId));`
		10872	`SET_TDF((ZId), &(ZIb));`
		10873	`}`
		10874	`switch (CURRENT_TERMINAL) {`
		10875	`case 25:`
		10876	`break;`
		10877	`default:`
		10878	`goto ZL1;`
		10879	`}`
		10880	`ADVANCE_LEXER;`
		10881	`ZRsigned__nat__body ();`
		10882	`if ((CURRENT_TERMINAL) == 130) {`
		10883	`RESTORE_LEXER;`
		10884	`goto ZL1;`
		10885	`}`
		10886	`{`
		10887
		10888	`RESET_TDF((ZId));`
		10889	`SET_TDF((ZId), &(ZIc));`
		10890	`}`
		10891	`switch (CURRENT_TERMINAL) {`
		10892	`case 25:`
		10893	`break;`
		10894	`default:`
		10895	`goto ZL1;`
		10896	`}`
		10897	`ADVANCE_LEXER;`
		10898	`ZRsigned__nat__body ();`
		10899	`if ((CURRENT_TERMINAL) == 130) {`
		10900	`RESTORE_LEXER;`
		10901	`goto ZL1;`
		10902	`}`
		10903	`{`
		10904
		10905	`RESET_TDF((ZId));`
		10906	`o_signed_nat_cond(append_TDF(&(ZIa),1), append_TDF(&(ZIb),1),`
		10907	`append_TDF(&(ZIc),1));`
		10908	`}`
		10909	`switch (CURRENT_TERMINAL) {`
		10910	`case 29:`
		10911	`break;`
		10912	`default:`
		10913	`goto ZL1;`
		10914	`}`
		10915	`ADVANCE_LEXER;`
		10916	`}`
		10917	`break;`
		10918	`case 130:`
		10919	`return;`
		10920	`default:`
		10921	`goto ZL1;`
		10922	`}`
		10923	`return;`
		10924	`ZL1:;`
		10925	`SAVE_LEXER (130);`
		10926	`return;`
		10927	`}`
		10928
		10929	`static void`
		10930	`ZRal__tag__def(void)`
		10931	`{`
		10932	`if ((CURRENT_TERMINAL) == 130) {`
		10933	`return;`
		10934	`}`
		10935	`{`
		10936	`PTR_Al_tagdec ZIa;`
		10937	`TDF ZIb;`
		10938	`PTR_TDF ZIc;`
		10939	`int ZId;`
		10940
		10941	`switch (CURRENT_TERMINAL) {`
		10942	`case 6:`
		10943	`break;`
		10944	`default:`
		10945	`goto ZL1;`
		10946	`}`
		10947	`ADVANCE_LEXER;`
		10948	`{`
		10949
		10950	`char * n =lex_v.val.name;`
		10951	`(ZIa) = find_al_tag(n);`
		10952	`SELECT_UNIT(al_tagdef_unit);`
		10953	`if ((ZIa)== (Al_tagdec*)0) {`
		10954	`(ZIa)= MALLOC(Al_tagdec); (ZIa)->isdeffed =0; (ZIa)->iskept=0; (ZIa)->isused=0;`
		10955	`NEW_IDNAME((ZIa)->idname, n, al_tag_ent);`
		10956	`(ZIa)->next = al_tagdecs; al_tagdecs = (ZIa);`
		10957	`(ZId) = 0;`
		10958	`}`
		10959	`else (ZId) = 1;`
		10960	`if ((ZIa)->isdeffed) { fail("Al_tag %s defined twice", n); }`
		10961	`(ZIa)->isdeffed = 1;`
		10962	`SET_TDF((ZIc), &(ZIb));`
		10963	`}`
		10964	`switch (CURRENT_TERMINAL) {`
		10965	`case 54:`
		10966	`break;`
		10967	`default:`
		10968	`goto ZL1;`
		10969	`}`
		10970	`ADVANCE_LEXER;`
		10971	`switch (CURRENT_TERMINAL) {`
		10972	`case 36:`
		10973	`break;`
		10974	`default:`
		10975	`goto ZL1;`
		10976	`}`
		10977	`ADVANCE_LEXER;`
		10978	`read_alignment ();`
		10979	`if ((CURRENT_TERMINAL) == 130) {`
		10980	`RESTORE_LEXER;`
		10981	`goto ZL1;`
		10982	`}`
		10983	`{`
		10984
		10985	`RESET_TDF((ZIc));`
		10986	`o_make_al_tagdef(if ((ZId)) {`
		10987	`out_tdfint32(UL(non_local(&(ZIa)->idname.name,al_tag_ent)));`
		10988	`} else {`
		10989	`out_tdfint32(LOCNAME((ZIa)->idname));`
		10990	`},`
		10991	`append_TDF(&(ZIb), 1)`
		10992	`);`
		10993	`INC_LIST;`
		10994	`}`
		10995	`}`
		10996	`return;`
		10997	`ZL1:;`
		10998	`SAVE_LEXER (130);`
		10999	`return;`
		11000	`}`
		11001
		11002	`static void`
		11003	`ZRotagexp(void)`
		11004	`{`
		11005	`if ((CURRENT_TERMINAL) == 130) {`
		11006	`return;`
		11007	`}`
		11008	`{`
		11009	`TDF ZIa;`
		11010	`PTR_TDF ZIb;`
		11011
		11012	`{`
		11013
		11014	`SET_TDF((ZIb), &(ZIa));`
		11015	`}`
		11016	`read_exp ();`
		11017	`ZR655 (&ZIa, &ZIb);`
		11018	`if ((CURRENT_TERMINAL) == 130) {`
		11019	`RESTORE_LEXER;`
		11020	`goto ZL1;`
		11021	`}`
		11022	`}`
		11023	`return;`
		11024	`ZL1:;`
		11025	`SAVE_LEXER (130);`
		11026	`return;`
		11027	`}`
		11028
		11029	`void`
		11030	`read_program(void)`
		11031	`{`
		11032	`if ((CURRENT_TERMINAL) == 130) {`
		11033	`return;`
		11034	`}`
		11035	`{`
		11036	`ZRelement__list__opt ();`
		11037	`ZR630 ();`
		11038	`if ((CURRENT_TERMINAL) == 130) {`
		11039	`RESTORE_LEXER;`
		11040	`goto ZL1;`
		11041	`}`
		11042	`}`
		11043	`return;`
		11044	`ZL1:;`
		11045	`{`
		11046	`{`
		11047
		11048	`fail("Syntax error");`
		11049	`}`
		11050	`}`
		11051	`}`
		11052
		11053	`static void`
		11054	`ZR634(void)`
		11055	`{`
		11056	`switch (CURRENT_TERMINAL) {`
		11057	`case 22: case 55:`
		11058	`{`
		11059	`ZRinteger ();`
		11060	`if ((CURRENT_TERMINAL) == 130) {`
		11061	`RESTORE_LEXER;`
		11062	`goto ZL1;`
		11063	`}`
		11064	`{`
		11065
		11066	`o_make_signed_nat(out_tdfbool(1), out_tdfint32(intvalue));`
		11067	`}`
		11068	`}`
		11069	`break;`
		11070	`case 69: case 70: case 71:`
		11071	`{`
		11072	`TDF ZIa;`
		11073	`PTR_TDF ZIb;`
		11074
		11075	`{`
		11076
		11077	`SET_TDF((ZIb), &(ZIa));`
		11078	`}`
		11079	`ZRnat__not__int ();`
		11080	`if ((CURRENT_TERMINAL) == 130) {`
		11081	`RESTORE_LEXER;`
		11082	`goto ZL1;`
		11083	`}`
		11084	`{`
		11085
		11086	`RESET_TDF((ZIb));`
		11087	`o_snat_from_nat(o_true, append_TDF(&(ZIa),1));`
		11088	`}`
		11089	`}`
		11090	`break;`
		11091	`case 130:`
		11092	`return;`
		11093	`default:`
		11094	`goto ZL1;`
		11095	`}`
		11096	`return;`
		11097	`ZL1:;`
		11098	`SAVE_LEXER (130);`
		11099	`return;`
		11100	`}`
		11101
		11102	`/* BEGINNING OF TRAILER */`
		11103
		11104
		11105
		11106	`/* END OF FILE */`

Subversion Repositories tendra.SVN

(root)/branches/algol60/src/tools/tpl/syntax.c – Rev 7