WebSVN – tendra.SVN – Blame – /branches/tendra5/src/utilities/calculus/syntax.c

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

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/utilities/calculus/syntax.c – Rev 2