WebSVN – tendra.SVN – Blame – /branches/tendra5/src/tools/tpl/decodings.c

Rev	Author	Line No.	Line
6	7u83	1	`/*`
		2	`* Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.`
		3	`* All rights reserved.`
		4	`*`
		5	`* Redistribution and use in source and binary forms, with or without`
		6	`* modification, are permitted provided that the following conditions are met:`
		7	`*`
		8	`* 1. Redistributions of source code must retain the above copyright notice,`
		9	`* this list of conditions and the following disclaimer.`
		10	`* 2. Redistributions in binary form must reproduce the above copyright notice,`
		11	`* this list of conditions and the following disclaimer in the documentation`
		12	`* and/or other materials provided with the distribution.`
		13	`* 3. Neither the name of The TenDRA Project nor the names of its contributors`
		14	`* may be used to endorse or promote products derived from this software`
		15	`* without specific, prior written permission.`
		16	`*`
		17	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
		18	`* IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,`
		19	`* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR`
		20	`* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR`
		21	`* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,`
		22	`* EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,`
		23	`* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;`
		24	`* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,`
		25	`* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR`
		26	`* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF`
		27	`* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.`
		28	`*`
		29	`* $Id$`
		30	`*/`
		31	`/*`
		32	`Crown Copyright (c) 1997`
		33
		34	`This TenDRA(r) Computer Program is subject to Copyright`
		35	`owned by the United Kingdom Secretary of State for Defence`
		36	`acting through the Defence Evaluation and Research Agency`
		37	`(DERA). It is made available to Recipients with a`
		38	`royalty-free licence for its use, reproduction, transfer`
		39	`to other parties and amendment for any purpose not excluding`
		40	`product development provided that any such use et cetera`
		41	`shall be deemed to be acceptance of the following conditions:-`
		42
		43	`(1) Its Recipients shall ensure that this Notice is`
		44	`reproduced upon any copies or amended versions of it;`
		45
		46	`(2) Any amended version of it shall be clearly marked to`
		47	`show both the nature of and the organisation responsible`
		48	`for the relevant amendment or amendments;`
		49
		50	`(3) Its onward transfer from a recipient to another`
		51	`party shall be deemed to be that party's acceptance of`
		52	`these conditions;`
		53
		54	`(4) DERA gives no warranty or assurance as to its`
		55	`quality or suitability for any purpose and DERA accepts`
		56	`no liability whatsoever in relation to any use to which`
		57	`it may be put.`
		58	`*/`
		59
		60
		61	`#include "config.h"`
		62	`#include "enc_nos.h"`
		63	`#include "errors.h"`
		64	`#include "readstreams.h"`
		65	`#include "decodings.h"`
		66
		67
		68	`/* DECODE ACCESS */`
		69
		70	`unsigned int`
		71	`d_access(int n)`
		72	`{`
		73	`unsigned int enc = get_basic_int(4, 1);`
		74	`switch (enc) {`
		75	`case e_access_apply_token:`
		76	`consname("access_apply_token", n);`
		77	`IGNORE d_token(n + 1);`
		78	`IGNORE d_bitstream("access_apply_token", n + 1);`
		79	`break;`
		80	`case e_access_cond:`
		81	`consname("access_cond", n);`
		82	`IGNORE d_exp(n + 1);`
		83	`IGNORE d_bitstream("access_cond", n + 1);`
		84	`IGNORE d_bitstream("access_cond", n + 1);`
		85	`break;`
		86	`case e_add_accesses:`
		87	`consname("add_accesses", n);`
		88	`IGNORE d_access(n + 1);`
		89	`IGNORE d_access(n + 1);`
		90	`break;`
		91	`case e_constant:`
		92	`consname("constant", n);`
		93	`break;`
		94	`case e_long_jump_access:`
		95	`consname("long_jump_access", n);`
		96	`break;`
		97	`case e_no_other_read:`
		98	`consname("no_other_read", n);`
		99	`break;`
		100	`case e_no_other_write:`
		101	`consname("no_other_write", n);`
		102	`break;`
		103	`case e_out_par:`
		104	`consname("out_par", n);`
		105	`break;`
		106	`case e_preserve:`
		107	`consname("preserve", n);`
		108	`break;`
		109	`case e_register:`
		110	`consname("register", n);`
		111	`break;`
		112	`case e_standard_access:`
		113	`consname("standard_access", n);`
		114	`break;`
		115	`case e_used_as_volatile:`
		116	`consname("used_as_volatile", n);`
		117	`break;`
		118	`case e_visible:`
		119	`consname("visible", n);`
		120	`break;`
		121	`default:`
		122	`fail("Bad access value, 0", enc);`
		123	`break;`
		124	`}`
		125	`return(enc);`
		126	`}`
		127
		128
		129	`/* DECODE OPTIONAL ACCESS */`
		130
		131	`unsigned int`
		132	`d_access_option(int n)`
		133	`{`
		134	`unsigned int nl = get_basic_int(1, 0);`
		135	`if (nl) {`
		136	`IGNORE d_access(n);`
		137	`}`
		138	`return(nl);`
		139	`}`
		140
		141
		142	`/* DECODE AL_TAG */`
		143
		144	`unsigned int`
		145	`d_al_tag(int n)`
		146	`{`
		147	`unsigned int enc = get_basic_int(1, 1);`
		148	`switch (enc) {`
		149	`case e_al_tag_apply_token:`
		150	`consname("al_tag_apply_token", n);`
		151	`IGNORE d_token(n + 1);`
		152	`IGNORE d_bitstream("al_tag_apply_token", n + 1);`
		153	`break;`
		154	`case e_make_al_tag:`
		155	`consname("make_al_tag", n);`
		156	`IGNORE d_tdfint(n + 1);`
		157	`break;`
		158	`default:`
		159	`fail("Bad al_tag value, 1", enc);`
		160	`break;`
		161	`}`
		162	`return(enc);`
		163	`}`
		164
		165
		166	`/* DECODE AL_TAGDEF */`
		167
		168	`unsigned int`
		169	`d_al_tagdef(int n)`
		170	`{`
		171	`unsigned int enc = get_basic_int(1, 1);`
		172	`switch (enc) {`
		173	`case e_make_al_tagdef:`
		174	`consname("make_al_tagdef", n);`
		175	`IGNORE d_tdfint(n + 1);`
		176	`IGNORE d_alignment(n + 1);`
		177	`break;`
		178	`default:`
		179	`fail("Bad al_tagdef value, 2", enc);`
		180	`break;`
		181	`}`
		182	`return(enc);`
		183	`}`
		184
		185
		186	`/* DECODE SIMPLE AL_TAGDEF LIST */`
		187
		188	`unsigned int`
		189	`d_al_tagdef_list(int n)`
		190	`{`
		191	`unsigned int nl = get_tdfint();`
		192	`for (; nl != 0; nl--) {`
		193	`IGNORE d_al_tagdef(n + 1);`
		194	`}`
		195	`return(nl);`
		196	`}`
		197
		198
		199	`/* DECODE AL_TAGDEF_PROPS */`
		200
		201	`unsigned int`
		202	`d_al_tagdef_props(int n)`
		203	`{`
		204	`consname("make_al_tagdefs", n);`
		205	`IGNORE d_tdfint(n + 1);`
		206	`IGNORE d_al_tagdef_list(n + 1);`
		207	`return(0);`
		208	`}`
		209
		210
		211	`/* DECODE ALIGNMENT */`
		212
		213	`unsigned int`
		214	`d_alignment(int n)`
		215	`{`
		216	`unsigned int enc = get_basic_int(4, 1);`
		217	`switch (enc) {`
		218	`case e_alignment_apply_token:`
		219	`consname("alignment_apply_token", n);`
		220	`IGNORE d_token(n + 1);`
		221	`IGNORE d_bitstream("alignment_apply_token", n + 1);`
		222	`break;`
		223	`case e_alignment_cond:`
		224	`consname("alignment_cond", n);`
		225	`IGNORE d_exp(n + 1);`
		226	`IGNORE d_bitstream("alignment_cond", n + 1);`
		227	`IGNORE d_bitstream("alignment_cond", n + 1);`
		228	`break;`
		229	`case e_alignment:`
		230	`consname("alignment", n);`
		231	`IGNORE d_shape(n + 1);`
		232	`break;`
		233	`case e_alloca_alignment:`
		234	`consname("alloca_alignment", n);`
		235	`break;`
		236	`case e_callees_alignment:`
		237	`consname("callees_alignment", n);`
		238	`IGNORE d_bool(n + 1);`
		239	`break;`
		240	`case e_callers_alignment:`
		241	`consname("callers_alignment", n);`
		242	`IGNORE d_bool(n + 1);`
		243	`break;`
		244	`case e_code_alignment:`
		245	`consname("code_alignment", n);`
		246	`break;`
		247	`case e_locals_alignment:`
		248	`consname("locals_alignment", n);`
		249	`break;`
		250	`case e_obtain_al_tag:`
		251	`consname("obtain_al_tag", n);`
		252	`IGNORE d_al_tag(n + 1);`
		253	`break;`
		254	`case e_parameter_alignment:`
		255	`consname("parameter_alignment", n);`
		256	`IGNORE d_shape(n + 1);`
		257	`break;`
		258	`case e_unite_alignments:`
		259	`consname("unite_alignments", n);`
		260	`IGNORE d_alignment(n + 1);`
		261	`IGNORE d_alignment(n + 1);`
		262	`break;`
		263	`case e_var_param_alignment:`
		264	`consname("var_param_alignment", n);`
		265	`break;`
		266	`default:`
		267	`fail("Bad alignment value, 3", enc);`
		268	`break;`
		269	`}`
		270	`return(enc);`
		271	`}`
		272
		273
		274	`/* DECODE BITFIELD_VARIETY */`
		275
		276	`unsigned int`
		277	`d_bitfield_variety(int n)`
		278	`{`
		279	`unsigned int enc = get_basic_int(2, 1);`
		280	`switch (enc) {`
		281	`case e_bfvar_apply_token:`
		282	`consname("bfvar_apply_token", n);`
		283	`IGNORE d_token(n + 1);`
		284	`IGNORE d_bitstream("bfvar_apply_token", n + 1);`
		285	`break;`
		286	`case e_bfvar_cond:`
		287	`consname("bfvar_cond", n);`
		288	`IGNORE d_exp(n + 1);`
		289	`IGNORE d_bitstream("bfvar_cond", n + 1);`
		290	`IGNORE d_bitstream("bfvar_cond", n + 1);`
		291	`break;`
		292	`case e_bfvar_bits:`
		293	`consname("bfvar_bits", n);`
		294	`IGNORE d_bool(n + 1);`
		295	`IGNORE d_nat(n + 1);`
		296	`break;`
		297	`default:`
		298	`fail("Bad bitfield_variety value, 4", enc);`
		299	`break;`
		300	`}`
		301	`return(enc);`
		302	`}`
		303
		304
		305	`/* DECODE BOOL */`
		306
		307	`unsigned int`
		308	`d_bool(int n)`
		309	`{`
		310	`unsigned int enc = get_basic_int(3, 1);`
		311	`switch (enc) {`
		312	`case e_bool_apply_token:`
		313	`consname("bool_apply_token", n);`
		314	`IGNORE d_token(n + 1);`
		315	`IGNORE d_bitstream("bool_apply_token", n + 1);`
		316	`break;`
		317	`case e_bool_cond:`
		318	`consname("bool_cond", n);`
		319	`IGNORE d_exp(n + 1);`
		320	`IGNORE d_bitstream("bool_cond", n + 1);`
		321	`IGNORE d_bitstream("bool_cond", n + 1);`
		322	`break;`
		323	`case e_false:`
		324	`consname("false", n);`
		325	`break;`
		326	`case e_true:`
		327	`consname("true", n);`
		328	`break;`
		329	`default:`
		330	`fail("Bad bool value, 5", enc);`
		331	`break;`
		332	`}`
		333	`return(enc);`
		334	`}`
		335
		336
		337	`/* DECODE CALLEES */`
		338
		339	`unsigned int`
		340	`d_callees(int n)`
		341	`{`
		342	`unsigned int enc = get_basic_int(2, 1);`
		343	`switch (enc) {`
		344	`case e_make_callee_list:`
		345	`consname("make_callee_list", n);`
		346	`IGNORE d_exp_list(n + 1);`
		347	`break;`
		348	`case e_make_dynamic_callees:`
		349	`consname("make_dynamic_callees", n);`
		350	`IGNORE d_exp(n + 1);`
		351	`IGNORE d_exp(n + 1);`
		352	`break;`
		353	`case e_same_callees:`
		354	`consname("same_callees", n);`
		355	`break;`
		356	`default:`
		357	`fail("Bad callees value, 6", enc);`
		358	`break;`
		359	`}`
		360	`return(enc);`
		361	`}`
		362
		363
		364	`/* DECODE CAPSULE */`
		365
		366	`unsigned int`
		367	`d_capsule(int n)`
		368	`{`
		369	`consname("make_capsule", n);`
		370	`IGNORE d_tdfident_list(n + 1);`
		371	`IGNORE d_capsule_link_list(n + 1);`
		372	`IGNORE d_extern_link_list(n + 1);`
		373	`IGNORE d_group_list(n + 1);`
		374	`return(0);`
		375	`}`
		376
		377
		378	`/* DECODE CAPSULE_LINK */`
		379
		380	`unsigned int`
		381	`d_capsule_link(int n)`
		382	`{`
		383	`consname("make_capsule_link", n);`
		384	`IGNORE d_tdfident(n + 1);`
		385	`IGNORE d_tdfint(n + 1);`
		386	`return(0);`
		387	`}`
		388
		389
		390	`/* DECODE SIMPLE CAPSULE_LINK LIST */`
		391
		392	`unsigned int`
		393	`d_capsule_link_list(int n)`
		394	`{`
		395	`unsigned int nl = get_tdfint();`
		396	`for (; nl != 0; nl--) {`
		397	`IGNORE d_capsule_link(n + 1);`
		398	`}`
		399	`return(nl);`
		400	`}`
		401
		402
		403	`/* DECODE CASELIM */`
		404
		405	`unsigned int`
		406	`d_caselim(int n)`
		407	`{`
		408	`consname("make_caselim", n);`
		409	`IGNORE d_label(n + 1);`
		410	`IGNORE d_signed_nat(n + 1);`
		411	`IGNORE d_signed_nat(n + 1);`
		412	`return(0);`
		413	`}`
		414
		415
		416	`/* DECODE CASELIM LIST */`
		417
		418	`unsigned int`
		419	`d_caselim_list(int n)`
		420	`{`
		421	`unsigned int nl;`
		422	`IGNORE get_basic_int(1, 0);`
		423	`nl = get_tdfint();`
		424	`for (; nl != 0; nl--) {`
		425	`IGNORE d_caselim(n + 1);`
		426	`}`
		427	`return(nl);`
		428	`}`
		429
		430
		431	`/* DECODE DIAG_DESCRIPTOR */`
		432
		433	`unsigned int`
		434	`d_diag_descriptor(int n)`
		435	`{`
		436	`unsigned int enc = get_basic_int(2, 1);`
		437	`switch (enc) {`
		438	`case e_diag_desc_id:`
		439	`consname("diag_desc_id", n);`
		440	`IGNORE d_tdfstring(n + 1);`
		441	`IGNORE d_sourcemark(n + 1);`
		442	`IGNORE d_exp(n + 1);`
		443	`IGNORE d_diag_type(n + 1);`
		444	`break;`
		445	`case e_diag_desc_struct:`
		446	`consname("diag_desc_struct", n);`
		447	`IGNORE d_tdfstring(n + 1);`
		448	`IGNORE d_sourcemark(n + 1);`
		449	`IGNORE d_diag_type(n + 1);`
		450	`break;`
		451	`case e_diag_desc_typedef:`
		452	`consname("diag_desc_typedef", n);`
		453	`IGNORE d_tdfstring(n + 1);`
		454	`IGNORE d_sourcemark(n + 1);`
		455	`IGNORE d_diag_type(n + 1);`
		456	`break;`
		457	`default:`
		458	`fail("Bad diag_descriptor value, 7", enc);`
		459	`break;`
		460	`}`
		461	`return(enc);`
		462	`}`
		463
		464
		465	`/* DECODE SIMPLE DIAG_DESCRIPTOR LIST */`
		466
		467	`unsigned int`
		468	`d_diag_descriptor_list(int n)`
		469	`{`
		470	`unsigned int nl = get_tdfint();`
		471	`for (; nl != 0; nl--) {`
		472	`IGNORE d_diag_descriptor(n + 1);`
		473	`}`
		474	`return(nl);`
		475	`}`
		476
		477
		478	`/* DECODE DIAG_FIELD */`
		479
		480	`unsigned int`
		481	`d_diag_field(int n)`
		482	`{`
		483	`consname("make_diag_field", n);`
		484	`IGNORE d_tdfstring(n + 1);`
		485	`IGNORE d_exp(n + 1);`
		486	`IGNORE d_diag_type(n + 1);`
		487	`return(0);`
		488	`}`
		489
		490
		491	`/* DECODE DIAG_FIELD LIST */`
		492
		493	`unsigned int`
		494	`d_diag_field_list(int n)`
		495	`{`
		496	`unsigned int nl;`
		497	`IGNORE get_basic_int(1, 0);`
		498	`nl = get_tdfint();`
		499	`for (; nl != 0; nl--) {`
		500	`IGNORE d_diag_field(n + 1);`
		501	`}`
		502	`return(nl);`
		503	`}`
		504
		505
		506	`/* DECODE DIAG_TAG */`
		507
		508	`unsigned int`
		509	`d_diag_tag(int n)`
		510	`{`
		511	`unsigned int enc = get_basic_int(1, 1);`
		512	`switch (enc) {`
		513	`case e_make_diag_tag:`
		514	`consname("make_diag_tag", n);`
		515	`IGNORE d_tdfint(n + 1);`
		516	`break;`
		517	`default:`
		518	`fail("Bad diag_tag value, 8", enc);`
		519	`break;`
		520	`}`
		521	`return(enc);`
		522	`}`
		523
		524
		525	`/* DECODE DIAG_TAGDEF */`
		526
		527	`unsigned int`
		528	`d_diag_tagdef(int n)`
		529	`{`
		530	`unsigned int enc = get_basic_int(1, 1);`
		531	`switch (enc) {`
		532	`case e_make_diag_tagdef:`
		533	`consname("make_diag_tagdef", n);`
		534	`IGNORE d_tdfint(n + 1);`
		535	`IGNORE d_diag_type(n + 1);`
		536	`break;`
		537	`default:`
		538	`fail("Bad diag_tagdef value, 9", enc);`
		539	`break;`
		540	`}`
		541	`return(enc);`
		542	`}`
		543
		544
		545	`/* DECODE SIMPLE DIAG_TAGDEF LIST */`
		546
		547	`unsigned int`
		548	`d_diag_tagdef_list(int n)`
		549	`{`
		550	`unsigned int nl = get_tdfint();`
		551	`for (; nl != 0; nl--) {`
		552	`IGNORE d_diag_tagdef(n + 1);`
		553	`}`
		554	`return(nl);`
		555	`}`
		556
		557
		558	`/* DECODE DIAG_TQ */`
		559
		560	`unsigned int`
		561	`d_diag_tq(int n)`
		562	`{`
		563	`unsigned int enc = get_basic_int(2, 1);`
		564	`switch (enc) {`
		565	`case e_add_diag_const:`
		566	`consname("add_diag_const", n);`
		567	`IGNORE d_diag_tq(n + 1);`
		568	`break;`
		569	`case e_add_diag_volatile:`
		570	`consname("add_diag_volatile", n);`
		571	`IGNORE d_diag_tq(n + 1);`
		572	`break;`
		573	`case e_diag_tq_null:`
		574	`consname("diag_tq_null", n);`
		575	`break;`
		576	`default:`
		577	`fail("Bad diag_tq value, 10", enc);`
		578	`break;`
		579	`}`
		580	`return(enc);`
		581	`}`
		582
		583
		584	`/* DECODE DIAG_TYPE */`
		585
		586	`unsigned int`
		587	`d_diag_type(int n)`
		588	`{`
		589	`unsigned int enc = get_basic_int(4, 1);`
		590	`switch (enc) {`
		591	`case e_diag_type_apply_token:`
		592	`consname("diag_type_apply_token", n);`
		593	`IGNORE d_token(n + 1);`
		594	`IGNORE d_bitstream("diag_type_apply_token", n + 1);`
		595	`break;`
		596	`case e_diag_array:`
		597	`consname("diag_array", n);`
		598	`IGNORE d_diag_type(n + 1);`
		599	`IGNORE d_exp(n + 1);`
		600	`IGNORE d_exp(n + 1);`
		601	`IGNORE d_exp(n + 1);`
		602	`IGNORE d_diag_type(n + 1);`
		603	`break;`
		604	`case e_diag_bitfield:`
		605	`consname("diag_bitfield", n);`
		606	`IGNORE d_diag_type(n + 1);`
		607	`IGNORE d_nat(n + 1);`
		608	`break;`
		609	`case e_diag_enum:`
		610	`consname("diag_enum", n);`
		611	`IGNORE d_diag_type(n + 1);`
		612	`IGNORE d_tdfstring(n + 1);`
		613	`IGNORE d_enum_values_list(n + 1);`
		614	`break;`
		615	`case e_diag_floating_variety:`
		616	`consname("diag_floating_variety", n);`
		617	`IGNORE d_floating_variety(n + 1);`
		618	`break;`
		619	`case e_diag_loc:`
		620	`consname("diag_loc", n);`
		621	`IGNORE d_diag_type(n + 1);`
		622	`IGNORE d_diag_tq(n + 1);`
		623	`break;`
		624	`case e_diag_proc:`
		625	`consname("diag_proc", n);`
		626	`IGNORE d_diag_type_list(n + 1);`
		627	`IGNORE d_bool(n + 1);`
		628	`IGNORE d_diag_type(n + 1);`
		629	`break;`
		630	`case e_diag_ptr:`
		631	`consname("diag_ptr", n);`
		632	`IGNORE d_diag_type(n + 1);`
		633	`IGNORE d_diag_tq(n + 1);`
		634	`break;`
		635	`case e_diag_struct:`
		636	`consname("diag_struct", n);`
		637	`IGNORE d_shape(n + 1);`
		638	`IGNORE d_tdfstring(n + 1);`
		639	`IGNORE d_diag_field_list(n + 1);`
		640	`break;`
		641	`case e_diag_type_null:`
		642	`consname("diag_type_null", n);`
		643	`break;`
		644	`case e_diag_union:`
		645	`consname("diag_union", n);`
		646	`IGNORE d_shape(n + 1);`
		647	`IGNORE d_tdfstring(n + 1);`
		648	`IGNORE d_diag_field_list(n + 1);`
		649	`break;`
		650	`case e_diag_variety:`
		651	`consname("diag_variety", n);`
		652	`IGNORE d_variety(n + 1);`
		653	`break;`
		654	`case e_use_diag_tag:`
		655	`consname("use_diag_tag", n);`
		656	`IGNORE d_diag_tag(n + 1);`
		657	`break;`
		658	`default:`
		659	`fail("Bad diag_type value, 11", enc);`
		660	`break;`
		661	`}`
		662	`return(enc);`
		663	`}`
		664
		665
		666	`/* DECODE DIAG_TYPE LIST */`
		667
		668	`unsigned int`
		669	`d_diag_type_list(int n)`
		670	`{`
		671	`unsigned int nl;`
		672	`IGNORE get_basic_int(1, 0);`
		673	`nl = get_tdfint();`
		674	`for (; nl != 0; nl--) {`
		675	`IGNORE d_diag_type(n + 1);`
		676	`}`
		677	`return(nl);`
		678	`}`
		679
		680
		681	`/* DECODE DIAG_TYPE_UNIT */`
		682
		683	`unsigned int`
		684	`d_diag_type_unit(int n)`
		685	`{`
		686	`consname("build_diagtype_unit", n);`
		687	`IGNORE d_tdfint(n + 1);`
		688	`IGNORE d_diag_tagdef_list(n + 1);`
		689	`return(0);`
		690	`}`
		691
		692
		693	`/* DECODE DIAG_UNIT */`
		694
		695	`unsigned int`
		696	`d_diag_unit(int n)`
		697	`{`
		698	`consname("build_diag_unit", n);`
		699	`IGNORE d_tdfint(n + 1);`
		700	`IGNORE d_diag_descriptor_list(n + 1);`
		701	`return(0);`
		702	`}`
		703
		704
		705	`/* DECODE ENUM_VALUES */`
		706
		707	`unsigned int`
		708	`d_enum_values(int n)`
		709	`{`
		710	`consname("make_enum_values", n);`
		711	`IGNORE d_exp(n + 1);`
		712	`IGNORE d_tdfstring(n + 1);`
		713	`return(0);`
		714	`}`
		715
		716
		717	`/* DECODE ENUM_VALUES LIST */`
		718
		719	`unsigned int`
		720	`d_enum_values_list(int n)`
		721	`{`
		722	`unsigned int nl;`
		723	`IGNORE get_basic_int(1, 0);`
		724	`nl = get_tdfint();`
		725	`for (; nl != 0; nl--) {`
		726	`IGNORE d_enum_values(n + 1);`
		727	`}`
		728	`return(nl);`
		729	`}`
		730
		731
		732	`/* DECODE ERROR_CODE */`
		733
		734	`unsigned int`
		735	`d_error_code(int n)`
		736	`{`
		737	`unsigned int enc = get_basic_int(2, 1);`
		738	`switch (enc) {`
		739	`case e_nil_access:`
		740	`consname("nil_access", n);`
		741	`break;`
		742	`case e_overflow:`
		743	`consname("overflow", n);`
		744	`break;`
		745	`case e_stack_overflow:`
		746	`consname("stack_overflow", n);`
		747	`break;`
		748	`default:`
		749	`fail("Bad error_code value, 12", enc);`
		750	`break;`
		751	`}`
		752	`return(enc);`
		753	`}`
		754
		755
		756	`/* DECODE ERROR_CODE LIST */`
		757
		758	`unsigned int`
		759	`d_error_code_list(int n)`
		760	`{`
		761	`unsigned int nl;`
		762	`IGNORE get_basic_int(1, 0);`
		763	`nl = get_tdfint();`
		764	`for (; nl != 0; nl--) {`
		765	`IGNORE d_error_code(n + 1);`
		766	`}`
		767	`return(nl);`
		768	`}`
		769
		770
		771	`/* DECODE ERROR_TREATMENT */`
		772
		773	`unsigned int`
		774	`d_error_treatment(int n)`
		775	`{`
		776	`unsigned int enc = get_basic_int(3, 1);`
		777	`switch (enc) {`
		778	`case e_errt_apply_token:`
		779	`consname("errt_apply_token", n);`
		780	`IGNORE d_token(n + 1);`
		781	`IGNORE d_bitstream("errt_apply_token", n + 1);`
		782	`break;`
		783	`case e_errt_cond:`
		784	`consname("errt_cond", n);`
		785	`IGNORE d_exp(n + 1);`
		786	`IGNORE d_bitstream("errt_cond", n + 1);`
		787	`IGNORE d_bitstream("errt_cond", n + 1);`
		788	`break;`
		789	`case e_continue:`
		790	`consname("continue", n);`
		791	`break;`
		792	`case e_error_jump:`
		793	`consname("error_jump", n);`
		794	`IGNORE d_label(n + 1);`
		795	`break;`
		796	`case e_trap:`
		797	`consname("trap", n);`
		798	`IGNORE d_error_code_list(n + 1);`
		799	`break;`
		800	`case e_wrap:`
		801	`consname("wrap", n);`
		802	`break;`
		803	`case e_impossible:`
		804	`consname("impossible", n);`
		805	`break;`
		806	`default:`
		807	`fail("Bad error_treatment value, 13", enc);`
		808	`break;`
		809	`}`
		810	`return(enc);`
		811	`}`
		812
		813
		814	`/* DECODE EXP */`
		815
		816	`unsigned int`
		817	`d_exp(int n)`
		818	`{`
		819	`unsigned int enc = get_basic_int(7, 1);`
		820	`switch (enc) {`
		821	`case e_exp_apply_token:`
		822	`consname("exp_apply_token", n);`
		823	`IGNORE d_token(n + 1);`
		824	`IGNORE d_bitstream("exp_apply_token", n + 1);`
		825	`break;`
		826	`case e_exp_cond:`
		827	`consname("exp_cond", n);`
		828	`IGNORE d_exp(n + 1);`
		829	`IGNORE d_bitstream("exp_cond", n + 1);`
		830	`IGNORE d_bitstream("exp_cond", n + 1);`
		831	`break;`
		832	`case e_abs:`
		833	`consname("abs", n);`
		834	`IGNORE d_error_treatment(n + 1);`
		835	`IGNORE d_exp(n + 1);`
		836	`break;`
		837	`case e_add_to_ptr:`
		838	`consname("add_to_ptr", n);`
		839	`IGNORE d_exp(n + 1);`
		840	`IGNORE d_exp(n + 1);`
		841	`break;`
		842	`case e_and:`
		843	`consname("and", n);`
		844	`IGNORE d_exp(n + 1);`
		845	`IGNORE d_exp(n + 1);`
		846	`break;`
		847	`case e_apply_proc:`
		848	`consname("apply_proc", n);`
		849	`IGNORE d_shape(n + 1);`
		850	`IGNORE d_exp(n + 1);`
		851	`IGNORE d_exp_list(n + 1);`
		852	`IGNORE d_exp_option(n + 1);`
		853	`break;`
		854	`case e_apply_general_proc:`
		855	`consname("apply_general_proc", n);`
		856	`IGNORE d_shape(n + 1);`
		857	`IGNORE d_procprops_option(n + 1);`
		858	`IGNORE d_exp(n + 1);`
		859	`IGNORE d_otagexp_list(n + 1);`
		860	`IGNORE d_callees(n + 1);`
		861	`IGNORE d_exp(n + 1);`
		862	`break;`
		863	`case e_assign:`
		864	`consname("assign", n);`
		865	`IGNORE d_exp(n + 1);`
		866	`IGNORE d_exp(n + 1);`
		867	`break;`
		868	`case e_assign_with_mode:`
		869	`consname("assign_with_mode", n);`
		870	`IGNORE d_transfer_mode(n + 1);`
		871	`IGNORE d_exp(n + 1);`
		872	`IGNORE d_exp(n + 1);`
		873	`break;`
		874	`case e_bitfield_assign:`
		875	`consname("bitfield_assign", n);`
		876	`IGNORE d_exp(n + 1);`
		877	`IGNORE d_exp(n + 1);`
		878	`IGNORE d_exp(n + 1);`
		879	`break;`
		880	`case e_bitfield_assign_with_mode:`
		881	`consname("bitfield_assign_with_mode", n);`
		882	`IGNORE d_transfer_mode(n + 1);`
		883	`IGNORE d_exp(n + 1);`
		884	`IGNORE d_exp(n + 1);`
		885	`IGNORE d_exp(n + 1);`
		886	`break;`
		887	`case e_bitfield_contents:`
		888	`consname("bitfield_contents", n);`
		889	`IGNORE d_bitfield_variety(n + 1);`
		890	`IGNORE d_exp(n + 1);`
		891	`IGNORE d_exp(n + 1);`
		892	`break;`
		893	`case e_bitfield_contents_with_mode:`
		894	`consname("bitfield_contents_with_mode", n);`
		895	`IGNORE d_transfer_mode(n + 1);`
		896	`IGNORE d_bitfield_variety(n + 1);`
		897	`IGNORE d_exp(n + 1);`
		898	`IGNORE d_exp(n + 1);`
		899	`break;`
		900	`case e_case:`
		901	`consname("case", n);`
		902	`IGNORE d_bool(n + 1);`
		903	`IGNORE d_exp(n + 1);`
		904	`IGNORE d_caselim_list(n + 1);`
		905	`break;`
		906	`case e_change_bitfield_to_int:`
		907	`consname("change_bitfield_to_int", n);`
		908	`IGNORE d_variety(n + 1);`
		909	`IGNORE d_exp(n + 1);`
		910	`break;`
		911	`case e_change_floating_variety:`
		912	`consname("change_floating_variety", n);`
		913	`IGNORE d_error_treatment(n + 1);`
		914	`IGNORE d_floating_variety(n + 1);`
		915	`IGNORE d_exp(n + 1);`
		916	`break;`
		917	`case e_change_variety:`
		918	`consname("change_variety", n);`
		919	`IGNORE d_error_treatment(n + 1);`
		920	`IGNORE d_variety(n + 1);`
		921	`IGNORE d_exp(n + 1);`
		922	`break;`
		923	`case e_change_int_to_bitfield:`
		924	`consname("change_int_to_bitfield", n);`
		925	`IGNORE d_bitfield_variety(n + 1);`
		926	`IGNORE d_exp(n + 1);`
		927	`break;`
		928	`case e_complex_conjugate:`
		929	`consname("complex_conjugate", n);`
		930	`IGNORE d_exp(n + 1);`
		931	`break;`
		932	`case e_component:`
		933	`consname("component", n);`
		934	`IGNORE d_shape(n + 1);`
		935	`IGNORE d_exp(n + 1);`
		936	`IGNORE d_exp(n + 1);`
		937	`break;`
		938	`case e_concat_nof:`
		939	`consname("concat_nof", n);`
		940	`IGNORE d_exp(n + 1);`
		941	`IGNORE d_exp(n + 1);`
		942	`break;`
		943	`case e_conditional:`
		944	`consname("conditional", n);`
		945	`IGNORE d_label(n + 1);`
		946	`IGNORE d_exp(n + 1);`
		947	`IGNORE d_exp(n + 1);`
		948	`break;`
		949	`case e_contents:`
		950	`consname("contents", n);`
		951	`IGNORE d_shape(n + 1);`
		952	`IGNORE d_exp(n + 1);`
		953	`break;`
		954	`case e_contents_with_mode:`
		955	`consname("contents_with_mode", n);`
		956	`IGNORE d_transfer_mode(n + 1);`
		957	`IGNORE d_shape(n + 1);`
		958	`IGNORE d_exp(n + 1);`
		959	`break;`
		960	`case e_current_env:`
		961	`consname("current_env", n);`
		962	`break;`
		963	`case e_div0:`
		964	`consname("div0", n);`
		965	`IGNORE d_error_treatment(n + 1);`
		966	`IGNORE d_error_treatment(n + 1);`
		967	`IGNORE d_exp(n + 1);`
		968	`IGNORE d_exp(n + 1);`
		969	`break;`
		970	`case e_div1:`
		971	`consname("div1", n);`
		972	`IGNORE d_error_treatment(n + 1);`
		973	`IGNORE d_error_treatment(n + 1);`
		974	`IGNORE d_exp(n + 1);`
		975	`IGNORE d_exp(n + 1);`
		976	`break;`
		977	`case e_div2:`
		978	`consname("div2", n);`
		979	`IGNORE d_error_treatment(n + 1);`
		980	`IGNORE d_error_treatment(n + 1);`
		981	`IGNORE d_exp(n + 1);`
		982	`IGNORE d_exp(n + 1);`
		983	`break;`
		984	`case e_env_offset:`
		985	`consname("env_offset", n);`
		986	`IGNORE d_alignment(n + 1);`
		987	`IGNORE d_alignment(n + 1);`
		988	`IGNORE d_tag(n + 1);`
		989	`break;`
		990	`case e_env_size:`
		991	`consname("env_size", n);`
		992	`IGNORE d_tag(n + 1);`
		993	`break;`
		994	`case e_fail_installer:`
		995	`consname("fail_installer", n);`
		996	`IGNORE d_string(n + 1);`
		997	`break;`
		998	`case e_float_int:`
		999	`consname("float_int", n);`
		1000	`IGNORE d_error_treatment(n + 1);`
		1001	`IGNORE d_floating_variety(n + 1);`
		1002	`IGNORE d_exp(n + 1);`
		1003	`break;`
		1004	`case e_floating_abs:`
		1005	`consname("floating_abs", n);`
		1006	`IGNORE d_error_treatment(n + 1);`
		1007	`IGNORE d_exp(n + 1);`
		1008	`break;`
		1009	`case e_floating_div:`
		1010	`consname("floating_div", n);`
		1011	`IGNORE d_error_treatment(n + 1);`
		1012	`IGNORE d_exp(n + 1);`
		1013	`IGNORE d_exp(n + 1);`
		1014	`break;`
		1015	`case e_floating_minus:`
		1016	`consname("floating_minus", n);`
		1017	`IGNORE d_error_treatment(n + 1);`
		1018	`IGNORE d_exp(n + 1);`
		1019	`IGNORE d_exp(n + 1);`
		1020	`break;`
		1021	`case e_floating_maximum:`
		1022	`consname("floating_maximum", n);`
		1023	`IGNORE d_error_treatment(n + 1);`
		1024	`IGNORE d_exp(n + 1);`
		1025	`IGNORE d_exp(n + 1);`
		1026	`break;`
		1027	`case e_floating_minimum:`
		1028	`consname("floating_minimum", n);`
		1029	`IGNORE d_error_treatment(n + 1);`
		1030	`IGNORE d_exp(n + 1);`
		1031	`IGNORE d_exp(n + 1);`
		1032	`break;`
		1033	`case e_floating_mult:`
		1034	`consname("floating_mult", n);`
		1035	`IGNORE d_error_treatment(n + 1);`
		1036	`IGNORE d_exp_list(n + 1);`
		1037	`break;`
		1038	`case e_floating_negate:`
		1039	`consname("floating_negate", n);`
		1040	`IGNORE d_error_treatment(n + 1);`
		1041	`IGNORE d_exp(n + 1);`
		1042	`break;`
		1043	`case e_floating_plus:`
		1044	`consname("floating_plus", n);`
		1045	`IGNORE d_error_treatment(n + 1);`
		1046	`IGNORE d_exp_list(n + 1);`
		1047	`break;`
		1048	`case e_floating_power:`
		1049	`consname("floating_power", n);`
		1050	`IGNORE d_error_treatment(n + 1);`
		1051	`IGNORE d_exp(n + 1);`
		1052	`IGNORE d_exp(n + 1);`
		1053	`break;`
		1054	`case e_floating_test:`
		1055	`consname("floating_test", n);`
		1056	`IGNORE d_nat_option(n + 1);`
		1057	`IGNORE d_error_treatment(n + 1);`
		1058	`IGNORE d_ntest(n + 1);`
		1059	`IGNORE d_label(n + 1);`
		1060	`IGNORE d_exp(n + 1);`
		1061	`IGNORE d_exp(n + 1);`
		1062	`break;`
		1063	`case e_goto:`
		1064	`consname("goto", n);`
		1065	`IGNORE d_label(n + 1);`
		1066	`break;`
		1067	`case e_goto_local_lv:`
		1068	`consname("goto_local_lv", n);`
		1069	`IGNORE d_exp(n + 1);`
		1070	`break;`
		1071	`case e_identify:`
		1072	`consname("identify", n);`
		1073	`IGNORE d_access_option(n + 1);`
		1074	`IGNORE d_tag(n + 1);`
		1075	`IGNORE d_exp(n + 1);`
		1076	`IGNORE d_exp(n + 1);`
		1077	`break;`
		1078	`case e_ignorable:`
		1079	`consname("ignorable", n);`
		1080	`IGNORE d_exp(n + 1);`
		1081	`break;`
		1082	`case e_imaginary_part:`
		1083	`consname("imaginary_part", n);`
		1084	`IGNORE d_exp(n + 1);`
		1085	`break;`
		1086	`case e_initial_value:`
		1087	`consname("initial_value", n);`
		1088	`IGNORE d_exp(n + 1);`
		1089	`break;`
		1090	`case e_integer_test:`
		1091	`consname("integer_test", n);`
		1092	`IGNORE d_nat_option(n + 1);`
		1093	`IGNORE d_ntest(n + 1);`
		1094	`IGNORE d_label(n + 1);`
		1095	`IGNORE d_exp(n + 1);`
		1096	`IGNORE d_exp(n + 1);`
		1097	`break;`
		1098	`case e_labelled:`
		1099	`consname("labelled", n);`
		1100	`IGNORE d_label_list(n + 1);`
		1101	`IGNORE d_exp(n + 1);`
		1102	`IGNORE d_exp_list(n + 1);`
		1103	`break;`
		1104	`case e_last_local:`
		1105	`consname("last_local", n);`
		1106	`IGNORE d_exp(n + 1);`
		1107	`break;`
		1108	`case e_local_alloc:`
		1109	`consname("local_alloc", n);`
		1110	`IGNORE d_exp(n + 1);`
		1111	`break;`
		1112	`case e_local_alloc_check:`
		1113	`consname("local_alloc_check", n);`
		1114	`IGNORE d_exp(n + 1);`
		1115	`break;`
		1116	`case e_local_free:`
		1117	`consname("local_free", n);`
		1118	`IGNORE d_exp(n + 1);`
		1119	`IGNORE d_exp(n + 1);`
		1120	`break;`
		1121	`case e_local_free_all:`
		1122	`consname("local_free_all", n);`
		1123	`break;`
		1124	`case e_long_jump:`
		1125	`consname("long_jump", n);`
		1126	`IGNORE d_exp(n + 1);`
		1127	`IGNORE d_exp(n + 1);`
		1128	`break;`
		1129	`case e_make_complex:`
		1130	`consname("make_complex", n);`
		1131	`IGNORE d_floating_variety(n + 1);`
		1132	`IGNORE d_exp(n + 1);`
		1133	`IGNORE d_exp(n + 1);`
		1134	`break;`
		1135	`case e_make_compound:`
		1136	`consname("make_compound", n);`
		1137	`IGNORE d_exp(n + 1);`
		1138	`IGNORE d_exp_list(n + 1);`
		1139	`break;`
		1140	`case e_make_floating:`
		1141	`consname("make_floating", n);`
		1142	`IGNORE d_floating_variety(n + 1);`
		1143	`IGNORE d_rounding_mode(n + 1);`
		1144	`IGNORE d_bool(n + 1);`
		1145	`IGNORE d_string(n + 1);`
		1146	`IGNORE d_nat(n + 1);`
		1147	`IGNORE d_signed_nat(n + 1);`
		1148	`break;`
		1149	`case e_make_general_proc:`
		1150	`consname("make_general_proc", n);`
		1151	`IGNORE d_shape(n + 1);`
		1152	`IGNORE d_procprops_option(n + 1);`
		1153	`IGNORE d_tagshacc_list(n + 1);`
		1154	`IGNORE d_tagshacc_list(n + 1);`
		1155	`IGNORE d_exp(n + 1);`
		1156	`break;`
		1157	`case e_make_int:`
		1158	`consname("make_int", n);`
		1159	`IGNORE d_variety(n + 1);`
		1160	`IGNORE d_signed_nat(n + 1);`
		1161	`break;`
		1162	`case e_make_local_lv:`
		1163	`consname("make_local_lv", n);`
		1164	`IGNORE d_label(n + 1);`
		1165	`break;`
		1166	`case e_make_nof:`
		1167	`consname("make_nof", n);`
		1168	`IGNORE d_exp_list(n + 1);`
		1169	`break;`
		1170	`case e_make_nof_int:`
		1171	`consname("make_nof_int", n);`
		1172	`IGNORE d_variety(n + 1);`
		1173	`IGNORE d_string(n + 1);`
		1174	`break;`
		1175	`case e_make_null_local_lv:`
		1176	`consname("make_null_local_lv", n);`
		1177	`break;`
		1178	`case e_make_null_proc:`
		1179	`consname("make_null_proc", n);`
		1180	`break;`
		1181	`case e_make_null_ptr:`
		1182	`consname("make_null_ptr", n);`
		1183	`IGNORE d_alignment(n + 1);`
		1184	`break;`
		1185	`case e_make_proc:`
		1186	`consname("make_proc", n);`
		1187	`IGNORE d_shape(n + 1);`
		1188	`IGNORE d_tagshacc_list(n + 1);`
		1189	`IGNORE d_tagacc_option(n + 1);`
		1190	`IGNORE d_exp(n + 1);`
		1191	`break;`
		1192	`case e_make_stack_limit:`
		1193	`consname("make_stack_limit", n);`
		1194	`IGNORE d_exp(n + 1);`
		1195	`IGNORE d_exp(n + 1);`
		1196	`IGNORE d_exp(n + 1);`
		1197	`break;`
		1198	`case e_make_top:`
		1199	`consname("make_top", n);`
		1200	`break;`
		1201	`case e_make_value:`
		1202	`consname("make_value", n);`
		1203	`IGNORE d_shape(n + 1);`
		1204	`break;`
		1205	`case e_maximum:`
		1206	`consname("maximum", n);`
		1207	`IGNORE d_exp(n + 1);`
		1208	`IGNORE d_exp(n + 1);`
		1209	`break;`
		1210	`case e_minimum:`
		1211	`consname("minimum", n);`
		1212	`IGNORE d_exp(n + 1);`
		1213	`IGNORE d_exp(n + 1);`
		1214	`break;`
		1215	`case e_minus:`
		1216	`consname("minus", n);`
		1217	`IGNORE d_error_treatment(n + 1);`
		1218	`IGNORE d_exp(n + 1);`
		1219	`IGNORE d_exp(n + 1);`
		1220	`break;`
		1221	`case e_move_some:`
		1222	`consname("move_some", n);`
		1223	`IGNORE d_transfer_mode(n + 1);`
		1224	`IGNORE d_exp(n + 1);`
		1225	`IGNORE d_exp(n + 1);`
		1226	`IGNORE d_exp(n + 1);`
		1227	`break;`
		1228	`case e_mult:`
		1229	`consname("mult", n);`
		1230	`IGNORE d_error_treatment(n + 1);`
		1231	`IGNORE d_exp(n + 1);`
		1232	`IGNORE d_exp(n + 1);`
		1233	`break;`
		1234	`case e_n_copies:`
		1235	`consname("n_copies", n);`
		1236	`IGNORE d_nat(n + 1);`
		1237	`IGNORE d_exp(n + 1);`
		1238	`break;`
		1239	`case e_negate:`
		1240	`consname("negate", n);`
		1241	`IGNORE d_error_treatment(n + 1);`
		1242	`IGNORE d_exp(n + 1);`
		1243	`break;`
		1244	`case e_not:`
		1245	`consname("not", n);`
		1246	`IGNORE d_exp(n + 1);`
		1247	`break;`
		1248	`case e_obtain_tag:`
		1249	`consname("obtain_tag", n);`
		1250	`IGNORE d_tag(n + 1);`
		1251	`break;`
		1252	`case e_offset_add:`
		1253	`consname("offset_add", n);`
		1254	`IGNORE d_exp(n + 1);`
		1255	`IGNORE d_exp(n + 1);`
		1256	`break;`
		1257	`case e_offset_div:`
		1258	`consname("offset_div", n);`
		1259	`IGNORE d_variety(n + 1);`
		1260	`IGNORE d_exp(n + 1);`
		1261	`IGNORE d_exp(n + 1);`
		1262	`break;`
		1263	`case e_offset_div_by_int:`
		1264	`consname("offset_div_by_int", n);`
		1265	`IGNORE d_exp(n + 1);`
		1266	`IGNORE d_exp(n + 1);`
		1267	`break;`
		1268	`case e_offset_max:`
		1269	`consname("offset_max", n);`
		1270	`IGNORE d_exp(n + 1);`
		1271	`IGNORE d_exp(n + 1);`
		1272	`break;`
		1273	`case e_offset_mult:`
		1274	`consname("offset_mult", n);`
		1275	`IGNORE d_exp(n + 1);`
		1276	`IGNORE d_exp(n + 1);`
		1277	`break;`
		1278	`case e_offset_negate:`
		1279	`consname("offset_negate", n);`
		1280	`IGNORE d_exp(n + 1);`
		1281	`break;`
		1282	`case e_offset_pad:`
		1283	`consname("offset_pad", n);`
		1284	`IGNORE d_alignment(n + 1);`
		1285	`IGNORE d_exp(n + 1);`
		1286	`break;`
		1287	`case e_offset_subtract:`
		1288	`consname("offset_subtract", n);`
		1289	`IGNORE d_exp(n + 1);`
		1290	`IGNORE d_exp(n + 1);`
		1291	`break;`
		1292	`case e_offset_test:`
		1293	`consname("offset_test", n);`
		1294	`IGNORE d_nat_option(n + 1);`
		1295	`IGNORE d_ntest(n + 1);`
		1296	`IGNORE d_label(n + 1);`
		1297	`IGNORE d_exp(n + 1);`
		1298	`IGNORE d_exp(n + 1);`
		1299	`break;`
		1300	`case e_offset_zero:`
		1301	`consname("offset_zero", n);`
		1302	`IGNORE d_alignment(n + 1);`
		1303	`break;`
		1304	`case e_or:`
		1305	`consname("or", n);`
		1306	`IGNORE d_exp(n + 1);`
		1307	`IGNORE d_exp(n + 1);`
		1308	`break;`
		1309	`case e_plus:`
		1310	`consname("plus", n);`
		1311	`IGNORE d_error_treatment(n + 1);`
		1312	`IGNORE d_exp(n + 1);`
		1313	`IGNORE d_exp(n + 1);`
		1314	`break;`
		1315	`case e_pointer_test:`
		1316	`consname("pointer_test", n);`
		1317	`IGNORE d_nat_option(n + 1);`
		1318	`IGNORE d_ntest(n + 1);`
		1319	`IGNORE d_label(n + 1);`
		1320	`IGNORE d_exp(n + 1);`
		1321	`IGNORE d_exp(n + 1);`
		1322	`break;`
		1323	`case e_power:`
		1324	`consname("power", n);`
		1325	`IGNORE d_error_treatment(n + 1);`
		1326	`IGNORE d_exp(n + 1);`
		1327	`IGNORE d_exp(n + 1);`
		1328	`break;`
		1329	`case e_proc_test:`
		1330	`consname("proc_test", n);`
		1331	`IGNORE d_nat_option(n + 1);`
		1332	`IGNORE d_ntest(n + 1);`
		1333	`IGNORE d_label(n + 1);`
		1334	`IGNORE d_exp(n + 1);`
		1335	`IGNORE d_exp(n + 1);`
		1336	`break;`
		1337	`case e_profile:`
		1338	`consname("profile", n);`
		1339	`IGNORE d_nat(n + 1);`
		1340	`break;`
		1341	`case e_real_part:`
		1342	`consname("real_part", n);`
		1343	`IGNORE d_exp(n + 1);`
		1344	`break;`
		1345	`case e_rem0:`
		1346	`consname("rem0", n);`
		1347	`IGNORE d_error_treatment(n + 1);`
		1348	`IGNORE d_error_treatment(n + 1);`
		1349	`IGNORE d_exp(n + 1);`
		1350	`IGNORE d_exp(n + 1);`
		1351	`break;`
		1352	`case e_rem1:`
		1353	`consname("rem1", n);`
		1354	`IGNORE d_error_treatment(n + 1);`
		1355	`IGNORE d_error_treatment(n + 1);`
		1356	`IGNORE d_exp(n + 1);`
		1357	`IGNORE d_exp(n + 1);`
		1358	`break;`
		1359	`case e_rem2:`
		1360	`consname("rem2", n);`
		1361	`IGNORE d_error_treatment(n + 1);`
		1362	`IGNORE d_error_treatment(n + 1);`
		1363	`IGNORE d_exp(n + 1);`
		1364	`IGNORE d_exp(n + 1);`
		1365	`break;`
		1366	`case e_repeat:`
		1367	`consname("repeat", n);`
		1368	`IGNORE d_label(n + 1);`
		1369	`IGNORE d_exp(n + 1);`
		1370	`IGNORE d_exp(n + 1);`
		1371	`break;`
		1372	`case e_return:`
		1373	`consname("return", n);`
		1374	`IGNORE d_exp(n + 1);`
		1375	`break;`
		1376	`case e_return_to_label:`
		1377	`consname("return_to_label", n);`
		1378	`IGNORE d_exp(n + 1);`
		1379	`break;`
		1380	`case e_round_with_mode:`
		1381	`consname("round_with_mode", n);`
		1382	`IGNORE d_error_treatment(n + 1);`
		1383	`IGNORE d_rounding_mode(n + 1);`
		1384	`IGNORE d_variety(n + 1);`
		1385	`IGNORE d_exp(n + 1);`
		1386	`break;`
		1387	`case e_rotate_left:`
		1388	`consname("rotate_left", n);`
		1389	`IGNORE d_exp(n + 1);`
		1390	`IGNORE d_exp(n + 1);`
		1391	`break;`
		1392	`case e_rotate_right:`
		1393	`consname("rotate_right", n);`
		1394	`IGNORE d_exp(n + 1);`
		1395	`IGNORE d_exp(n + 1);`
		1396	`break;`
		1397	`case e_sequence:`
		1398	`consname("sequence", n);`
		1399	`IGNORE d_exp_list(n + 1);`
		1400	`IGNORE d_exp(n + 1);`
		1401	`break;`
		1402	`case e_set_stack_limit:`
		1403	`consname("set_stack_limit", n);`
		1404	`IGNORE d_exp(n + 1);`
		1405	`break;`
		1406	`case e_shape_offset:`
		1407	`consname("shape_offset", n);`
		1408	`IGNORE d_shape(n + 1);`
		1409	`break;`
		1410	`case e_shift_left:`
		1411	`consname("shift_left", n);`
		1412	`IGNORE d_error_treatment(n + 1);`
		1413	`IGNORE d_exp(n + 1);`
		1414	`IGNORE d_exp(n + 1);`
		1415	`break;`
		1416	`case e_shift_right:`
		1417	`consname("shift_right", n);`
		1418	`IGNORE d_exp(n + 1);`
		1419	`IGNORE d_exp(n + 1);`
		1420	`break;`
		1421	`case e_subtract_ptrs:`
		1422	`consname("subtract_ptrs", n);`
		1423	`IGNORE d_exp(n + 1);`
		1424	`IGNORE d_exp(n + 1);`
		1425	`break;`
		1426	`case e_tail_call:`
		1427	`consname("tail_call", n);`
		1428	`IGNORE d_procprops_option(n + 1);`
		1429	`IGNORE d_exp(n + 1);`
		1430	`IGNORE d_callees(n + 1);`
		1431	`break;`
		1432	`case e_untidy_return:`
		1433	`consname("untidy_return", n);`
		1434	`IGNORE d_exp(n + 1);`
		1435	`break;`
		1436	`case e_variable:`
		1437	`consname("variable", n);`
		1438	`IGNORE d_access_option(n + 1);`
		1439	`IGNORE d_tag(n + 1);`
		1440	`IGNORE d_exp(n + 1);`
		1441	`IGNORE d_exp(n + 1);`
		1442	`break;`
		1443	`case e_xor:`
		1444	`consname("xor", n);`
		1445	`IGNORE d_exp(n + 1);`
		1446	`IGNORE d_exp(n + 1);`
		1447	`break;`
		1448	`default:`
		1449	`fail("Bad exp value, 14", enc);`
		1450	`break;`
		1451	`}`
		1452	`return(enc);`
		1453	`}`
		1454
		1455
		1456	`/* DECODE EXP LIST */`
		1457
		1458	`unsigned int`
		1459	`d_exp_list(int n)`
		1460	`{`
		1461	`unsigned int nl;`
		1462	`IGNORE get_basic_int(1, 0);`
		1463	`nl = get_tdfint();`
		1464	`for (; nl != 0; nl--) {`
		1465	`IGNORE d_exp(n + 1);`
		1466	`}`
		1467	`return(nl);`
		1468	`}`
		1469
		1470
		1471	`/* DECODE OPTIONAL EXP */`
		1472
		1473	`unsigned int`
		1474	`d_exp_option(int n)`
		1475	`{`
		1476	`unsigned int nl = get_basic_int(1, 0);`
		1477	`if (nl) {`
		1478	`IGNORE d_exp(n);`
		1479	`}`
		1480	`return(nl);`
		1481	`}`
		1482
		1483
		1484	`/* DECODE EXTERN_LINK */`
		1485
		1486	`unsigned int`
		1487	`d_extern_link(int n)`
		1488	`{`
		1489	`consname("make_extern_link", n);`
		1490	`IGNORE d_linkextern_list(n + 1);`
		1491	`return(0);`
		1492	`}`
		1493
		1494
		1495	`/* DECODE SIMPLE EXTERN_LINK LIST */`
		1496
		1497	`unsigned int`
		1498	`d_extern_link_list(int n)`
		1499	`{`
		1500	`unsigned int nl = get_tdfint();`
		1501	`for (; nl != 0; nl--) {`
		1502	`IGNORE d_extern_link(n + 1);`
		1503	`}`
		1504	`return(nl);`
		1505	`}`
		1506
		1507
		1508	`/* DECODE EXTERNAL */`
		1509
		1510	`unsigned int`
		1511	`d_external(int n)`
		1512	`{`
		1513	`unsigned int enc = get_basic_int(2, 1);`
		1514	`switch (enc) {`
		1515	`case e_string_extern:`
		1516	`consname("string_extern", n);`
		1517	`IGNORE d_tdfident(n + 1);`
		1518	`break;`
		1519	`case e_unique_extern:`
		1520	`consname("unique_extern", n);`
		1521	`IGNORE d_unique(n + 1);`
		1522	`break;`
		1523	`case e_chain_extern:`
		1524	`consname("chain_extern", n);`
		1525	`IGNORE d_tdfident(n + 1);`
		1526	`IGNORE d_tdfint(n + 1);`
		1527	`break;`
		1528	`default:`
		1529	`fail("Bad external value, 15", enc);`
		1530	`break;`
		1531	`}`
		1532	`return(enc);`
		1533	`}`
		1534
		1535
		1536	`/* DECODE FILENAME */`
		1537
		1538	`unsigned int`
		1539	`d_filename(int n)`
		1540	`{`
		1541	`unsigned int enc = get_basic_int(2, 1);`
		1542	`switch (enc) {`
		1543	`case e_filename_apply_token:`
		1544	`consname("filename_apply_token", n);`
		1545	`IGNORE d_token(n + 1);`
		1546	`IGNORE d_bitstream("filename_apply_token", n + 1);`
		1547	`break;`
		1548	`case e_make_filename:`
		1549	`consname("make_filename", n);`
		1550	`IGNORE d_nat(n + 1);`
		1551	`IGNORE d_tdfstring(n + 1);`
		1552	`IGNORE d_tdfstring(n + 1);`
		1553	`break;`
		1554	`default:`
		1555	`fail("Bad filename value, 16", enc);`
		1556	`break;`
		1557	`}`
		1558	`return(enc);`
		1559	`}`
		1560
		1561
		1562	`/* DECODE FLOATING_VARIETY */`
		1563
		1564	`unsigned int`
		1565	`d_floating_variety(int n)`
		1566	`{`
		1567	`unsigned int enc = get_basic_int(3, 1);`
		1568	`switch (enc) {`
		1569	`case e_flvar_apply_token:`
		1570	`consname("flvar_apply_token", n);`
		1571	`IGNORE d_token(n + 1);`
		1572	`IGNORE d_bitstream("flvar_apply_token", n + 1);`
		1573	`break;`
		1574	`case e_flvar_cond:`
		1575	`consname("flvar_cond", n);`
		1576	`IGNORE d_exp(n + 1);`
		1577	`IGNORE d_bitstream("flvar_cond", n + 1);`
		1578	`IGNORE d_bitstream("flvar_cond", n + 1);`
		1579	`break;`
		1580	`case e_flvar_parms:`
		1581	`consname("flvar_parms", n);`
		1582	`IGNORE d_nat(n + 1);`
		1583	`IGNORE d_nat(n + 1);`
		1584	`IGNORE d_nat(n + 1);`
		1585	`IGNORE d_nat(n + 1);`
		1586	`break;`
		1587	`case e_complex_parms:`
		1588	`consname("complex_parms", n);`
		1589	`IGNORE d_nat(n + 1);`
		1590	`IGNORE d_nat(n + 1);`
		1591	`IGNORE d_nat(n + 1);`
		1592	`IGNORE d_nat(n + 1);`
		1593	`break;`
		1594	`case e_float_of_complex:`
		1595	`consname("float_of_complex", n);`
		1596	`IGNORE d_shape(n + 1);`
		1597	`break;`
		1598	`case e_complex_of_float:`
		1599	`consname("complex_of_float", n);`
		1600	`IGNORE d_shape(n + 1);`
		1601	`break;`
		1602	`default:`
		1603	`fail("Bad floating_variety value, 17", enc);`
		1604	`break;`
		1605	`}`
		1606	`return(enc);`
		1607	`}`
		1608
		1609
		1610	`/* DECODE GROUP */`
		1611
		1612	`unsigned int`
		1613	`d_group(int n)`
		1614	`{`
		1615	`consname("make_group", n);`
		1616	`IGNORE d_unit_list(n + 1);`
		1617	`return(0);`
		1618	`}`
		1619
		1620
		1621	`/* DECODE SIMPLE GROUP LIST */`
		1622
		1623	`unsigned int`
		1624	`d_group_list(int n)`
		1625	`{`
		1626	`unsigned int nl = get_tdfint();`
		1627	`for (; nl != 0; nl--) {`
		1628	`IGNORE d_group(n + 1);`
		1629	`}`
		1630	`return(nl);`
		1631	`}`
		1632
		1633
		1634	`/* DECODE LABEL */`
		1635
		1636	`unsigned int`
		1637	`d_label(int n)`
		1638	`{`
		1639	`unsigned int enc = get_basic_int(1, 1);`
		1640	`switch (enc) {`
		1641	`case e_label_apply_token:`
		1642	`consname("label_apply_token", n);`
		1643	`IGNORE d_token(n + 1);`
		1644	`IGNORE d_bitstream("label_apply_token", n + 1);`
		1645	`break;`
		1646	`case e_make_label:`
		1647	`consname("make_label", n);`
		1648	`IGNORE d_tdfint(n + 1);`
		1649	`break;`
		1650	`default:`
		1651	`fail("Bad label value, 18", enc);`
		1652	`break;`
		1653	`}`
		1654	`return(enc);`
		1655	`}`
		1656
		1657
		1658	`/* DECODE LABEL LIST */`
		1659
		1660	`unsigned int`
		1661	`d_label_list(int n)`
		1662	`{`
		1663	`unsigned int nl;`
		1664	`IGNORE get_basic_int(1, 0);`
		1665	`nl = get_tdfint();`
		1666	`for (; nl != 0; nl--) {`
		1667	`IGNORE d_label(n + 1);`
		1668	`}`
		1669	`return(nl);`
		1670	`}`
		1671
		1672
		1673	`/* DECODE LINK */`
		1674
		1675	`unsigned int`
		1676	`d_link(int n)`
		1677	`{`
		1678	`consname("make_link", n);`
		1679	`IGNORE d_tdfint(n + 1);`
		1680	`IGNORE d_tdfint(n + 1);`
		1681	`return(0);`
		1682	`}`
		1683
		1684
		1685	`/* DECODE SIMPLE LINK LIST */`
		1686
		1687	`unsigned int`
		1688	`d_link_list(int n)`
		1689	`{`
		1690	`unsigned int nl = get_tdfint();`
		1691	`for (; nl != 0; nl--) {`
		1692	`IGNORE d_link(n + 1);`
		1693	`}`
		1694	`return(nl);`
		1695	`}`
		1696
		1697
		1698	`/* DECODE LINKEXTERN */`
		1699
		1700	`unsigned int`
		1701	`d_linkextern(int n)`
		1702	`{`
		1703	`consname("make_linkextern", n);`
		1704	`IGNORE d_tdfint(n + 1);`
		1705	`IGNORE d_external(n + 1);`
		1706	`return(0);`
		1707	`}`
		1708
		1709
		1710	`/* DECODE SIMPLE LINKEXTERN LIST */`
		1711
		1712	`unsigned int`
		1713	`d_linkextern_list(int n)`
		1714	`{`
		1715	`unsigned int nl = get_tdfint();`
		1716	`for (; nl != 0; nl--) {`
		1717	`IGNORE d_linkextern(n + 1);`
		1718	`}`
		1719	`return(nl);`
		1720	`}`
		1721
		1722
		1723	`/* DECODE LINKINFO */`
		1724
		1725	`unsigned int`
		1726	`d_linkinfo(int n)`
		1727	`{`
		1728	`unsigned int enc = get_basic_int(2, 1);`
		1729	`switch (enc) {`
		1730	`case e_static_name_def:`
		1731	`consname("static_name_def", n);`
		1732	`IGNORE d_exp(n + 1);`
		1733	`IGNORE d_tdfstring(n + 1);`
		1734	`break;`
		1735	`case e_make_comment:`
		1736	`consname("make_comment", n);`
		1737	`IGNORE d_tdfstring(n + 1);`
		1738	`break;`
		1739	`case e_make_weak_defn:`
		1740	`consname("make_weak_defn", n);`
		1741	`IGNORE d_exp(n + 1);`
		1742	`IGNORE d_exp(n + 1);`
		1743	`break;`
		1744	`case e_make_weak_symbol:`
		1745	`consname("make_weak_symbol", n);`
		1746	`IGNORE d_tdfstring(n + 1);`
		1747	`IGNORE d_exp(n + 1);`
		1748	`break;`
		1749	`default:`
		1750	`fail("Bad linkinfo value, 19", enc);`
		1751	`break;`
		1752	`}`
		1753	`return(enc);`
		1754	`}`
		1755
		1756
		1757	`/* DECODE SIMPLE LINKINFO LIST */`
		1758
		1759	`unsigned int`
		1760	`d_linkinfo_list(int n)`
		1761	`{`
		1762	`unsigned int nl = get_tdfint();`
		1763	`for (; nl != 0; nl--) {`
		1764	`IGNORE d_linkinfo(n + 1);`
		1765	`}`
		1766	`return(nl);`
		1767	`}`
		1768
		1769
		1770	`/* DECODE LINKINFO_PROPS */`
		1771
		1772	`unsigned int`
		1773	`d_linkinfo_props(int n)`
		1774	`{`
		1775	`consname("make_linkinfos", n);`
		1776	`IGNORE d_tdfint(n + 1);`
		1777	`IGNORE d_linkinfo_list(n + 1);`
		1778	`return(0);`
		1779	`}`
		1780
		1781
		1782	`/* DECODE LINKS */`
		1783
		1784	`unsigned int`
		1785	`d_links(int n)`
		1786	`{`
		1787	`consname("make_links", n);`
		1788	`IGNORE d_link_list(n + 1);`
		1789	`return(0);`
		1790	`}`
		1791
		1792
		1793	`/* DECODE SIMPLE LINKS LIST */`
		1794
		1795	`unsigned int`
		1796	`d_links_list(int n)`
		1797	`{`
		1798	`unsigned int nl = get_tdfint();`
		1799	`for (; nl != 0; nl--) {`
		1800	`IGNORE d_links(n + 1);`
		1801	`}`
		1802	`return(nl);`
		1803	`}`
		1804
		1805
		1806	`/* DECODE NAT */`
		1807
		1808	`unsigned int`
		1809	`d_nat(int n)`
		1810	`{`
		1811	`unsigned int enc = get_basic_int(3, 1);`
		1812	`switch (enc) {`
		1813	`case e_nat_apply_token:`
		1814	`consname("nat_apply_token", n);`
		1815	`IGNORE d_token(n + 1);`
		1816	`IGNORE d_bitstream("nat_apply_token", n + 1);`
		1817	`break;`
		1818	`case e_nat_cond:`
		1819	`consname("nat_cond", n);`
		1820	`IGNORE d_exp(n + 1);`
		1821	`IGNORE d_bitstream("nat_cond", n + 1);`
		1822	`IGNORE d_bitstream("nat_cond", n + 1);`
		1823	`break;`
		1824	`case e_computed_nat:`
		1825	`consname("computed_nat", n);`
		1826	`IGNORE d_exp(n + 1);`
		1827	`break;`
		1828	`case e_error_val:`
		1829	`consname("error_val", n);`
		1830	`IGNORE d_error_code(n + 1);`
		1831	`break;`
		1832	`case e_make_nat:`
		1833	`consname("make_nat", n);`
		1834	`IGNORE d_tdfint(n + 1);`
		1835	`break;`
		1836	`default:`
		1837	`fail("Bad nat value, 20", enc);`
		1838	`break;`
		1839	`}`
		1840	`return(enc);`
		1841	`}`
		1842
		1843
		1844	`/* DECODE OPTIONAL NAT */`
		1845
		1846	`unsigned int`
		1847	`d_nat_option(int n)`
		1848	`{`
		1849	`unsigned int nl = get_basic_int(1, 0);`
		1850	`if (nl) {`
		1851	`IGNORE d_nat(n);`
		1852	`}`
		1853	`return(nl);`
		1854	`}`
		1855
		1856
		1857	`/* DECODE NTEST */`
		1858
		1859	`unsigned int`
		1860	`d_ntest(int n)`
		1861	`{`
		1862	`unsigned int enc = get_basic_int(4, 1);`
		1863	`switch (enc) {`
		1864	`case e_ntest_apply_token:`
		1865	`consname("ntest_apply_token", n);`
		1866	`IGNORE d_token(n + 1);`
		1867	`IGNORE d_bitstream("ntest_apply_token", n + 1);`
		1868	`break;`
		1869	`case e_ntest_cond:`
		1870	`consname("ntest_cond", n);`
		1871	`IGNORE d_exp(n + 1);`
		1872	`IGNORE d_bitstream("ntest_cond", n + 1);`
		1873	`IGNORE d_bitstream("ntest_cond", n + 1);`
		1874	`break;`
		1875	`case e_equal:`
		1876	`consname("equal", n);`
		1877	`break;`
		1878	`case e_greater_than:`
		1879	`consname("greater_than", n);`
		1880	`break;`
		1881	`case e_greater_than_or_equal:`
		1882	`consname("greater_than_or_equal", n);`
		1883	`break;`
		1884	`case e_less_than:`
		1885	`consname("less_than", n);`
		1886	`break;`
		1887	`case e_less_than_or_equal:`
		1888	`consname("less_than_or_equal", n);`
		1889	`break;`
		1890	`case e_not_equal:`
		1891	`consname("not_equal", n);`
		1892	`break;`
		1893	`case e_not_greater_than:`
		1894	`consname("not_greater_than", n);`
		1895	`break;`
		1896	`case e_not_greater_than_or_equal:`
		1897	`consname("not_greater_than_or_equal", n);`
		1898	`break;`
		1899	`case e_not_less_than:`
		1900	`consname("not_less_than", n);`
		1901	`break;`
		1902	`case e_not_less_than_or_equal:`
		1903	`consname("not_less_than_or_equal", n);`
		1904	`break;`
		1905	`case e_less_than_or_greater_than:`
		1906	`consname("less_than_or_greater_than", n);`
		1907	`break;`
		1908	`case e_not_less_than_and_not_greater_than:`
		1909	`consname("not_less_than_and_not_greater_than", n);`
		1910	`break;`
		1911	`case e_comparable:`
		1912	`consname("comparable", n);`
		1913	`break;`
		1914	`case e_not_comparable:`
		1915	`consname("not_comparable", n);`
		1916	`break;`
		1917	`default:`
		1918	`fail("Bad ntest value, 21", enc);`
		1919	`break;`
		1920	`}`
		1921	`return(enc);`
		1922	`}`
		1923
		1924
		1925	`/* DECODE OTAGEXP */`
		1926
		1927	`unsigned int`
		1928	`d_otagexp(int n)`
		1929	`{`
		1930	`consname("make_otagexp", n);`
		1931	`IGNORE d_tag_option(n + 1);`
		1932	`IGNORE d_exp(n + 1);`
		1933	`return(0);`
		1934	`}`
		1935
		1936
		1937	`/* DECODE OTAGEXP LIST */`
		1938
		1939	`unsigned int`
		1940	`d_otagexp_list(int n)`
		1941	`{`
		1942	`unsigned int nl;`
		1943	`IGNORE get_basic_int(1, 0);`
		1944	`nl = get_tdfint();`
		1945	`for (; nl != 0; nl--) {`
		1946	`IGNORE d_otagexp(n + 1);`
		1947	`}`
		1948	`return(nl);`
		1949	`}`
		1950
		1951
		1952	`/* DECODE PROCPROPS */`
		1953
		1954	`unsigned int`
		1955	`d_procprops(int n)`
		1956	`{`
		1957	`unsigned int enc = get_basic_int(4, 1);`
		1958	`switch (enc) {`
		1959	`case e_procprops_apply_token:`
		1960	`consname("procprops_apply_token", n);`
		1961	`IGNORE d_token(n + 1);`
		1962	`IGNORE d_bitstream("procprops_apply_token", n + 1);`
		1963	`break;`
		1964	`case e_procprops_cond:`
		1965	`consname("procprops_cond", n);`
		1966	`IGNORE d_exp(n + 1);`
		1967	`IGNORE d_bitstream("procprops_cond", n + 1);`
		1968	`IGNORE d_bitstream("procprops_cond", n + 1);`
		1969	`break;`
		1970	`case e_add_procprops:`
		1971	`consname("add_procprops", n);`
		1972	`IGNORE d_procprops(n + 1);`
		1973	`IGNORE d_procprops(n + 1);`
		1974	`break;`
		1975	`case e_check_stack:`
		1976	`consname("check_stack", n);`
		1977	`break;`
		1978	`case e_inline:`
		1979	`consname("inline", n);`
		1980	`break;`
		1981	`case e_no_long_jump_dest:`
		1982	`consname("no_long_jump_dest", n);`
		1983	`break;`
		1984	`case e_untidy:`
		1985	`consname("untidy", n);`
		1986	`break;`
		1987	`case e_var_callees:`
		1988	`consname("var_callees", n);`
		1989	`break;`
		1990	`case e_var_callers:`
		1991	`consname("var_callers", n);`
		1992	`break;`
		1993	`default:`
		1994	`fail("Bad procprops value, 22", enc);`
		1995	`break;`
		1996	`}`
		1997	`return(enc);`
		1998	`}`
		1999
		2000
		2001	`/* DECODE OPTIONAL PROCPROPS */`
		2002
		2003	`unsigned int`
		2004	`d_procprops_option(int n)`
		2005	`{`
		2006	`unsigned int nl = get_basic_int(1, 0);`
		2007	`if (nl) {`
		2008	`IGNORE d_procprops(n);`
		2009	`}`
		2010	`return(nl);`
		2011	`}`
		2012
		2013
		2014	`/* DECODE ROUNDING_MODE */`
		2015
		2016	`unsigned int`
		2017	`d_rounding_mode(int n)`
		2018	`{`
		2019	`unsigned int enc = get_basic_int(3, 1);`
		2020	`switch (enc) {`
		2021	`case e_rounding_mode_apply_token:`
		2022	`consname("rounding_mode_apply_token", n);`
		2023	`IGNORE d_token(n + 1);`
		2024	`IGNORE d_bitstream("rounding_mode_apply_token", n + 1);`
		2025	`break;`
		2026	`case e_rounding_mode_cond:`
		2027	`consname("rounding_mode_cond", n);`
		2028	`IGNORE d_exp(n + 1);`
		2029	`IGNORE d_bitstream("rounding_mode_cond", n + 1);`
		2030	`IGNORE d_bitstream("rounding_mode_cond", n + 1);`
		2031	`break;`
		2032	`case e_round_as_state:`
		2033	`consname("round_as_state", n);`
		2034	`break;`
		2035	`case e_to_nearest:`
		2036	`consname("to_nearest", n);`
		2037	`break;`
		2038	`case e_toward_larger:`
		2039	`consname("toward_larger", n);`
		2040	`break;`
		2041	`case e_toward_smaller:`
		2042	`consname("toward_smaller", n);`
		2043	`break;`
		2044	`case e_toward_zero:`
		2045	`consname("toward_zero", n);`
		2046	`break;`
		2047	`default:`
		2048	`fail("Bad rounding_mode value, 23", enc);`
		2049	`break;`
		2050	`}`
		2051	`return(enc);`
		2052	`}`
		2053
		2054
		2055	`/* DECODE SHAPE */`
		2056
		2057	`unsigned int`
		2058	`d_shape(int n)`
		2059	`{`
		2060	`unsigned int enc = get_basic_int(4, 1);`
		2061	`switch (enc) {`
		2062	`case e_shape_apply_token:`
		2063	`consname("shape_apply_token", n);`
		2064	`IGNORE d_token(n + 1);`
		2065	`IGNORE d_bitstream("shape_apply_token", n + 1);`
		2066	`break;`
		2067	`case e_shape_cond:`
		2068	`consname("shape_cond", n);`
		2069	`IGNORE d_exp(n + 1);`
		2070	`IGNORE d_bitstream("shape_cond", n + 1);`
		2071	`IGNORE d_bitstream("shape_cond", n + 1);`
		2072	`break;`
		2073	`case e_bitfield:`
		2074	`consname("bitfield", n);`
		2075	`IGNORE d_bitfield_variety(n + 1);`
		2076	`break;`
		2077	`case e_bottom:`
		2078	`consname("bottom", n);`
		2079	`break;`
		2080	`case e_compound:`
		2081	`consname("compound", n);`
		2082	`IGNORE d_exp(n + 1);`
		2083	`break;`
		2084	`case e_floating:`
		2085	`consname("floating", n);`
		2086	`IGNORE d_floating_variety(n + 1);`
		2087	`break;`
		2088	`case e_integer:`
		2089	`consname("integer", n);`
		2090	`IGNORE d_variety(n + 1);`
		2091	`break;`
		2092	`case e_nof:`
		2093	`consname("nof", n);`
		2094	`IGNORE d_nat(n + 1);`
		2095	`IGNORE d_shape(n + 1);`
		2096	`break;`
		2097	`case e_offset:`
		2098	`consname("offset", n);`
		2099	`IGNORE d_alignment(n + 1);`
		2100	`IGNORE d_alignment(n + 1);`
		2101	`break;`
		2102	`case e_pointer:`
		2103	`consname("pointer", n);`
		2104	`IGNORE d_alignment(n + 1);`
		2105	`break;`
		2106	`case e_proc:`
		2107	`consname("proc", n);`
		2108	`break;`
		2109	`case e_top:`
		2110	`consname("top", n);`
		2111	`break;`
		2112	`default:`
		2113	`fail("Bad shape value, 24", enc);`
		2114	`break;`
		2115	`}`
		2116	`return(enc);`
		2117	`}`
		2118
		2119
		2120	`/* DECODE SIGNED_NAT */`
		2121
		2122	`unsigned int`
		2123	`d_signed_nat(int n)`
		2124	`{`
		2125	`unsigned int enc = get_basic_int(3, 1);`
		2126	`switch (enc) {`
		2127	`case e_signed_nat_apply_token:`
		2128	`consname("signed_nat_apply_token", n);`
		2129	`IGNORE d_token(n + 1);`
		2130	`IGNORE d_bitstream("signed_nat_apply_token", n + 1);`
		2131	`break;`
		2132	`case e_signed_nat_cond:`
		2133	`consname("signed_nat_cond", n);`
		2134	`IGNORE d_exp(n + 1);`
		2135	`IGNORE d_bitstream("signed_nat_cond", n + 1);`
		2136	`IGNORE d_bitstream("signed_nat_cond", n + 1);`
		2137	`break;`
		2138	`case e_computed_signed_nat:`
		2139	`consname("computed_signed_nat", n);`
		2140	`IGNORE d_exp(n + 1);`
		2141	`break;`
		2142	`case e_make_signed_nat:`
		2143	`consname("make_signed_nat", n);`
		2144	`IGNORE d_tdfbool(n + 1);`
		2145	`IGNORE d_tdfint(n + 1);`
		2146	`break;`
		2147	`case e_snat_from_nat:`
		2148	`consname("snat_from_nat", n);`
		2149	`IGNORE d_bool(n + 1);`
		2150	`IGNORE d_nat(n + 1);`
		2151	`break;`
		2152	`default:`
		2153	`fail("Bad signed_nat value, 25", enc);`
		2154	`break;`
		2155	`}`
		2156	`return(enc);`
		2157	`}`
		2158
		2159
		2160	`/* DECODE SORTNAME */`
		2161
		2162	`unsigned int`
		2163	`d_sortname(int n)`
		2164	`{`
		2165	`unsigned int enc = get_basic_int(5, 1);`
		2166	`switch (enc) {`
		2167	`case e_access:`
		2168	`consname("access", n);`
		2169	`break;`
		2170	`case e_al_tag:`
		2171	`consname("al_tag", n);`
		2172	`break;`
		2173	`case e_alignment_sort:`
		2174	`consname("alignment_sort", n);`
		2175	`break;`
		2176	`case e_bitfield_variety:`
		2177	`consname("bitfield_variety", n);`
		2178	`break;`
		2179	`case e_bool:`
		2180	`consname("bool", n);`
		2181	`break;`
		2182	`case e_error_treatment:`
		2183	`consname("error_treatment", n);`
		2184	`break;`
		2185	`case e_exp:`
		2186	`consname("exp", n);`
		2187	`break;`
		2188	`case e_floating_variety:`
		2189	`consname("floating_variety", n);`
		2190	`break;`
		2191	`case e_foreign_sort:`
		2192	`consname("foreign_sort", n);`
		2193	`IGNORE d_string(n + 1);`
		2194	`break;`
		2195	`case e_label:`
		2196	`consname("label", n);`
		2197	`break;`
		2198	`case e_nat:`
		2199	`consname("nat", n);`
		2200	`break;`
		2201	`case e_ntest:`
		2202	`consname("ntest", n);`
		2203	`break;`
		2204	`case e_procprops:`
		2205	`consname("procprops", n);`
		2206	`break;`
		2207	`case e_rounding_mode:`
		2208	`consname("rounding_mode", n);`
		2209	`break;`
		2210	`case e_shape:`
		2211	`consname("shape", n);`
		2212	`break;`
		2213	`case e_signed_nat:`
		2214	`consname("signed_nat", n);`
		2215	`break;`
		2216	`case e_string:`
		2217	`consname("string", n);`
		2218	`break;`
		2219	`case e_tag:`
		2220	`consname("tag", n);`
		2221	`break;`
		2222	`case e_transfer_mode:`
		2223	`consname("transfer_mode", n);`
		2224	`break;`
		2225	`case e_token:`
		2226	`consname("token", n);`
		2227	`IGNORE d_sortname(n + 1);`
		2228	`IGNORE d_sortname_list(n + 1);`
		2229	`break;`
		2230	`case e_variety:`
		2231	`consname("variety", n);`
		2232	`break;`
		2233	`default:`
		2234	`fail("Bad sortname value, 26", enc);`
		2235	`break;`
		2236	`}`
		2237	`return(enc);`
		2238	`}`
		2239
		2240
		2241	`/* DECODE SORTNAME LIST */`
		2242
		2243	`unsigned int`
		2244	`d_sortname_list(int n)`
		2245	`{`
		2246	`unsigned int nl;`
		2247	`IGNORE get_basic_int(1, 0);`
		2248	`nl = get_tdfint();`
		2249	`for (; nl != 0; nl--) {`
		2250	`IGNORE d_sortname(n + 1);`
		2251	`}`
		2252	`return(nl);`
		2253	`}`
		2254
		2255
		2256	`/* DECODE SOURCEMARK */`
		2257
		2258	`unsigned int`
		2259	`d_sourcemark(int n)`
		2260	`{`
		2261	`unsigned int enc = get_basic_int(1, 1);`
		2262	`switch (enc) {`
		2263	`case e_make_sourcemark:`
		2264	`consname("make_sourcemark", n);`
		2265	`IGNORE d_filename(n + 1);`
		2266	`IGNORE d_nat(n + 1);`
		2267	`IGNORE d_nat(n + 1);`
		2268	`break;`
		2269	`default:`
		2270	`fail("Bad sourcemark value, 27", enc);`
		2271	`break;`
		2272	`}`
		2273	`return(enc);`
		2274	`}`
		2275
		2276
		2277	`/* DECODE STRING */`
		2278
		2279	`unsigned int`
		2280	`d_string(int n)`
		2281	`{`
		2282	`unsigned int enc = get_basic_int(3, 1);`
		2283	`switch (enc) {`
		2284	`case e_string_apply_token:`
		2285	`consname("string_apply_token", n);`
		2286	`IGNORE d_token(n + 1);`
		2287	`IGNORE d_bitstream("string_apply_token", n + 1);`
		2288	`break;`
		2289	`case e_string_cond:`
		2290	`consname("string_cond", n);`
		2291	`IGNORE d_exp(n + 1);`
		2292	`IGNORE d_bitstream("string_cond", n + 1);`
		2293	`IGNORE d_bitstream("string_cond", n + 1);`
		2294	`break;`
		2295	`case e_concat_string:`
		2296	`consname("concat_string", n);`
		2297	`IGNORE d_string(n + 1);`
		2298	`IGNORE d_string(n + 1);`
		2299	`break;`
		2300	`case e_make_string:`
		2301	`consname("make_string", n);`
		2302	`IGNORE d_tdfstring(n + 1);`
		2303	`break;`
		2304	`default:`
		2305	`fail("Bad string value, 28", enc);`
		2306	`break;`
		2307	`}`
		2308	`return(enc);`
		2309	`}`
		2310
		2311
		2312	`/* DECODE OPTIONAL STRING */`
		2313
		2314	`unsigned int`
		2315	`d_string_option(int n)`
		2316	`{`
		2317	`unsigned int nl = get_basic_int(1, 0);`
		2318	`if (nl) {`
		2319	`IGNORE d_string(n);`
		2320	`}`
		2321	`return(nl);`
		2322	`}`
		2323
		2324
		2325	`/* DECODE TAG */`
		2326
		2327	`unsigned int`
		2328	`d_tag(int n)`
		2329	`{`
		2330	`unsigned int enc = get_basic_int(1, 1);`
		2331	`switch (enc) {`
		2332	`case e_tag_apply_token:`
		2333	`consname("tag_apply_token", n);`
		2334	`IGNORE d_token(n + 1);`
		2335	`IGNORE d_bitstream("tag_apply_token", n + 1);`
		2336	`break;`
		2337	`case e_make_tag:`
		2338	`consname("make_tag", n);`
		2339	`IGNORE d_tdfint(n + 1);`
		2340	`break;`
		2341	`default:`
		2342	`fail("Bad tag value, 29", enc);`
		2343	`break;`
		2344	`}`
		2345	`return(enc);`
		2346	`}`
		2347
		2348
		2349	`/* DECODE OPTIONAL TAG */`
		2350
		2351	`unsigned int`
		2352	`d_tag_option(int n)`
		2353	`{`
		2354	`unsigned int nl = get_basic_int(1, 0);`
		2355	`if (nl) {`
		2356	`IGNORE d_tag(n);`
		2357	`}`
		2358	`return(nl);`
		2359	`}`
		2360
		2361
		2362	`/* DECODE TAGACC */`
		2363
		2364	`unsigned int`
		2365	`d_tagacc(int n)`
		2366	`{`
		2367	`consname("make_tagacc", n);`
		2368	`IGNORE d_tag(n + 1);`
		2369	`IGNORE d_access_option(n + 1);`
		2370	`return(0);`
		2371	`}`
		2372
		2373
		2374	`/* DECODE OPTIONAL TAGACC */`
		2375
		2376	`unsigned int`
		2377	`d_tagacc_option(int n)`
		2378	`{`
		2379	`unsigned int nl = get_basic_int(1, 0);`
		2380	`if (nl) {`
		2381	`IGNORE d_tagacc(n);`
		2382	`}`
		2383	`return(nl);`
		2384	`}`
		2385
		2386
		2387	`/* DECODE TAGDEC */`
		2388
		2389	`unsigned int`
		2390	`d_tagdec(int n)`
		2391	`{`
		2392	`unsigned int enc = get_basic_int(2, 1);`
		2393	`switch (enc) {`
		2394	`case e_make_id_tagdec:`
		2395	`consname("make_id_tagdec", n);`
		2396	`IGNORE d_tdfint(n + 1);`
		2397	`IGNORE d_access_option(n + 1);`
		2398	`IGNORE d_string_option(n + 1);`
		2399	`IGNORE d_shape(n + 1);`
		2400	`break;`
		2401	`case e_make_var_tagdec:`
		2402	`consname("make_var_tagdec", n);`
		2403	`IGNORE d_tdfint(n + 1);`
		2404	`IGNORE d_access_option(n + 1);`
		2405	`IGNORE d_string_option(n + 1);`
		2406	`IGNORE d_shape(n + 1);`
		2407	`break;`
		2408	`case e_common_tagdec:`
		2409	`consname("common_tagdec", n);`
		2410	`IGNORE d_tdfint(n + 1);`
		2411	`IGNORE d_access_option(n + 1);`
		2412	`IGNORE d_string_option(n + 1);`
		2413	`IGNORE d_shape(n + 1);`
		2414	`break;`
		2415	`default:`
		2416	`fail("Bad tagdec value, 30", enc);`
		2417	`break;`
		2418	`}`
		2419	`return(enc);`
		2420	`}`
		2421
		2422
		2423	`/* DECODE SIMPLE TAGDEC LIST */`
		2424
		2425	`unsigned int`
		2426	`d_tagdec_list(int n)`
		2427	`{`
		2428	`unsigned int nl = get_tdfint();`
		2429	`for (; nl != 0; nl--) {`
		2430	`IGNORE d_tagdec(n + 1);`
		2431	`}`
		2432	`return(nl);`
		2433	`}`
		2434
		2435
		2436	`/* DECODE TAGDEC_PROPS */`
		2437
		2438	`unsigned int`
		2439	`d_tagdec_props(int n)`
		2440	`{`
		2441	`consname("make_tagdecs", n);`
		2442	`IGNORE d_tdfint(n + 1);`
		2443	`IGNORE d_tagdec_list(n + 1);`
		2444	`return(0);`
		2445	`}`
		2446
		2447
		2448	`/* DECODE TAGDEF */`
		2449
		2450	`unsigned int`
		2451	`d_tagdef(int n)`
		2452	`{`
		2453	`unsigned int enc = get_basic_int(2, 1);`
		2454	`switch (enc) {`
		2455	`case e_make_id_tagdef:`
		2456	`consname("make_id_tagdef", n);`
		2457	`IGNORE d_tdfint(n + 1);`
		2458	`IGNORE d_string_option(n + 1);`
		2459	`IGNORE d_exp(n + 1);`
		2460	`break;`
		2461	`case e_make_var_tagdef:`
		2462	`consname("make_var_tagdef", n);`
		2463	`IGNORE d_tdfint(n + 1);`
		2464	`IGNORE d_access_option(n + 1);`
		2465	`IGNORE d_string_option(n + 1);`
		2466	`IGNORE d_exp(n + 1);`
		2467	`break;`
		2468	`case e_common_tagdef:`
		2469	`consname("common_tagdef", n);`
		2470	`IGNORE d_tdfint(n + 1);`
		2471	`IGNORE d_access_option(n + 1);`
		2472	`IGNORE d_string_option(n + 1);`
		2473	`IGNORE d_exp(n + 1);`
		2474	`break;`
		2475	`default:`
		2476	`fail("Bad tagdef value, 31", enc);`
		2477	`break;`
		2478	`}`
		2479	`return(enc);`
		2480	`}`
		2481
		2482
		2483	`/* DECODE SIMPLE TAGDEF LIST */`
		2484
		2485	`unsigned int`
		2486	`d_tagdef_list(int n)`
		2487	`{`
		2488	`unsigned int nl = get_tdfint();`
		2489	`for (; nl != 0; nl--) {`
		2490	`IGNORE d_tagdef(n + 1);`
		2491	`}`
		2492	`return(nl);`
		2493	`}`
		2494
		2495
		2496	`/* DECODE TAGDEF_PROPS */`
		2497
		2498	`unsigned int`
		2499	`d_tagdef_props(int n)`
		2500	`{`
		2501	`consname("make_tagdefs", n);`
		2502	`IGNORE d_tdfint(n + 1);`
		2503	`IGNORE d_tagdef_list(n + 1);`
		2504	`return(0);`
		2505	`}`
		2506
		2507
		2508	`/* DECODE TAGSHACC */`
		2509
		2510	`unsigned int`
		2511	`d_tagshacc(int n)`
		2512	`{`
		2513	`consname("make_tagshacc", n);`
		2514	`IGNORE d_shape(n + 1);`
		2515	`IGNORE d_access_option(n + 1);`
		2516	`IGNORE d_tag(n + 1);`
		2517	`return(0);`
		2518	`}`
		2519
		2520
		2521	`/* DECODE TAGSHACC LIST */`
		2522
		2523	`unsigned int`
		2524	`d_tagshacc_list(int n)`
		2525	`{`
		2526	`unsigned int nl;`
		2527	`IGNORE get_basic_int(1, 0);`
		2528	`nl = get_tdfint();`
		2529	`for (; nl != 0; nl--) {`
		2530	`IGNORE d_tagshacc(n + 1);`
		2531	`}`
		2532	`return(nl);`
		2533	`}`
		2534
		2535
		2536	`/* DECODE SIMPLE TDFIDENT LIST */`
		2537
		2538	`unsigned int`
		2539	`d_tdfident_list(int n)`
		2540	`{`
		2541	`unsigned int nl = get_tdfint();`
		2542	`for (; nl != 0; nl--) {`
		2543	`IGNORE d_tdfident(n + 1);`
		2544	`}`
		2545	`return(nl);`
		2546	`}`
		2547
		2548
		2549	`/* DECODE SIMPLE TDFINT LIST */`
		2550
		2551	`unsigned int`
		2552	`d_tdfint_list(int n)`
		2553	`{`
		2554	`unsigned int nl = get_tdfint();`
		2555	`for (; nl != 0; nl--) {`
		2556	`IGNORE d_tdfint(n + 1);`
		2557	`}`
		2558	`return(nl);`
		2559	`}`
		2560
		2561
		2562	`/* DECODE TOKDEC */`
		2563
		2564	`unsigned int`
		2565	`d_tokdec(int n)`
		2566	`{`
		2567	`unsigned int enc = get_basic_int(1, 1);`
		2568	`switch (enc) {`
		2569	`case e_make_tokdec:`
		2570	`consname("make_tokdec", n);`
		2571	`IGNORE d_tdfint(n + 1);`
		2572	`IGNORE d_string_option(n + 1);`
		2573	`IGNORE d_sortname(n + 1);`
		2574	`break;`
		2575	`default:`
		2576	`fail("Bad tokdec value, 32", enc);`
		2577	`break;`
		2578	`}`
		2579	`return(enc);`
		2580	`}`
		2581
		2582
		2583	`/* DECODE SIMPLE TOKDEC LIST */`
		2584
		2585	`unsigned int`
		2586	`d_tokdec_list(int n)`
		2587	`{`
		2588	`unsigned int nl = get_tdfint();`
		2589	`for (; nl != 0; nl--) {`
		2590	`IGNORE d_tokdec(n + 1);`
		2591	`}`
		2592	`return(nl);`
		2593	`}`
		2594
		2595
		2596	`/* DECODE TOKDEC_PROPS */`
		2597
		2598	`unsigned int`
		2599	`d_tokdec_props(int n)`
		2600	`{`
		2601	`consname("make_tokdecs", n);`
		2602	`IGNORE d_tokdec_list(n + 1);`
		2603	`return(0);`
		2604	`}`
		2605
		2606
		2607	`/* DECODE TOKDEF */`
		2608
		2609	`unsigned int`
		2610	`d_tokdef(int n)`
		2611	`{`
		2612	`unsigned int enc = get_basic_int(1, 1);`
		2613	`switch (enc) {`
		2614	`case e_make_tokdef:`
		2615	`consname("make_tokdef", n);`
		2616	`IGNORE d_tdfint(n + 1);`
		2617	`IGNORE d_string_option(n + 1);`
		2618	`IGNORE d_bitstream("make_tokdef", n + 1);`
		2619	`break;`
		2620	`default:`
		2621	`fail("Bad tokdef value, 33", enc);`
		2622	`break;`
		2623	`}`
		2624	`return(enc);`
		2625	`}`
		2626
		2627
		2628	`/* DECODE SIMPLE TOKDEF LIST */`
		2629
		2630	`unsigned int`
		2631	`d_tokdef_list(int n)`
		2632	`{`
		2633	`unsigned int nl = get_tdfint();`
		2634	`for (; nl != 0; nl--) {`
		2635	`IGNORE d_tokdef(n + 1);`
		2636	`}`
		2637	`return(nl);`
		2638	`}`
		2639
		2640
		2641	`/* DECODE TOKDEF_PROPS */`
		2642
		2643	`unsigned int`
		2644	`d_tokdef_props(int n)`
		2645	`{`
		2646	`consname("make_tokdefs", n);`
		2647	`IGNORE d_tdfint(n + 1);`
		2648	`IGNORE d_tokdef_list(n + 1);`
		2649	`return(0);`
		2650	`}`
		2651
		2652
		2653	`/* DECODE TOKEN */`
		2654
		2655	`unsigned int`
		2656	`d_token(int n)`
		2657	`{`
		2658	`unsigned int enc = get_basic_int(2, 1);`
		2659	`switch (enc) {`
		2660	`case e_token_apply_token:`
		2661	`consname("token_apply_token", n);`
		2662	`IGNORE d_token(n + 1);`
		2663	`IGNORE d_bitstream("token_apply_token", n + 1);`
		2664	`break;`
		2665	`case e_make_tok:`
		2666	`consname("make_tok", n);`
		2667	`IGNORE d_tdfint(n + 1);`
		2668	`break;`
		2669	`case e_use_tokdef:`
		2670	`consname("use_tokdef", n);`
		2671	`IGNORE d_bitstream("use_tokdef", n + 1);`
		2672	`break;`
		2673	`default:`
		2674	`fail("Bad token value, 34", enc);`
		2675	`break;`
		2676	`}`
		2677	`return(enc);`
		2678	`}`
		2679
		2680
		2681	`/* DECODE TOKEN_DEFN */`
		2682
		2683	`unsigned int`
		2684	`d_token_defn(int n)`
		2685	`{`
		2686	`unsigned int enc = get_basic_int(1, 1);`
		2687	`switch (enc) {`
		2688	`case e_token_definition:`
		2689	`consname("token_definition", n);`
		2690	`IGNORE d_sortname(n + 1);`
		2691	`IGNORE d_tokformals_list(n + 1);`
		2692	`break;`
		2693	`default:`
		2694	`fail("Bad token_defn value, 35", enc);`
		2695	`break;`
		2696	`}`
		2697	`return(enc);`
		2698	`}`
		2699
		2700
		2701	`/* DECODE TOKFORMALS */`
		2702
		2703	`unsigned int`
		2704	`d_tokformals(int n)`
		2705	`{`
		2706	`consname("make_tokformals", n);`
		2707	`IGNORE d_sortname(n + 1);`
		2708	`IGNORE d_tdfint(n + 1);`
		2709	`return(0);`
		2710	`}`
		2711
		2712
		2713	`/* DECODE TOKFORMALS LIST */`
		2714
		2715	`unsigned int`
		2716	`d_tokformals_list(int n)`
		2717	`{`
		2718	`unsigned int nl;`
		2719	`IGNORE get_basic_int(1, 0);`
		2720	`nl = get_tdfint();`
		2721	`for (; nl != 0; nl--) {`
		2722	`IGNORE d_tokformals(n + 1);`
		2723	`}`
		2724	`return(nl);`
		2725	`}`
		2726
		2727
		2728	`/* DECODE TRANSFER_MODE */`
		2729
		2730	`unsigned int`
		2731	`d_transfer_mode(int n)`
		2732	`{`
		2733	`unsigned int enc = get_basic_int(3, 1);`
		2734	`switch (enc) {`
		2735	`case e_transfer_mode_apply_token:`
		2736	`consname("transfer_mode_apply_token", n);`
		2737	`IGNORE d_token(n + 1);`
		2738	`IGNORE d_bitstream("transfer_mode_apply_token", n + 1);`
		2739	`break;`
		2740	`case e_transfer_mode_cond:`
		2741	`consname("transfer_mode_cond", n);`
		2742	`IGNORE d_exp(n + 1);`
		2743	`IGNORE d_bitstream("transfer_mode_cond", n + 1);`
		2744	`IGNORE d_bitstream("transfer_mode_cond", n + 1);`
		2745	`break;`
		2746	`case e_add_modes:`
		2747	`consname("add_modes", n);`
		2748	`IGNORE d_transfer_mode(n + 1);`
		2749	`IGNORE d_transfer_mode(n + 1);`
		2750	`break;`
		2751	`case e_overlap:`
		2752	`consname("overlap", n);`
		2753	`break;`
		2754	`case e_standard_transfer_mode:`
		2755	`consname("standard_transfer_mode", n);`
		2756	`break;`
		2757	`case e_trap_on_nil:`
		2758	`consname("trap_on_nil", n);`
		2759	`break;`
		2760	`case e_volatile:`
		2761	`consname("volatile", n);`
		2762	`break;`
		2763	`case e_complete:`
		2764	`consname("complete", n);`
		2765	`break;`
		2766	`default:`
		2767	`fail("Bad transfer_mode value, 36", enc);`
		2768	`break;`
		2769	`}`
		2770	`return(enc);`
		2771	`}`
		2772
		2773
		2774	`/* DECODE UNIQUE */`
		2775
		2776	`unsigned int`
		2777	`d_unique(int n)`
		2778	`{`
		2779	`consname("make_unique", n);`
		2780	`IGNORE d_tdfident_list(n + 1);`
		2781	`return(0);`
		2782	`}`
		2783
		2784
		2785	`/* DECODE UNIT */`
		2786
		2787	`unsigned int`
		2788	`d_unit(int n)`
		2789	`{`
		2790	`consname("make_unit", n);`
		2791	`IGNORE d_tdfint_list(n + 1);`
		2792	`IGNORE d_links_list(n + 1);`
		2793	`IGNORE d_bytestream(n + 1);`
		2794	`return(0);`
		2795	`}`
		2796
		2797
		2798	`/* DECODE SIMPLE UNIT LIST */`
		2799
		2800	`unsigned int`
		2801	`d_unit_list(int n)`
		2802	`{`
		2803	`unsigned int nl = get_tdfint();`
		2804	`for (; nl != 0; nl--) {`
		2805	`IGNORE d_unit(n + 1);`
		2806	`}`
		2807	`return(nl);`
		2808	`}`
		2809
		2810
		2811	`/* DECODE VARIETY */`
		2812
		2813	`unsigned int`
		2814	`d_variety(int n)`
		2815	`{`
		2816	`unsigned int enc = get_basic_int(2, 1);`
		2817	`switch (enc) {`
		2818	`case e_var_apply_token:`
		2819	`consname("var_apply_token", n);`
		2820	`IGNORE d_token(n + 1);`
		2821	`IGNORE d_bitstream("var_apply_token", n + 1);`
		2822	`break;`
		2823	`case e_var_cond:`
		2824	`consname("var_cond", n);`
		2825	`IGNORE d_exp(n + 1);`
		2826	`IGNORE d_bitstream("var_cond", n + 1);`
		2827	`IGNORE d_bitstream("var_cond", n + 1);`
		2828	`break;`
		2829	`case e_var_limits:`
		2830	`consname("var_limits", n);`
		2831	`IGNORE d_signed_nat(n + 1);`
		2832	`IGNORE d_signed_nat(n + 1);`
		2833	`break;`
		2834	`case e_var_width:`
		2835	`consname("var_width", n);`
		2836	`IGNORE d_bool(n + 1);`
		2837	`IGNORE d_nat(n + 1);`
		2838	`break;`
		2839	`default:`
		2840	`fail("Bad variety value, 37", enc);`
		2841	`break;`
		2842	`}`
		2843	`return(enc);`
		2844	`}`
		2845
		2846
		2847	`/* DECODE VERSION */`
		2848
		2849	`unsigned int`
		2850	`d_version(int n)`
		2851	`{`
		2852	`unsigned int enc = get_basic_int(1, 1);`
		2853	`switch (enc) {`
		2854	`case e_make_version:`
		2855	`consname("make_version", n);`
		2856	`IGNORE d_tdfint(n + 1);`
		2857	`IGNORE d_tdfint(n + 1);`
		2858	`break;`
		2859	`case e_user_info:`
		2860	`consname("user_info", n);`
		2861	`IGNORE d_string(n + 1);`
		2862	`break;`
		2863	`default:`
		2864	`fail("Bad version value, 38", enc);`
		2865	`break;`
		2866	`}`
		2867	`return(enc);`
		2868	`}`
		2869
		2870
		2871	`/* DECODE SIMPLE VERSION LIST */`
		2872
		2873	`unsigned int`
		2874	`d_version_list(int n)`
		2875	`{`
		2876	`unsigned int nl = get_tdfint();`
		2877	`for (; nl != 0; nl--) {`
		2878	`IGNORE d_version(n + 1);`
		2879	`}`
		2880	`return(nl);`
		2881	`}`
		2882
		2883
		2884	`/* DECODE VERSION_PROPS */`
		2885
		2886	`unsigned int`
		2887	`d_version_props(int n)`
		2888	`{`
		2889	`consname("make_versions", n);`
		2890	`IGNORE d_version_list(n + 1);`
		2891	`return(0);`
		2892	`}`

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/tools/tpl/decodings.c – Rev 6