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

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

Subversion Repositories tendra.SVN

(root)/branches/tendra5-amd64/src/utilities/calculus/syntax.c – Rev 123