WebSVN – tendra.SVN – Blame – /trunk/src/installers/common/reader/decoder.c

Rev	Author	Line No.	Line
2	7u83	1	`/*`
7	7u83	2	`* Copyright (c) 2002-2005 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	`/*`
2	7u83	32	`Crown Copyright (c) 1997`
7	7u83	33
2	7u83	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:-`
7	7u83	42
2	7u83	43	`(1) Its Recipients shall ensure that this Notice is`
		44	`reproduced upon any copies or amended versions of it;`
7	7u83	45
2	7u83	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;`
7	7u83	49
2	7u83	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;`
7	7u83	53
2	7u83	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	`/* AUTOMATICALLY GENERATED BY make_tdf VERSION 2.0 FROM TDF 4.1 */`
		62
		63	`#include "config.h"`
		64	`#include "common_types.h"`
		65	`#include "basicread.h"`
		66	`#include "ecodes.h"`
		67	`#include "externs.h"`
		68	`#include "messages_r.h"`
		69	`#include "main_reads.h"`
		70	`#include "check.h"`
		71
		72
		73	`/* REPORT AN ERROR */`
		74
7	7u83	75	`static void`
		76	`decode_error(char *s)`
2	7u83	77	`{`
7	7u83	78	`failer(s);`
		79	`exit(EXIT_FAILURE);`
2	7u83	80	`}`
		81
		82
		83	`/* DECODE ACCESS */`
		84
7	7u83	85	`access`
		86	`d_access(void)`
2	7u83	87	`{`
7	7u83	88	`int code = get_big_code(4);`
		89	`switch (code) {`
		90	`case e_access_apply_token: {`
		91	`token p0;`
		92	`bitstream p1;`
		93	`p0 = d_token();`
		94	`p1 = d_bitstream();`
		95	`return(f_access_apply_token(p0, p1));`
2	7u83	96	`}`
7	7u83	97	`case e_access_cond: {`
		98	`exp p0;`
		99	`bitstream p1;`
		100	`bitstream p2;`
		101	`p0 = hold_const_check(d_exp());`
		102	`p1 = d_bitstream();`
		103	`p2 = d_bitstream();`
		104	`return(f_access_cond(p0, p1, p2));`
2	7u83	105	`}`
7	7u83	106	`case e_add_accesses: {`
		107	`access p0;`
		108	`access p1;`
		109	`p0 = d_access();`
		110	`p1 = d_access();`
		111	`return(f_add_accesses(p0, p1));`
2	7u83	112	`}`
7	7u83	113	`case e_constant: {`
		114	`return(f_constant);`
2	7u83	115	`}`
7	7u83	116	`case e_long_jump_access: {`
		117	`return(f_long_jump_access);`
2	7u83	118	`}`
7	7u83	119	`case e_no_other_read: {`
		120	`return(f_no_other_read);`
2	7u83	121	`}`
7	7u83	122	`case e_no_other_write: {`
		123	`return(f_no_other_write);`
2	7u83	124	`}`
7	7u83	125	`case e_out_par: {`
		126	`return(f_out_par);`
2	7u83	127	`}`
7	7u83	128	`case e_preserve: {`
		129	`return(f_preserve);`
2	7u83	130	`}`
7	7u83	131	`case e_register: {`
		132	`return(f_register);`
2	7u83	133	`}`
7	7u83	134	`case e_standard_access: {`
		135	`return(f_standard_access);`
2	7u83	136	`}`
7	7u83	137	`case e_used_as_volatile: {`
		138	`return(f_used_as_volatile);`
2	7u83	139	`}`
7	7u83	140	`case e_visible: {`
		141	`return(f_visible);`
2	7u83	142	`}`
		143	`}`
7	7u83	144	`decode_error(ILLEGAL_CODE_access);`
		145	`return(f_dummy_access);`
2	7u83	146	`}`
		147
		148
		149	`/* DECODE ACCESS_OPTION */`
		150
7	7u83	151	`access_option`
		152	`d_access_option(void)`
2	7u83	153	`{`
7	7u83	154	`if (getcode(1)) {`
		155	`access e;`
		156	`e = d_access();`
		157	`return(yes_access_option(e));`
2	7u83	158	`}`
7	7u83	159	`return(no_access_option);`
2	7u83	160	`}`
		161
		162
		163	`/* DECODE AL_TAG */`
		164
7	7u83	165	`al_tag`
		166	`d_al_tag(void)`
2	7u83	167	`{`
7	7u83	168	`int code = get_big_code(1);`
		169	`switch (code) {`
		170	`case e_al_tag_apply_token: {`
		171	`token p0;`
		172	`bitstream p1;`
		173	`p0 = d_token();`
		174	`p1 = d_bitstream();`
		175	`return(f_al_tag_apply_token(p0, p1));`
2	7u83	176	`}`
7	7u83	177	`case e_make_al_tag: {`
		178	`tdfint p0;`
		179	`p0 = d_tdfint();`
		180	`return(f_make_al_tag(p0));`
2	7u83	181	`}`
		182	`}`
7	7u83	183	`decode_error(ILLEGAL_CODE_al_tag);`
		184	`return(f_dummy_al_tag);`
2	7u83	185	`}`
		186
		187
		188	`/* DECODE AL_TAGDEF */`
		189
7	7u83	190	`al_tagdef`
		191	`d_al_tagdef(void)`
2	7u83	192	`{`
7	7u83	193	`int code = get_big_code(1);`
		194	`switch (code) {`
		195	`case e_make_al_tagdef: {`
		196	`tdfint p0;`
		197	`alignment p1;`
		198	`p0 = d_tdfint();`
		199	`p1 = d_alignment();`
		200	`return(f_make_al_tagdef(p0, p1));`
2	7u83	201	`}`
		202	`}`
7	7u83	203	`decode_error(ILLEGAL_CODE_al_tagdef);`
		204	`return(f_dummy_al_tagdef);`
2	7u83	205	`}`
		206
		207
		208	`/* DECODE AL_TAGDEF_LIST */`
		209
7	7u83	210	`al_tagdef_list`
		211	`d_al_tagdef_list(void)`
2	7u83	212	`{`
7	7u83	213	`int i, n;`
		214	`al_tagdef_list temp;`
		215	`n = small_dtdfint();`
		216	`temp = new_al_tagdef_list(n);`
		217	`for (i = 0; i < n; i++) {`
		218	`al_tagdef e;`
		219	`e = d_al_tagdef();`
		220	`temp = add_al_tagdef_list(temp, e, i);`
2	7u83	221	`}`
7	7u83	222	`return(temp);`
2	7u83	223	`}`
		224
		225
		226	`/* DECODE AL_TAGDEF_PROPS */`
		227
7	7u83	228	`al_tagdef_props`
		229	`d_al_tagdef_props(void)`
2	7u83	230	`{`
7	7u83	231	`tdfint p0;`
		232	`al_tagdef_list p1;`
		233	`p0 = d_tdfint();`
		234	`p1 = d_al_tagdef_list();`
		235	`return(f_make_al_tagdefs(p0, p1));`
2	7u83	236	`}`
		237
		238
		239	`/* DECODE ALIGNMENT */`
		240
7	7u83	241	`alignment`
		242	`d_alignment(void)`
2	7u83	243	`{`
7	7u83	244	`int code = get_big_code(4);`
		245	`switch (code) {`
		246	`case e_alignment_apply_token: {`
		247	`token p0;`
		248	`bitstream p1;`
		249	`p0 = d_token();`
		250	`p1 = d_bitstream();`
		251	`return(f_alignment_apply_token(p0, p1));`
2	7u83	252	`}`
7	7u83	253	`case e_alignment_cond: {`
		254	`exp p0;`
		255	`bitstream p1;`
		256	`bitstream p2;`
		257	`p0 = hold_const_check(d_exp());`
		258	`p1 = d_bitstream();`
		259	`p2 = d_bitstream();`
		260	`return(f_alignment_cond(p0, p1, p2));`
2	7u83	261	`}`
7	7u83	262	`case e_alignment: {`
		263	`shape p0;`
		264	`p0 = d_shape();`
		265	`return(f_alignment(p0));`
2	7u83	266	`}`
7	7u83	267	`case e_alloca_alignment: {`
		268	`return(f_alloca_alignment);`
2	7u83	269	`}`
7	7u83	270	`case e_callees_alignment: {`
		271	`bool p0;`
		272	`p0 = d_bool();`
		273	`return(f_callees_alignment(p0));`
2	7u83	274	`}`
7	7u83	275	`case e_callers_alignment: {`
		276	`bool p0;`
		277	`p0 = d_bool();`
		278	`return(f_callers_alignment(p0));`
2	7u83	279	`}`
7	7u83	280	`case e_code_alignment: {`
		281	`return(f_code_alignment);`
2	7u83	282	`}`
7	7u83	283	`case e_locals_alignment: {`
		284	`return(f_locals_alignment);`
2	7u83	285	`}`
7	7u83	286	`case e_obtain_al_tag: {`
		287	`al_tag p0;`
		288	`p0 = d_al_tag();`
		289	`return(f_obtain_al_tag(p0));`
2	7u83	290	`}`
7	7u83	291	`case e_parameter_alignment: {`
		292	`shape p0;`
		293	`p0 = d_shape();`
		294	`return(f_parameter_alignment(p0));`
2	7u83	295	`}`
7	7u83	296	`case e_unite_alignments: {`
		297	`alignment p0;`
		298	`alignment p1;`
		299	`p0 = d_alignment();`
		300	`p1 = d_alignment();`
		301	`return(f_unite_alignments(p0, p1));`
2	7u83	302	`}`
7	7u83	303	`case e_var_param_alignment: {`
		304	`return(f_var_param_alignment);`
2	7u83	305	`}`
		306	`}`
7	7u83	307	`decode_error(ILLEGAL_CODE_alignment);`
		308	`return(f_dummy_alignment);`
2	7u83	309	`}`
		310
		311
		312	`/* DECODE BITFIELD_VARIETY */`
		313
7	7u83	314	`bitfield_variety`
		315	`d_bitfield_variety(void)`
2	7u83	316	`{`
7	7u83	317	`int code = get_big_code(2);`
		318	`switch (code) {`
		319	`case e_bfvar_apply_token: {`
		320	`token p0;`
		321	`bitstream p1;`
		322	`p0 = d_token();`
		323	`p1 = d_bitstream();`
		324	`return(f_bfvar_apply_token(p0, p1));`
2	7u83	325	`}`
7	7u83	326	`case e_bfvar_cond: {`
		327	`exp p0;`
		328	`bitstream p1;`
		329	`bitstream p2;`
		330	`p0 = hold_const_check(d_exp());`
		331	`p1 = d_bitstream();`
		332	`p2 = d_bitstream();`
		333	`return(f_bfvar_cond(p0, p1, p2));`
2	7u83	334	`}`
7	7u83	335	`case e_bfvar_bits: {`
		336	`bool p0;`
		337	`nat p1;`
		338	`p0 = d_bool();`
		339	`p1 = d_nat();`
		340	`return(f_bfvar_bits(p0, p1));`
2	7u83	341	`}`
		342	`}`
7	7u83	343	`decode_error(ILLEGAL_CODE_bitfield_variety);`
		344	`return(f_dummy_bitfield_variety);`
2	7u83	345	`}`
		346
		347
		348	`/* DECODE BOOL */`
		349
7	7u83	350	`bool`
		351	`d_bool(void)`
2	7u83	352	`{`
7	7u83	353	`int code = get_big_code(3);`
		354	`switch (code) {`
		355	`case e_bool_apply_token: {`
		356	`token p0;`
		357	`bitstream p1;`
		358	`p0 = d_token();`
		359	`p1 = d_bitstream();`
		360	`return(f_bool_apply_token(p0, p1));`
2	7u83	361	`}`
7	7u83	362	`case e_bool_cond: {`
		363	`exp p0;`
		364	`bitstream p1;`
		365	`bitstream p2;`
		366	`p0 = hold_const_check(d_exp());`
		367	`p1 = d_bitstream();`
		368	`p2 = d_bitstream();`
		369	`return(f_bool_cond(p0, p1, p2));`
2	7u83	370	`}`
7	7u83	371	`case e_false: {`
		372	`return(f_false);`
2	7u83	373	`}`
7	7u83	374	`case e_true: {`
		375	`return(f_true);`
2	7u83	376	`}`
		377	`}`
7	7u83	378	`decode_error(ILLEGAL_CODE_bool);`
		379	`return(f_dummy_bool);`
2	7u83	380	`}`
		381
		382
		383	`/* DECODE BOOL_OPTION */`
		384
7	7u83	385	`bool_option`
		386	`d_bool_option(void)`
2	7u83	387	`{`
7	7u83	388	`if (getcode(1)) {`
		389	`bool e;`
		390	`e = d_bool();`
		391	`return(yes_bool_option(e));`
2	7u83	392	`}`
7	7u83	393	`return(no_bool_option);`
2	7u83	394	`}`
		395
		396
		397	`/* DECODE CALLEES */`
		398
7	7u83	399	`callees`
		400	`d_callees(void)`
2	7u83	401	`{`
7	7u83	402	`int code = get_big_code(2);`
		403	`switch (code) {`
		404	`case e_make_callee_list: {`
		405	`exp_list p0;`
		406	`p0 = d_exp_list();`
		407	`return(f_make_callee_list(p0));`
2	7u83	408	`}`
7	7u83	409	`case e_make_dynamic_callees: {`
		410	`exp p0;`
		411	`exp p1;`
		412	`p0 = hold_check(d_exp());`
		413	`p1 = hold_check(d_exp());`
		414	`return(f_make_dynamic_callees(p0, p1));`
2	7u83	415	`}`
7	7u83	416	`case e_same_callees: {`
		417	`return(f_same_callees);`
2	7u83	418	`}`
		419	`}`
7	7u83	420	`decode_error(ILLEGAL_CODE_callees);`
		421	`return(f_dummy_callees);`
2	7u83	422	`}`
		423
		424
		425	`/* DECODE CAPSULE */`
		426
7	7u83	427	`capsule`
		428	`d_capsule(void)`
2	7u83	429	`{`
7	7u83	430	`tdfident_list p0;`
		431	`capsule_link_list p1;`
		432	`extern_link_list p2;`
		433	`group_list p3;`
		434	`p0 = d_tdfident_list();`
		435	`p1 = d_capsule_link_list();`
		436	`start_make_capsule(p0, p1);`
		437	`p2 = d_extern_link_list();`
		438	`p3 = d_group_list();`
		439	`return(f_make_capsule(p0, p1, p2, p3));`
2	7u83	440	`}`
		441
		442
		443	`/* DECODE CAPSULE_LINK */`
		444
7	7u83	445	`capsule_link`
		446	`d_capsule_link(void)`
2	7u83	447	`{`
7	7u83	448	`tdfident p0;`
		449	`tdfint p1;`
		450	`p0 = d_tdfident();`
		451	`p1 = d_tdfint();`
		452	`return(f_make_capsule_link(p0, p1));`
2	7u83	453	`}`
		454
		455
		456	`/* DECODE CAPSULE_LINK_LIST */`
		457
7	7u83	458	`capsule_link_list`
		459	`d_capsule_link_list(void)`
2	7u83	460	`{`
7	7u83	461	`int i, n;`
		462	`capsule_link_list temp;`
		463	`n = small_dtdfint();`
		464	`temp = new_capsule_link_list(n);`
		465	`for (i = 0; i < n; i++) {`
		466	`capsule_link e;`
		467	`e = d_capsule_link();`
		468	`temp = add_capsule_link_list(temp, e, i);`
2	7u83	469	`}`
7	7u83	470	`return(temp);`
2	7u83	471	`}`
		472
		473
		474	`/* DECODE CASELIM */`
		475
7	7u83	476	`caselim`
		477	`d_caselim(void)`
2	7u83	478	`{`
7	7u83	479	`label p0;`
		480	`signed_nat p1;`
		481	`signed_nat p2;`
		482	`p0 = d_label();`
		483	`p1 = d_signed_nat();`
		484	`p2 = d_signed_nat();`
		485	`return(f_make_caselim(p0, p1, p2));`
2	7u83	486	`}`
		487
		488
		489	`/* DECODE CASELIM_LIST */`
		490
7	7u83	491	`caselim_list`
		492	`d_caselim_list(void)`
2	7u83	493	`{`
7	7u83	494	`int i, n;`
		495	`caselim_list temp;`
		496	`IGNORE getcode(1);`
		497	`n = small_dtdfint();`
		498	`temp = new_caselim_list(n);`
		499	`for (i = 0; i < n; i++) {`
		500	`caselim e;`
		501	`e = d_caselim();`
		502	`temp = add_caselim_list(temp, e, i);`
2	7u83	503	`}`
7	7u83	504	`return(temp);`
2	7u83	505	`}`
		506
		507
		508	`/* DECODE DG */`
		509
7	7u83	510	`dg`
		511	`d_dg(void)`
2	7u83	512	`{`
7	7u83	513	`int code = get_big_code(6);`
		514	`switch (code) {`
		515	`case e_dg_apply_token: {`
		516	`token p0;`
		517	`bitstream p1;`
		518	`p0 = d_token();`
		519	`p1 = d_bitstream();`
		520	`return(f_dg_apply_token(p0, p1));`
2	7u83	521	`}`
7	7u83	522	`case e_make_tag_dg: {`
		523	`dg_tag p0;`
		524	`dg p1;`
		525	`p0 = d_dg_tag();`
		526	`p1 = d_dg();`
		527	`return(f_make_tag_dg(p0, p1));`
2	7u83	528	`}`
7	7u83	529	`case e_abortable_part_dg: {`
		530	`dg_sourcepos p0;`
		531	`bool p1;`
		532	`p0 = d_dg_sourcepos();`
		533	`p1 = d_bool();`
		534	`return(f_abortable_part_dg(p0, p1));`
2	7u83	535	`}`
7	7u83	536	`case e_accept_dg: {`
		537	`dg_sourcepos p0;`
		538	`dg_tag p1;`
		539	`dg_name_list p2;`
		540	`bool p3;`
		541	`dg_tag_option p4;`
		542	`p0 = d_dg_sourcepos();`
		543	`p1 = d_dg_tag();`
		544	`p2 = d_dg_name_list();`
		545	`p3 = d_bool();`
		546	`p4 = d_dg_tag_option();`
		547	`return(f_accept_dg(p0, p1, p2, p3, p4));`
2	7u83	548	`}`
7	7u83	549	`case e_barrier_dg: {`
		550	`dg_sourcepos p0;`
		551	`dg_tag p1;`
		552	`p0 = d_dg_sourcepos();`
		553	`p1 = d_dg_tag();`
		554	`return(f_barrier_dg(p0, p1));`
2	7u83	555	`}`
7	7u83	556	`case e_branch_dg: {`
		557	`dg_sourcepos p0;`
		558	`p0 = d_dg_sourcepos();`
		559	`return(f_branch_dg(p0));`
2	7u83	560	`}`
7	7u83	561	`case e_call_dg: {`
		562	`dg_idname_option p0;`
		563	`dg_sourcepos p1;`
		564	`nat_option p2;`
		565	`dg_tag_option p3;`
		566	`dg_tag_option p4;`
		567	`p0 = d_dg_idname_option();`
		568	`p1 = d_dg_sourcepos();`
		569	`p2 = d_nat_option();`
		570	`p3 = d_dg_tag_option();`
		571	`p4 = d_dg_tag_option();`
		572	`return(f_call_dg(p0, p1, p2, p3, p4));`
2	7u83	573	`}`
7	7u83	574	`case e_compilation_dg: {`
		575	`dg_tag p0;`
		576	`p0 = d_dg_tag();`
		577	`return(f_compilation_dg(p0));`
2	7u83	578	`}`
7	7u83	579	`case e_destructor_dg: {`
		580	`dg_sourcepos p0;`
		581	`exp_option p1;`
		582	`p0 = d_dg_sourcepos();`
		583	`p1 = d_exp_option();`
		584	`return(f_destructor_dg(p0, p1));`
2	7u83	585	`}`
7	7u83	586	`case e_exception_handler_dg: {`
		587	`dg_name_option p0;`
		588	`p0 = d_dg_name_option();`
		589	`return(f_exception_handler_dg(p0));`
2	7u83	590	`}`
7	7u83	591	`case e_exception_scope_dg: {`
		592	`dg_tag_list p0;`
		593	`p0 = d_dg_tag_list();`
		594	`return(f_exception_scope_dg(p0));`
2	7u83	595	`}`
7	7u83	596	`case e_inline_call_dg: {`
		597	`dg_tag p0;`
		598	`dg_name_list p1;`
		599	`nat_option p2;`
		600	`p0 = d_dg_tag();`
		601	`p1 = d_dg_name_list();`
		602	`p2 = d_nat_option();`
		603	`return(f_inline_call_dg(p0, p1, p2));`
2	7u83	604	`}`
7	7u83	605	`case e_inline_result_dg: {`
		606	`dg_tag p0;`
		607	`p0 = d_dg_tag();`
		608	`return(f_inline_result_dg(p0));`
2	7u83	609	`}`
7	7u83	610	`case e_inlined_dg: {`
		611	`dg p0;`
		612	`dg_tag p1;`
		613	`p0 = d_dg();`
		614	`p1 = d_dg_tag();`
		615	`return(f_inlined_dg(p0, p1));`
2	7u83	616	`}`
7	7u83	617	`case e_jump_dg: {`
		618	`dg_sourcepos p0;`
		619	`p0 = d_dg_sourcepos();`
		620	`return(f_jump_dg(p0));`
2	7u83	621	`}`
7	7u83	622	`case e_label_dg: {`
		623	`dg_idname p0;`
		624	`dg_sourcepos p1;`
		625	`p0 = d_dg_idname();`
		626	`p1 = d_dg_sourcepos();`
		627	`return(f_label_dg(p0, p1));`
2	7u83	628	`}`
7	7u83	629	`case e_lexical_block_dg: {`
		630	`dg_idname_option p0;`
		631	`dg_sourcepos p1;`
		632	`p0 = d_dg_idname_option();`
		633	`p1 = d_dg_sourcepos();`
		634	`return(f_lexical_block_dg(p0, p1));`
2	7u83	635	`}`
7	7u83	636	`case e_list_dg: {`
		637	`dg_list p0;`
		638	`p0 = d_dg_list();`
		639	`return(f_list_dg(p0));`
2	7u83	640	`}`
7	7u83	641	`case e_long_jump_dg: {`
		642	`dg_sourcepos p0;`
		643	`p0 = d_dg_sourcepos();`
		644	`return(f_long_jump_dg(p0));`
2	7u83	645	`}`
7	7u83	646	`case e_name_decl_dg: {`
		647	`dg_name p0;`
		648	`p0 = d_dg_name();`
		649	`return(f_name_decl_dg(p0));`
2	7u83	650	`}`
7	7u83	651	`case e_params_dg: {`
		652	`dg_name_list p0;`
		653	`exp_option p1;`
		654	`p0 = d_dg_name_list();`
		655	`p1 = d_exp_option();`
		656	`return(f_params_dg(p0, p1));`
2	7u83	657	`}`
7	7u83	658	`case e_raise_dg: {`
		659	`dg_sourcepos p0;`
		660	`dg_type_option p1;`
		661	`exp_option p2;`
		662	`p0 = d_dg_sourcepos();`
		663	`p1 = d_dg_type_option();`
		664	`p2 = d_exp_option();`
		665	`return(f_raise_dg(p0, p1, p2));`
2	7u83	666	`}`
7	7u83	667	`case e_requeue_dg: {`
		668	`dg_sourcepos p0;`
		669	`dg_tag p1;`
		670	`bool p2;`
		671	`p0 = d_dg_sourcepos();`
		672	`p1 = d_dg_tag();`
		673	`p2 = d_bool();`
		674	`return(f_requeue_dg(p0, p1, p2));`
2	7u83	675	`}`
7	7u83	676	`case e_rts_call_dg: {`
		677	`dg_sourcepos p0;`
		678	`nat p1;`
		679	`dg_tag_option p2;`
		680	`dg_tag_option p3;`
		681	`p0 = d_dg_sourcepos();`
		682	`p1 = d_nat();`
		683	`p2 = d_dg_tag_option();`
		684	`p3 = d_dg_tag_option();`
		685	`return(f_rts_call_dg(p0, p1, p2, p3));`
2	7u83	686	`}`
7	7u83	687	`case e_select_dg: {`
		688	`dg_sourcepos p0;`
		689	`bool p1;`
		690	`p0 = d_dg_sourcepos();`
		691	`p1 = d_bool();`
		692	`return(f_select_dg(p0, p1));`
2	7u83	693	`}`
7	7u83	694	`case e_select_alternative_dg: {`
		695	`dg_sourcepos p0;`
		696	`nat p1;`
		697	`bool p2;`
		698	`exp p3;`
		699	`p0 = d_dg_sourcepos();`
		700	`p1 = d_nat();`
		701	`p2 = d_bool();`
		702	`p3 = hold_check(d_exp());`
		703	`return(f_select_alternative_dg(p0, p1, p2, p3));`
2	7u83	704	`}`
7	7u83	705	`case e_select_guard_dg: {`
		706	`dg_sourcepos p0;`
		707	`dg_tag p1;`
		708	`p0 = d_dg_sourcepos();`
		709	`p1 = d_dg_tag();`
		710	`return(f_select_guard_dg(p0, p1));`
2	7u83	711	`}`
7	7u83	712	`case e_singlestep_dg: {`
		713	`dg_sourcepos p0;`
		714	`p0 = d_dg_sourcepos();`
		715	`return(f_singlestep_dg(p0));`
2	7u83	716	`}`
7	7u83	717	`case e_source_language_dg: {`
		718	`nat p0;`
		719	`p0 = d_nat();`
		720	`return(f_source_language_dg(p0));`
2	7u83	721	`}`
7	7u83	722	`case e_sourcepos_dg: {`
		723	`dg_sourcepos p0;`
		724	`p0 = d_dg_sourcepos();`
		725	`return(f_sourcepos_dg(p0));`
2	7u83	726	`}`
7	7u83	727	`case e_statement_part_dg: {`
		728	`dg_tag p0;`
		729	`p0 = d_dg_tag();`
		730	`return(f_statement_part_dg(p0));`
2	7u83	731	`}`
7	7u83	732	`case e_test_dg: {`
		733	`dg_sourcepos p0;`
		734	`bool p1;`
		735	`p0 = d_dg_sourcepos();`
		736	`p1 = d_bool();`
		737	`return(f_test_dg(p0, p1));`
2	7u83	738	`}`
7	7u83	739	`case e_triggering_alternative_dg: {`
		740	`dg_sourcepos p0;`
		741	`nat p1;`
		742	`bool p2;`
		743	`p0 = d_dg_sourcepos();`
		744	`p1 = d_nat();`
		745	`p2 = d_bool();`
		746	`return(f_triggering_alternative_dg(p0, p1, p2));`
2	7u83	747	`}`
7	7u83	748	`case e_with_dg: {`
		749	`dg_type p0;`
		750	`exp p1;`
		751	`p0 = d_dg_type();`
		752	`p1 = hold_check(d_exp());`
		753	`return(f_with_dg(p0, p1));`
2	7u83	754	`}`
		755	`}`
7	7u83	756	`decode_error(ILLEGAL_CODE_dg);`
		757	`return(f_dummy_dg);`
2	7u83	758	`}`
		759
		760
		761	`/* DECODE DG_ACCESSIBILITY */`
		762
7	7u83	763	`dg_accessibility`
		764	`d_dg_accessibility(void)`
2	7u83	765	`{`
7	7u83	766	`int code = get_big_code(2);`
		767	`switch (code) {`
		768	`case e_dg_local_accessibility: {`
		769	`return(f_dg_local_accessibility);`
2	7u83	770	`}`
7	7u83	771	`case e_dg_private_accessibility: {`
		772	`return(f_dg_private_accessibility);`
2	7u83	773	`}`
7	7u83	774	`case e_dg_protected_accessibility: {`
		775	`return(f_dg_protected_accessibility);`
2	7u83	776	`}`
7	7u83	777	`case e_dg_public_accessibility: {`
		778	`return(f_dg_public_accessibility);`
2	7u83	779	`}`
		780	`}`
7	7u83	781	`decode_error(ILLEGAL_CODE_dg_accessibility);`
		782	`return(f_dummy_dg_accessibility);`
2	7u83	783	`}`
		784
		785
		786	`/* DECODE DG_ACCESSIBILITY_OPTION */`
		787
7	7u83	788	`dg_accessibility_option`
		789	`d_dg_accessibility_option(void)`
2	7u83	790	`{`
7	7u83	791	`if (getcode(1)) {`
		792	`dg_accessibility e;`
		793	`e = d_dg_accessibility();`
		794	`return(yes_dg_accessibility_option(e));`
2	7u83	795	`}`
7	7u83	796	`return(no_dg_accessibility_option);`
2	7u83	797	`}`
		798
		799
		800	`/* DECODE DG_APPEND */`
		801
7	7u83	802	`dg_append`
		803	`d_dg_append(void)`
2	7u83	804	`{`
7	7u83	805	`int code = get_big_code(1);`
		806	`switch (code) {`
		807	`case e_dg_name_append: {`
		808	`dg_tag p0;`
		809	`dg_name p1;`
		810	`p0 = d_dg_tag();`
		811	`p1 = d_dg_name();`
		812	`return(f_dg_name_append(p0, p1));`
2	7u83	813	`}`
		814	`}`
7	7u83	815	`decode_error(ILLEGAL_CODE_dg_append);`
		816	`return(f_dummy_dg_append);`
2	7u83	817	`}`
		818
		819
		820	`/* DECODE DG_APPEND_LIST */`
		821
7	7u83	822	`dg_append_list`
		823	`d_dg_append_list(void)`
2	7u83	824	`{`
7	7u83	825	`int i, n;`
		826	`dg_append_list temp;`
		827	`n = small_dtdfint();`
		828	`temp = new_dg_append_list(n);`
		829	`for (i = 0; i < n; i++) {`
		830	`dg_append e;`
		831	`e = d_dg_append();`
		832	`temp = add_dg_append_list(temp, e, i);`
2	7u83	833	`}`
7	7u83	834	`return(temp);`
2	7u83	835	`}`
		836
		837
		838	`/* DECODE DG_BOUND */`
		839
7	7u83	840	`dg_bound`
		841	`d_dg_bound(void)`
2	7u83	842	`{`
7	7u83	843	`int code = get_big_code(2);`
		844	`switch (code) {`
		845	`case e_dg_dynamic_bound: {`
		846	`dg_tag p0;`
		847	`shape p1;`
		848	`p0 = d_dg_tag();`
		849	`p1 = d_shape();`
		850	`return(f_dg_dynamic_bound(p0, p1));`
2	7u83	851	`}`
7	7u83	852	`case e_dg_static_bound: {`
		853	`exp p0;`
		854	`p0 = hold_check(d_exp());`
		855	`return(f_dg_static_bound(p0));`
2	7u83	856	`}`
7	7u83	857	`case e_dg_unknown_bound: {`
		858	`shape p0;`
		859	`p0 = d_shape();`
		860	`return(f_dg_unknown_bound(p0));`
2	7u83	861	`}`
		862	`}`
7	7u83	863	`decode_error(ILLEGAL_CODE_dg_bound);`
		864	`return(f_dummy_dg_bound);`
2	7u83	865	`}`
		866
		867
		868	`/* DECODE DG_CLASS_BASE */`
		869
7	7u83	870	`dg_class_base`
		871	`d_dg_class_base(void)`
2	7u83	872	`{`
7	7u83	873	`int code = get_big_code(1);`
		874	`switch (code) {`
		875	`case e_make_dg_class_base: {`
		876	`dg_tag p0;`
		877	`dg_sourcepos_option p1;`
		878	`token_option p2;`
		879	`dg_accessibility_option p3;`
		880	`dg_virtuality_option p4;`
		881	`p0 = d_dg_tag();`
		882	`p1 = d_dg_sourcepos_option();`
		883	`p2 = d_token_option();`
		884	`p3 = d_dg_accessibility_option();`
		885	`p4 = d_dg_virtuality_option();`
		886	`return(f_make_dg_class_base(p0, p1, p2, p3, p4));`
2	7u83	887	`}`
		888	`}`
7	7u83	889	`decode_error(ILLEGAL_CODE_dg_class_base);`
		890	`return(f_dummy_dg_class_base);`
2	7u83	891	`}`
		892
		893
		894	`/* DECODE DG_CLASS_BASE_LIST */`
		895
7	7u83	896	`dg_class_base_list`
		897	`d_dg_class_base_list(void)`
2	7u83	898	`{`
7	7u83	899	`int i, n;`
		900	`dg_class_base_list temp;`
		901	`IGNORE getcode(1);`
		902	`n = small_dtdfint();`
		903	`temp = new_dg_class_base_list(n);`
		904	`for (i = 0; i < n; i++) {`
		905	`dg_class_base e;`
		906	`e = d_dg_class_base();`
		907	`temp = add_dg_class_base_list(temp, e, i);`
2	7u83	908	`}`
7	7u83	909	`return(temp);`
2	7u83	910	`}`
		911
		912
		913	`/* DECODE DG_CLASSMEM */`
		914
7	7u83	915	`dg_classmem`
		916	`d_dg_classmem(void)`
2	7u83	917	`{`
7	7u83	918	`int code = get_big_code(3);`
		919	`switch (code) {`
		920	`case e_dg_tag_classmem: {`
		921	`dg_tag p0;`
		922	`dg_classmem p1;`
		923	`p0 = d_dg_tag();`
		924	`p1 = d_dg_classmem();`
		925	`return(f_dg_tag_classmem(p0, p1));`
2	7u83	926	`}`
7	7u83	927	`case e_dg_field_classmem: {`
		928	`dg_idname p0;`
		929	`dg_sourcepos p1;`
		930	`exp p2;`
		931	`dg_type p3;`
		932	`dg_accessibility_option p4;`
		933	`bool_option p5;`
		934	`dg_default_option p6;`
		935	`p0 = d_dg_idname();`
		936	`p1 = d_dg_sourcepos();`
		937	`p2 = hold_check(d_exp());`
		938	`p3 = d_dg_type();`
		939	`p4 = d_dg_accessibility_option();`
		940	`p5 = d_bool_option();`
		941	`p6 = d_dg_default_option();`
		942	`return(f_dg_field_classmem(p0, p1, p2, p3, p4, p5, p6));`
2	7u83	943	`}`
7	7u83	944	`case e_dg_function_classmem: {`
		945	`dg_name p0;`
		946	`exp_option p1;`
		947	`p0 = d_dg_name();`
		948	`p1 = d_exp_option();`
		949	`return(f_dg_function_classmem(p0, p1));`
2	7u83	950	`}`
7	7u83	951	`case e_dg_indirect_classmem: {`
		952	`dg_idname p0;`
		953	`dg_sourcepos p1;`
		954	`token p2;`
		955	`dg_type p3;`
		956	`p0 = d_dg_idname();`
		957	`p1 = d_dg_sourcepos();`
		958	`p2 = d_token();`
		959	`p3 = d_dg_type();`
		960	`return(f_dg_indirect_classmem(p0, p1, p2, p3));`
2	7u83	961	`}`
7	7u83	962	`case e_dg_name_classmem: {`
		963	`dg_name p0;`
		964	`p0 = d_dg_name();`
		965	`return(f_dg_name_classmem(p0));`
2	7u83	966	`}`
		967	`}`
7	7u83	968	`decode_error(ILLEGAL_CODE_dg_classmem);`
		969	`return(f_dummy_dg_classmem);`
2	7u83	970	`}`
		971
		972
		973	`/* DECODE DG_CLASSMEM_LIST */`
		974
7	7u83	975	`dg_classmem_list`
		976	`d_dg_classmem_list(void)`
2	7u83	977	`{`
7	7u83	978	`int i, n;`
		979	`dg_classmem_list temp;`
		980	`IGNORE getcode(1);`
		981	`n = small_dtdfint();`
		982	`temp = new_dg_classmem_list(n);`
		983	`for (i = 0; i < n; i++) {`
		984	`dg_classmem e;`
		985	`e = d_dg_classmem();`
		986	`temp = add_dg_classmem_list(temp, e, i);`
2	7u83	987	`}`
7	7u83	988	`return(temp);`
2	7u83	989	`}`
		990
		991
		992	`/* DECODE DG_COMP_PROPS */`
		993
7	7u83	994	`dg_comp_props`
		995	`d_dg_comp_props(void)`
2	7u83	996	`{`
7	7u83	997	`tdfint p0;`
		998	`dg_compilation p1;`
		999	`dg_append_list p2;`
		1000	`p0 = d_tdfint();`
		1001	`p1 = d_dg_compilation();`
		1002	`p2 = d_dg_append_list();`
		1003	`return(f_make_dg_compunit(p0, p1, p2));`
2	7u83	1004	`}`
		1005
		1006
		1007	`/* DECODE DG_COMPILATION */`
		1008
7	7u83	1009	`dg_compilation`
		1010	`d_dg_compilation(void)`
2	7u83	1011	`{`
7	7u83	1012	`int code = get_big_code(2);`
		1013	`switch (code) {`
		1014	`case e_dg_tag_compilation: {`
		1015	`dg_tag p0;`
		1016	`dg_compilation p1;`
		1017	`p0 = d_dg_tag();`
		1018	`p1 = d_dg_compilation();`
		1019	`return(f_dg_tag_compilation(p0, p1));`
2	7u83	1020	`}`
7	7u83	1021	`case e_make_dg_compilation: {`
		1022	`dg_filename p0;`
		1023	`string_list p1;`
		1024	`dg_macro_list p2;`
		1025	`dg_filename p3;`
		1026	`nat p4;`
		1027	`nat p5;`
		1028	`nat p6;`
		1029	`string p7;`
		1030	`string_list p8;`
		1031	`dg_namelist p9;`
		1032	`p0 = d_dg_filename();`
		1033	`p1 = d_string_list();`
		1034	`p2 = d_dg_macro_list();`
		1035	`p3 = d_dg_filename();`
		1036	`p4 = d_nat();`
		1037	`p5 = d_nat();`
		1038	`p6 = d_nat();`
		1039	`p7 = d_string();`
		1040	`p8 = d_string_list();`
		1041	`p9 = d_dg_namelist();`
		1042	`return(f_make_dg_compilation(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));`
2	7u83	1043	`}`
		1044	`}`
7	7u83	1045	`decode_error(ILLEGAL_CODE_dg_compilation);`
		1046	`return(f_dummy_dg_compilation);`
2	7u83	1047	`}`
		1048
		1049
		1050	`/* DECODE DG_CONSTRAINT */`
		1051
7	7u83	1052	`dg_constraint`
		1053	`d_dg_constraint(void)`
2	7u83	1054	`{`
7	7u83	1055	`int code = get_big_code(2);`
		1056	`switch (code) {`
		1057	`case e_dg_type_constraint: {`
		1058	`dg_tag_option p0;`
		1059	`dg_type p1;`
		1060	`p0 = d_dg_tag_option();`
		1061	`p1 = d_dg_type();`
		1062	`return(f_dg_type_constraint(p0, p1));`
2	7u83	1063	`}`
7	7u83	1064	`case e_dg_value_constraint: {`
		1065	`dg_tag_option p0;`
		1066	`exp p1;`
		1067	`p0 = d_dg_tag_option();`
		1068	`p1 = hold_check(d_exp());`
		1069	`return(f_dg_value_constraint(p0, p1));`
2	7u83	1070	`}`
		1071	`}`
7	7u83	1072	`decode_error(ILLEGAL_CODE_dg_constraint);`
		1073	`return(f_dummy_dg_constraint);`
2	7u83	1074	`}`
		1075
		1076
		1077	`/* DECODE DG_CONSTRAINT_LIST */`
		1078
7	7u83	1079	`dg_constraint_list`
		1080	`d_dg_constraint_list(void)`
2	7u83	1081	`{`
7	7u83	1082	`int i, n;`
		1083	`dg_constraint_list temp;`
		1084	`IGNORE getcode(1);`
		1085	`n = small_dtdfint();`
		1086	`temp = new_dg_constraint_list(n);`
		1087	`for (i = 0; i < n; i++) {`
		1088	`dg_constraint e;`
		1089	`e = d_dg_constraint();`
		1090	`temp = add_dg_constraint_list(temp, e, i);`
2	7u83	1091	`}`
7	7u83	1092	`return(temp);`
2	7u83	1093	`}`
		1094
		1095
		1096	`/* DECODE DG_CONSTRAINT_LIST_OPTION */`
		1097
7	7u83	1098	`dg_constraint_list_option`
		1099	`d_dg_constraint_list_option(void)`
2	7u83	1100	`{`
7	7u83	1101	`if (getcode(1)) {`
		1102	`dg_constraint_list e;`
		1103	`e = d_dg_constraint_list();`
		1104	`return(yes_dg_constraint_list_option(e));`
2	7u83	1105	`}`
7	7u83	1106	`return(no_dg_constraint_list_option);`
2	7u83	1107	`}`
		1108
		1109
		1110	`/* DECODE DG_DEFAULT */`
		1111
7	7u83	1112	`dg_default`
		1113	`d_dg_default(void)`
2	7u83	1114	`{`
7	7u83	1115	`int code = get_big_code(1);`
		1116	`switch (code) {`
		1117	`case e_make_dg_default: {`
		1118	`exp_option p0;`
		1119	`dg_sourcepos_option p1;`
		1120	`p0 = d_exp_option();`
		1121	`p1 = d_dg_sourcepos_option();`
		1122	`return(f_make_dg_default(p0, p1));`
2	7u83	1123	`}`
		1124	`}`
7	7u83	1125	`decode_error(ILLEGAL_CODE_dg_default);`
		1126	`return(f_dummy_dg_default);`
2	7u83	1127	`}`
		1128
		1129
		1130	`/* DECODE DG_DEFAULT_OPTION */`
		1131
7	7u83	1132	`dg_default_option`
		1133	`d_dg_default_option(void)`
2	7u83	1134	`{`
7	7u83	1135	`if (getcode(1)) {`
		1136	`dg_default e;`
		1137	`e = d_dg_default();`
		1138	`return(yes_dg_default_option(e));`
2	7u83	1139	`}`
7	7u83	1140	`return(no_dg_default_option);`
2	7u83	1141	`}`
		1142
		1143
		1144	`/* DECODE DG_DIM */`
		1145
7	7u83	1146	`dg_dim`
		1147	`d_dg_dim(void)`
2	7u83	1148	`{`
7	7u83	1149	`int code = get_big_code(3);`
		1150	`switch (code) {`
		1151	`case e_dg_dim_apply_token: {`
		1152	`token p0;`
		1153	`bitstream p1;`
		1154	`p0 = d_token();`
		1155	`p1 = d_bitstream();`
		1156	`return(f_dg_dim_apply_token(p0, p1));`
2	7u83	1157	`}`
7	7u83	1158	`case e_dg_tag_dim: {`
		1159	`dg_tag p0;`
		1160	`dg_dim p1;`
		1161	`p0 = d_dg_tag();`
		1162	`p1 = d_dg_dim();`
		1163	`return(f_dg_tag_dim(p0, p1));`
2	7u83	1164	`}`
7	7u83	1165	`case e_dg_bounds_dim: {`
		1166	`dg_bound p0;`
		1167	`dg_bound p1;`
		1168	`dg_type p2;`
		1169	`p0 = d_dg_bound();`
		1170	`p1 = d_dg_bound();`
		1171	`p2 = d_dg_type();`
		1172	`return(f_dg_bounds_dim(p0, p1, p2));`
2	7u83	1173	`}`
7	7u83	1174	`case e_dg_count_dim: {`
		1175	`dg_bound p0;`
		1176	`dg_bound p1;`
		1177	`dg_type p2;`
		1178	`p0 = d_dg_bound();`
		1179	`p1 = d_dg_bound();`
		1180	`p2 = d_dg_type();`
		1181	`return(f_dg_count_dim(p0, p1, p2));`
2	7u83	1182	`}`
7	7u83	1183	`case e_dg_type_dim: {`
		1184	`dg_type p0;`
		1185	`nat_option p1;`
		1186	`p0 = d_dg_type();`
		1187	`p1 = d_nat_option();`
		1188	`return(f_dg_type_dim(p0, p1));`
2	7u83	1189	`}`
7	7u83	1190	`case e_dg_unspecified_dim: {`
		1191	`return(f_dg_unspecified_dim);`
2	7u83	1192	`}`
		1193	`}`
7	7u83	1194	`decode_error(ILLEGAL_CODE_dg_dim);`
		1195	`return(f_dummy_dg_dim);`
2	7u83	1196	`}`
		1197
		1198
		1199	`/* DECODE DG_DIM_LIST */`
		1200
7	7u83	1201	`dg_dim_list`
		1202	`d_dg_dim_list(void)`
2	7u83	1203	`{`
7	7u83	1204	`int i, n;`
		1205	`dg_dim_list temp;`
		1206	`IGNORE getcode(1);`
		1207	`n = small_dtdfint();`
		1208	`temp = new_dg_dim_list(n);`
		1209	`for (i = 0; i < n; i++) {`
		1210	`dg_dim e;`
		1211	`e = d_dg_dim();`
		1212	`temp = add_dg_dim_list(temp, e, i);`
2	7u83	1213	`}`
7	7u83	1214	`return(temp);`
2	7u83	1215	`}`
		1216
		1217
		1218	`/* DECODE DG_DIM_OPTION */`
		1219
7	7u83	1220	`dg_dim_option`
		1221	`d_dg_dim_option(void)`
2	7u83	1222	`{`
7	7u83	1223	`if (getcode(1)) {`
		1224	`dg_dim e;`
		1225	`e = d_dg_dim();`
		1226	`return(yes_dg_dim_option(e));`
2	7u83	1227	`}`
7	7u83	1228	`return(no_dg_dim_option);`
2	7u83	1229	`}`
		1230
		1231
		1232	`/* DECODE DG_DISCRIM */`
		1233
7	7u83	1234	`dg_discrim`
		1235	`d_dg_discrim(void)`
2	7u83	1236	`{`
7	7u83	1237	`int code = get_big_code(1);`
		1238	`switch (code) {`
		1239	`case e_make_dg_discrim: {`
		1240	`exp p0;`
		1241	`exp p1;`
		1242	`p0 = hold_check(d_exp());`
		1243	`p1 = hold_check(d_exp());`
		1244	`return(f_make_dg_discrim(p0, p1));`
2	7u83	1245	`}`
		1246	`}`
7	7u83	1247	`decode_error(ILLEGAL_CODE_dg_discrim);`
		1248	`return(f_dummy_dg_discrim);`
2	7u83	1249	`}`
		1250
		1251
		1252	`/* DECODE DG_DISCRIM_LIST */`
		1253
7	7u83	1254	`dg_discrim_list`
		1255	`d_dg_discrim_list(void)`
2	7u83	1256	`{`
7	7u83	1257	`int i, n;`
		1258	`dg_discrim_list temp;`
		1259	`IGNORE getcode(1);`
		1260	`n = small_dtdfint();`
		1261	`temp = new_dg_discrim_list(n);`
		1262	`for (i = 0; i < n; i++) {`
		1263	`dg_discrim e;`
		1264	`e = d_dg_discrim();`
		1265	`temp = add_dg_discrim_list(temp, e, i);`
2	7u83	1266	`}`
7	7u83	1267	`return(temp);`
2	7u83	1268	`}`
		1269
		1270
		1271	`/* DECODE DG_ENUM */`
		1272
7	7u83	1273	`dg_enum`
		1274	`d_dg_enum(void)`
2	7u83	1275	`{`
7	7u83	1276	`int code = get_big_code(2);`
		1277	`switch (code) {`
		1278	`case e_dg_tag_enum: {`
		1279	`dg_tag p0;`
		1280	`dg_enum p1;`
		1281	`p0 = d_dg_tag();`
		1282	`p1 = d_dg_enum();`
		1283	`return(f_dg_tag_enum(p0, p1));`
2	7u83	1284	`}`
7	7u83	1285	`case e_make_dg_enum: {`
		1286	`exp p0;`
		1287	`dg_idname p1;`
		1288	`dg_sourcepos p2;`
		1289	`p0 = hold_check(d_exp());`
		1290	`p1 = d_dg_idname();`
		1291	`p2 = d_dg_sourcepos();`
		1292	`return(f_make_dg_enum(p0, p1, p2));`
2	7u83	1293	`}`
7	7u83	1294	`case e_dg_char_enum: {`
		1295	`exp p0;`
		1296	`nat p1;`
		1297	`dg_sourcepos p2;`
		1298	`p0 = hold_check(d_exp());`
		1299	`p1 = d_nat();`
		1300	`p2 = d_dg_sourcepos();`
		1301	`return(f_dg_char_enum(p0, p1, p2));`
2	7u83	1302	`}`
		1303	`}`
7	7u83	1304	`decode_error(ILLEGAL_CODE_dg_enum);`
		1305	`return(f_dummy_dg_enum);`
2	7u83	1306	`}`
		1307
		1308
		1309	`/* DECODE DG_ENUM_LIST */`
		1310
7	7u83	1311	`dg_enum_list`
		1312	`d_dg_enum_list(void)`
2	7u83	1313	`{`
7	7u83	1314	`int i, n;`
		1315	`dg_enum_list temp;`
		1316	`IGNORE getcode(1);`
		1317	`n = small_dtdfint();`
		1318	`temp = new_dg_enum_list(n);`
		1319	`for (i = 0; i < n; i++) {`
		1320	`dg_enum e;`
		1321	`e = d_dg_enum();`
		1322	`temp = add_dg_enum_list(temp, e, i);`
2	7u83	1323	`}`
7	7u83	1324	`return(temp);`
2	7u83	1325	`}`
		1326
		1327
		1328	`/* DECODE DG_FILENAME */`
		1329
7	7u83	1330	`dg_filename`
		1331	`d_dg_filename(void)`
2	7u83	1332	`{`
7	7u83	1333	`int code = get_big_code(2);`
		1334	`switch (code) {`
		1335	`case e_dg_filename_apply_token: {`
		1336	`token p0;`
		1337	`bitstream p1;`
		1338	`p0 = d_token();`
		1339	`p1 = d_bitstream();`
		1340	`return(f_dg_filename_apply_token(p0, p1));`
2	7u83	1341	`}`
7	7u83	1342	`case e_make_dg_filename: {`
		1343	`nat p0;`
		1344	`string p1;`
		1345	`string p2;`
		1346	`string p3;`
		1347	`p0 = d_nat();`
		1348	`p1 = d_string();`
		1349	`p2 = d_string();`
		1350	`p3 = d_string();`
		1351	`return(f_make_dg_filename(p0, p1, p2, p3));`
2	7u83	1352	`}`
		1353	`}`
7	7u83	1354	`decode_error(ILLEGAL_CODE_dg_filename);`
		1355	`return(f_dummy_dg_filename);`
2	7u83	1356	`}`
		1357
		1358
		1359	`/* DECODE DG_FILENAME_OPTION */`
		1360
7	7u83	1361	`dg_filename_option`
		1362	`d_dg_filename_option(void)`
2	7u83	1363	`{`
7	7u83	1364	`if (getcode(1)) {`
		1365	`dg_filename e;`
		1366	`e = d_dg_filename();`
		1367	`return(yes_dg_filename_option(e));`
2	7u83	1368	`}`
7	7u83	1369	`return(no_dg_filename_option);`
2	7u83	1370	`}`
		1371
		1372
		1373	`/* DECODE DG_IDNAME */`
		1374
7	7u83	1375	`dg_idname`
		1376	`d_dg_idname(void)`
2	7u83	1377	`{`
7	7u83	1378	`int code = get_big_code(3);`
		1379	`switch (code) {`
		1380	`case e_dg_idname_apply_token: {`
		1381	`token p0;`
		1382	`bitstream p1;`
		1383	`p0 = d_token();`
		1384	`p1 = d_bitstream();`
		1385	`return(f_dg_idname_apply_token(p0, p1));`
2	7u83	1386	`}`
7	7u83	1387	`case e_dg_anonymous_idname: {`
		1388	`string_option p0;`
		1389	`p0 = d_string_option();`
		1390	`return(f_dg_anonymous_idname(p0));`
2	7u83	1391	`}`
7	7u83	1392	`case e_dg_artificial_idname: {`
		1393	`string_option p0;`
		1394	`p0 = d_string_option();`
		1395	`return(f_dg_artificial_idname(p0));`
2	7u83	1396	`}`
7	7u83	1397	`case e_dg_external_idname: {`
		1398	`string p0;`
		1399	`p0 = d_string();`
		1400	`return(f_dg_external_idname(p0));`
2	7u83	1401	`}`
7	7u83	1402	`case e_dg_instance_idname: {`
		1403	`dg_idname_option p0;`
		1404	`dg_idname p1;`
		1405	`dg_sourcepos p2;`
		1406	`dg_name_list p3;`
		1407	`p0 = d_dg_idname_option();`
		1408	`p1 = d_dg_idname();`
		1409	`p2 = d_dg_sourcepos();`
		1410	`p3 = d_dg_name_list();`
		1411	`return(f_dg_instance_idname(p0, p1, p2, p3));`
2	7u83	1412	`}`
7	7u83	1413	`case e_dg_sourcestring_idname: {`
		1414	`string p0;`
		1415	`p0 = d_string();`
		1416	`return(f_dg_sourcestring_idname(p0));`
2	7u83	1417	`}`
		1418	`}`
7	7u83	1419	`decode_error(ILLEGAL_CODE_dg_idname);`
		1420	`return(f_dummy_dg_idname);`
2	7u83	1421	`}`
		1422
		1423
		1424	`/* DECODE DG_IDNAME_LIST */`
		1425
7	7u83	1426	`dg_idname_list`
		1427	`d_dg_idname_list(void)`
2	7u83	1428	`{`
7	7u83	1429	`int i, n;`
		1430	`dg_idname_list temp;`
		1431	`IGNORE getcode(1);`
		1432	`n = small_dtdfint();`
		1433	`temp = new_dg_idname_list(n);`
		1434	`for (i = 0; i < n; i++) {`
		1435	`dg_idname e;`
		1436	`e = d_dg_idname();`
		1437	`temp = add_dg_idname_list(temp, e, i);`
2	7u83	1438	`}`
7	7u83	1439	`return(temp);`
2	7u83	1440	`}`
		1441
		1442
		1443	`/* DECODE DG_IDNAME_OPTION */`
		1444
7	7u83	1445	`dg_idname_option`
		1446	`d_dg_idname_option(void)`
2	7u83	1447	`{`
7	7u83	1448	`if (getcode(1)) {`
		1449	`dg_idname e;`
		1450	`e = d_dg_idname();`
		1451	`return(yes_dg_idname_option(e));`
2	7u83	1452	`}`
7	7u83	1453	`return(no_dg_idname_option);`
2	7u83	1454	`}`
		1455
		1456
		1457	`/* DECODE DG_LIST */`
		1458
7	7u83	1459	`dg_list`
		1460	`d_dg_list(void)`
2	7u83	1461	`{`
7	7u83	1462	`int i, n;`
		1463	`dg_list temp;`
		1464	`IGNORE getcode(1);`
		1465	`n = small_dtdfint();`
		1466	`temp = new_dg_list(n);`
		1467	`for (i = 0; i < n; i++) {`
		1468	`dg e;`
		1469	`e = d_dg();`
		1470	`temp = add_dg_list(temp, e, i);`
2	7u83	1471	`}`
7	7u83	1472	`return(temp);`
2	7u83	1473	`}`
		1474
		1475
		1476	`/* DECODE DG_MACRO */`
		1477
7	7u83	1478	`dg_macro`
		1479	`d_dg_macro(void)`
2	7u83	1480	`{`
7	7u83	1481	`int code = get_big_code(2);`
		1482	`switch (code) {`
		1483	`case e_dg_function_macro: {`
		1484	`dg_sourcepos p0;`
		1485	`dg_idname p1;`
		1486	`dg_idname_list p2;`
		1487	`string p3;`
		1488	`p0 = d_dg_sourcepos();`
		1489	`p1 = d_dg_idname();`
		1490	`p2 = d_dg_idname_list();`
		1491	`p3 = d_string();`
		1492	`return(f_dg_function_macro(p0, p1, p2, p3));`
2	7u83	1493	`}`
7	7u83	1494	`case e_dg_include_macro: {`
		1495	`dg_sourcepos p0;`
		1496	`dg_filename p1;`
		1497	`dg_macro_list p2;`
		1498	`p0 = d_dg_sourcepos();`
		1499	`p1 = d_dg_filename();`
		1500	`p2 = d_dg_macro_list();`
		1501	`return(f_dg_include_macro(p0, p1, p2));`
2	7u83	1502	`}`
7	7u83	1503	`case e_dg_object_macro: {`
		1504	`dg_sourcepos p0;`
		1505	`dg_idname p1;`
		1506	`string p2;`
		1507	`p0 = d_dg_sourcepos();`
		1508	`p1 = d_dg_idname();`
		1509	`p2 = d_string();`
		1510	`return(f_dg_object_macro(p0, p1, p2));`
2	7u83	1511	`}`
7	7u83	1512	`case e_dg_undef_macro: {`
		1513	`dg_sourcepos p0;`
		1514	`dg_idname p1;`
		1515	`p0 = d_dg_sourcepos();`
		1516	`p1 = d_dg_idname();`
		1517	`return(f_dg_undef_macro(p0, p1));`
2	7u83	1518	`}`
		1519	`}`
7	7u83	1520	`decode_error(ILLEGAL_CODE_dg_macro);`
		1521	`return(f_dummy_dg_macro);`
2	7u83	1522	`}`
		1523
		1524
		1525	`/* DECODE DG_MACRO_LIST */`
		1526
7	7u83	1527	`dg_macro_list`
		1528	`d_dg_macro_list(void)`
2	7u83	1529	`{`
7	7u83	1530	`int i, n;`
		1531	`dg_macro_list temp;`
		1532	`IGNORE getcode(1);`
		1533	`n = small_dtdfint();`
		1534	`temp = new_dg_macro_list(n);`
		1535	`for (i = 0; i < n; i++) {`
		1536	`dg_macro e;`
		1537	`e = d_dg_macro();`
		1538	`temp = add_dg_macro_list(temp, e, i);`
2	7u83	1539	`}`
7	7u83	1540	`return(temp);`
2	7u83	1541	`}`
		1542
		1543
		1544	`/* DECODE DG_NAME */`
		1545
7	7u83	1546	`dg_name`
		1547	`d_dg_name(void)`
2	7u83	1548	`{`
7	7u83	1549	`int code = get_big_code(5);`
		1550	`switch (code) {`
		1551	`case e_dg_name_apply_token: {`
		1552	`token p0;`
		1553	`bitstream p1;`
		1554	`p0 = d_token();`
		1555	`p1 = d_bitstream();`
		1556	`return(f_dg_name_apply_token(p0, p1));`
2	7u83	1557	`}`
7	7u83	1558	`case e_dg_tag_name: {`
		1559	`dg_tag p0;`
		1560	`dg_name p1;`
		1561	`p0 = d_dg_tag();`
		1562	`p1 = d_dg_name();`
		1563	`return(f_dg_tag_name(p0, p1));`
2	7u83	1564	`}`
7	7u83	1565	`case e_dg_constant_name: {`
		1566	`dg_name p0;`
		1567	`p0 = d_dg_name();`
		1568	`return(f_dg_constant_name(p0));`
2	7u83	1569	`}`
7	7u83	1570	`case e_dg_entry_family_name: {`
		1571	`dg_name p0;`
		1572	`dg_dim p1;`
		1573	`p0 = d_dg_name();`
		1574	`p1 = d_dg_dim();`
		1575	`return(f_dg_entry_family_name(p0, p1));`
2	7u83	1576	`}`
7	7u83	1577	`case e_dg_entry_name: {`
		1578	`dg_idname p0;`
		1579	`dg_sourcepos p1;`
		1580	`dg_type p2;`
		1581	`dg_accessibility_option p3;`
		1582	`dg_dim_option p4;`
		1583	`p0 = d_dg_idname();`
		1584	`p1 = d_dg_sourcepos();`
		1585	`p2 = d_dg_type();`
		1586	`p3 = d_dg_accessibility_option();`
		1587	`p4 = d_dg_dim_option();`
		1588	`return(f_dg_entry_name(p0, p1, p2, p3, p4));`
2	7u83	1589	`}`
7	7u83	1590	`case e_dg_inlined_name: {`
		1591	`dg_name p0;`
		1592	`dg_tag p1;`
		1593	`p0 = d_dg_name();`
		1594	`p1 = d_dg_tag();`
		1595	`return(f_dg_inlined_name(p0, p1));`
2	7u83	1596	`}`
7	7u83	1597	`case e_dg_is_spec_name: {`
		1598	`dg_name p0;`
		1599	`bool_option p1;`
		1600	`p0 = d_dg_name();`
		1601	`p1 = d_bool_option();`
		1602	`return(f_dg_is_spec_name(p0, p1));`
2	7u83	1603	`}`
7	7u83	1604	`case e_dg_module_name: {`
		1605	`dg_idname p0;`
		1606	`dg_sourcepos p1;`
		1607	`dg_namelist p2;`
		1608	`exp_option p3;`
		1609	`dg_tag_option p4;`
		1610	`p0 = d_dg_idname();`
		1611	`p1 = d_dg_sourcepos();`
		1612	`p2 = d_dg_namelist();`
		1613	`p3 = d_exp_option();`
		1614	`p4 = d_dg_tag_option();`
		1615	`return(f_dg_module_name(p0, p1, p2, p3, p4));`
2	7u83	1616	`}`
7	7u83	1617	`case e_dg_namespace_name: {`
		1618	`dg_idname p0;`
		1619	`dg_sourcepos p1;`
		1620	`dg_namelist p2;`
		1621	`p0 = d_dg_idname();`
		1622	`p1 = d_dg_sourcepos();`
		1623	`p2 = d_dg_namelist();`
		1624	`return(f_dg_namespace_name(p0, p1, p2));`
2	7u83	1625	`}`
7	7u83	1626	`case e_dg_object_name: {`
		1627	`dg_idname p0;`
		1628	`dg_sourcepos p1;`
		1629	`dg_type p2;`
		1630	`exp_option p3;`
		1631	`dg_accessibility_option p4;`
		1632	`p0 = d_dg_idname();`
		1633	`p1 = d_dg_sourcepos();`
		1634	`p2 = d_dg_type();`
		1635	`p3 = d_exp_option();`
		1636	`p4 = d_dg_accessibility_option();`
		1637	`return(f_dg_object_name(p0, p1, p2, p3, p4));`
2	7u83	1638	`}`
7	7u83	1639	`case e_dg_proc_name: {`
		1640	`dg_idname p0;`
		1641	`dg_sourcepos p1;`
		1642	`dg_type p2;`
		1643	`exp_option p3;`
		1644	`dg_accessibility_option p4;`
		1645	`dg_virtuality_option p5;`
		1646	`bool p6;`
		1647	`dg_type_list_option p7;`
		1648	`dg_tag_option p8;`
		1649	`p0 = d_dg_idname();`
		1650	`p1 = d_dg_sourcepos();`
		1651	`p2 = d_dg_type();`
		1652	`p3 = d_exp_option();`
		1653	`p4 = d_dg_accessibility_option();`
		1654	`p5 = d_dg_virtuality_option();`
		1655	`p6 = d_bool();`
		1656	`p7 = d_dg_type_list_option();`
		1657	`p8 = d_dg_tag_option();`
		1658	`return(f_dg_proc_name(p0, p1, p2, p3, p4, p5, p6, p7, p8));`
2	7u83	1659	`}`
7	7u83	1660	`case e_dg_program_name: {`
		1661	`dg_idname p0;`
		1662	`dg_sourcepos p1;`
		1663	`exp p2;`
		1664	`p0 = d_dg_idname();`
		1665	`p1 = d_dg_sourcepos();`
		1666	`p2 = hold_check(d_exp());`
		1667	`return(f_dg_program_name(p0, p1, p2));`
2	7u83	1668	`}`
7	7u83	1669	`case e_dg_rep_clause_name: {`
		1670	`dg_name p0;`
		1671	`exp p1;`
		1672	`p0 = d_dg_name();`
		1673	`p1 = hold_check(d_exp());`
		1674	`return(f_dg_rep_clause_name(p0, p1));`
2	7u83	1675	`}`
7	7u83	1676	`case e_dg_spec_ref_name: {`
		1677	`dg_tag p0;`
		1678	`dg_name p1;`
		1679	`p0 = d_dg_tag();`
		1680	`p1 = d_dg_name();`
		1681	`return(f_dg_spec_ref_name(p0, p1));`
2	7u83	1682	`}`
7	7u83	1683	`case e_dg_subunit_name: {`
		1684	`dg_tag p0;`
		1685	`dg_name p1;`
		1686	`nat p2;`
		1687	`dg_accessibility_option p3;`
		1688	`p0 = d_dg_tag();`
		1689	`p1 = d_dg_name();`
		1690	`p2 = d_nat();`
		1691	`p3 = d_dg_accessibility_option();`
		1692	`return(f_dg_subunit_name(p0, p1, p2, p3));`
2	7u83	1693	`}`
7	7u83	1694	`case e_dg_type_name: {`
		1695	`dg_idname_option p0;`
		1696	`dg_sourcepos p1;`
		1697	`dg_accessibility_option p2;`
		1698	`dg_type_option p3;`
		1699	`bool p4;`
		1700	`bool_option p5;`
		1701	`dg_constraint_list_option p6;`
		1702	`p0 = d_dg_idname_option();`
		1703	`p1 = d_dg_sourcepos();`
		1704	`p2 = d_dg_accessibility_option();`
		1705	`p3 = d_dg_type_option();`
		1706	`p4 = d_bool();`
		1707	`p5 = d_bool_option();`
		1708	`p6 = d_dg_constraint_list_option();`
		1709	`return(f_dg_type_name(p0, p1, p2, p3, p4, p5, p6));`
2	7u83	1710	`}`
7	7u83	1711	`case e_dg_visibility_name: {`
		1712	`dg_tag p0;`
		1713	`nat p1;`
		1714	`dg_idname_option p2;`
		1715	`dg_sourcepos_option p3;`
		1716	`dg_accessibility_option p4;`
		1717	`dg_type_option p5;`
		1718	`p0 = d_dg_tag();`
		1719	`p1 = d_nat();`
		1720	`p2 = d_dg_idname_option();`
		1721	`p3 = d_dg_sourcepos_option();`
		1722	`p4 = d_dg_accessibility_option();`
		1723	`p5 = d_dg_type_option();`
		1724	`return(f_dg_visibility_name(p0, p1, p2, p3, p4, p5));`
2	7u83	1725	`}`
		1726	`}`
7	7u83	1727	`decode_error(ILLEGAL_CODE_dg_name);`
		1728	`return(f_dummy_dg_name);`
2	7u83	1729	`}`
		1730
		1731
		1732	`/* DECODE DG_NAME_LIST */`
		1733
7	7u83	1734	`dg_name_list`
		1735	`d_dg_name_list(void)`
2	7u83	1736	`{`
7	7u83	1737	`int i, n;`
		1738	`dg_name_list temp;`
		1739	`IGNORE getcode(1);`
		1740	`n = small_dtdfint();`
		1741	`temp = new_dg_name_list(n);`
		1742	`for (i = 0; i < n; i++) {`
		1743	`dg_name e;`
		1744	`e = d_dg_name();`
		1745	`temp = add_dg_name_list(temp, e, i);`
2	7u83	1746	`}`
7	7u83	1747	`return(temp);`
2	7u83	1748	`}`
		1749
		1750
		1751	`/* DECODE DG_NAME_OPTION */`
		1752
7	7u83	1753	`dg_name_option`
		1754	`d_dg_name_option(void)`
2	7u83	1755	`{`
7	7u83	1756	`if (getcode(1)) {`
		1757	`dg_name e;`
		1758	`e = d_dg_name();`
		1759	`return(yes_dg_name_option(e));`
2	7u83	1760	`}`
7	7u83	1761	`return(no_dg_name_option);`
2	7u83	1762	`}`
		1763
		1764
		1765	`/* DECODE DG_NAMELIST */`
		1766
7	7u83	1767	`dg_namelist`
		1768	`d_dg_namelist(void)`
2	7u83	1769	`{`
7	7u83	1770	`int code = get_big_code(2);`
		1771	`switch (code) {`
		1772	`case e_dg_tag_namelist: {`
		1773	`dg_tag p0;`
		1774	`dg_namelist p1;`
		1775	`p0 = d_dg_tag();`
		1776	`p1 = d_dg_namelist();`
		1777	`return(f_dg_tag_namelist(p0, p1));`
2	7u83	1778	`}`
7	7u83	1779	`case e_make_dg_namelist: {`
		1780	`dg_name_list p0;`
		1781	`p0 = d_dg_name_list();`
		1782	`return(f_make_dg_namelist(p0));`
2	7u83	1783	`}`
		1784	`}`
7	7u83	1785	`decode_error(ILLEGAL_CODE_dg_namelist);`
		1786	`return(f_dummy_dg_namelist);`
2	7u83	1787	`}`
		1788
		1789
		1790	`/* DECODE DG_PARAM */`
		1791
7	7u83	1792	`dg_param`
		1793	`d_dg_param(void)`
2	7u83	1794	`{`
7	7u83	1795	`int code = get_big_code(2);`
		1796	`switch (code) {`
		1797	`case e_dg_object_param: {`
		1798	`dg_idname_option p0;`
		1799	`dg_sourcepos_option p1;`
		1800	`dg_param_mode_option p2;`
		1801	`dg_type p3;`
		1802	`dg_default_option p4;`
		1803	`p0 = d_dg_idname_option();`
		1804	`p1 = d_dg_sourcepos_option();`
		1805	`p2 = d_dg_param_mode_option();`
		1806	`p3 = d_dg_type();`
		1807	`p4 = d_dg_default_option();`
		1808	`return(f_dg_object_param(p0, p1, p2, p3, p4));`
2	7u83	1809	`}`
7	7u83	1810	`case e_dg_type_param: {`
		1811	`dg_idname_option p0;`
		1812	`dg_sourcepos_option p1;`
		1813	`dg_param_list p2;`
		1814	`p0 = d_dg_idname_option();`
		1815	`p1 = d_dg_sourcepos_option();`
		1816	`p2 = d_dg_param_list();`
		1817	`return(f_dg_type_param(p0, p1, p2));`
2	7u83	1818	`}`
		1819	`}`
7	7u83	1820	`decode_error(ILLEGAL_CODE_dg_param);`
		1821	`return(f_dummy_dg_param);`
2	7u83	1822	`}`
		1823
		1824
		1825	`/* DECODE DG_PARAM_LIST */`
		1826
7	7u83	1827	`dg_param_list`
		1828	`d_dg_param_list(void)`
2	7u83	1829	`{`
7	7u83	1830	`int i, n;`
		1831	`dg_param_list temp;`
		1832	`IGNORE getcode(1);`
		1833	`n = small_dtdfint();`
		1834	`temp = new_dg_param_list(n);`
		1835	`for (i = 0; i < n; i++) {`
		1836	`dg_param e;`
		1837	`e = d_dg_param();`
		1838	`temp = add_dg_param_list(temp, e, i);`
2	7u83	1839	`}`
7	7u83	1840	`return(temp);`
2	7u83	1841	`}`
		1842
		1843
		1844	`/* DECODE DG_PARAM_MODE */`
		1845
7	7u83	1846	`dg_param_mode`
		1847	`d_dg_param_mode(void)`
2	7u83	1848	`{`
7	7u83	1849	`int code = get_big_code(2);`
		1850	`switch (code) {`
		1851	`case e_dg_in_mode: {`
		1852	`return(f_dg_in_mode);`
2	7u83	1853	`}`
7	7u83	1854	`case e_dg_inout_mode: {`
		1855	`return(f_dg_inout_mode);`
2	7u83	1856	`}`
7	7u83	1857	`case e_dg_out_mode: {`
		1858	`return(f_dg_out_mode);`
2	7u83	1859	`}`
		1860	`}`
7	7u83	1861	`decode_error(ILLEGAL_CODE_dg_param_mode);`
		1862	`return(f_dummy_dg_param_mode);`
2	7u83	1863	`}`
		1864
		1865
		1866	`/* DECODE DG_PARAM_MODE_OPTION */`
		1867
7	7u83	1868	`dg_param_mode_option`
		1869	`d_dg_param_mode_option(void)`
2	7u83	1870	`{`
7	7u83	1871	`if (getcode(1)) {`
		1872	`dg_param_mode e;`
		1873	`e = d_dg_param_mode();`
		1874	`return(yes_dg_param_mode_option(e));`
2	7u83	1875	`}`
7	7u83	1876	`return(no_dg_param_mode_option);`
2	7u83	1877	`}`
		1878
		1879
		1880	`/* DECODE DG_QUALIFIER */`
		1881
7	7u83	1882	`dg_qualifier`
		1883	`d_dg_qualifier(void)`
2	7u83	1884	`{`
7	7u83	1885	`int code = get_big_code(3);`
		1886	`switch (code) {`
		1887	`case e_dg_aliased_qualifier: {`
		1888	`return(f_dg_aliased_qualifier);`
2	7u83	1889	`}`
7	7u83	1890	`case e_dg_class_wide_qualifier: {`
		1891	`return(f_dg_class_wide_qualifier);`
2	7u83	1892	`}`
7	7u83	1893	`case e_dg_const_qualifier: {`
		1894	`return(f_dg_const_qualifier);`
2	7u83	1895	`}`
7	7u83	1896	`case e_dg_limited_qualifier: {`
		1897	`return(f_dg_limited_qualifier);`
2	7u83	1898	`}`
7	7u83	1899	`case e_dg_volatile_qualifier: {`
		1900	`return(f_dg_volatile_qualifier);`
2	7u83	1901	`}`
		1902	`}`
7	7u83	1903	`decode_error(ILLEGAL_CODE_dg_qualifier);`
		1904	`return(f_dummy_dg_qualifier);`
2	7u83	1905	`}`
		1906
		1907
		1908	`/* DECODE DG_SOURCEPOS */`
		1909
7	7u83	1910	`dg_sourcepos`
		1911	`d_dg_sourcepos(void)`
2	7u83	1912	`{`
7	7u83	1913	`int code = get_big_code(3);`
		1914	`switch (code) {`
		1915	`case e_dg_file_sourcepos: {`
		1916	`dg_filename p0;`
		1917	`p0 = d_dg_filename();`
		1918	`return(f_dg_file_sourcepos(p0));`
2	7u83	1919	`}`
7	7u83	1920	`case e_dg_global_sourcepos: {`
		1921	`return(f_dg_global_sourcepos);`
2	7u83	1922	`}`
7	7u83	1923	`case e_dg_mark_sourcepos: {`
		1924	`dg_filename p0;`
		1925	`nat p1;`
		1926	`nat p2;`
		1927	`p0 = d_dg_filename();`
		1928	`p1 = d_nat();`
		1929	`p2 = d_nat();`
		1930	`return(f_dg_mark_sourcepos(p0, p1, p2));`
2	7u83	1931	`}`
7	7u83	1932	`case e_dg_null_sourcepos: {`
		1933	`return(f_dg_null_sourcepos);`
2	7u83	1934	`}`
7	7u83	1935	`case e_dg_span_sourcepos: {`
		1936	`dg_filename p0;`
		1937	`nat p1;`
		1938	`nat p2;`
		1939	`dg_filename_option p3;`
		1940	`nat p4;`
		1941	`nat p5;`
		1942	`p0 = d_dg_filename();`
		1943	`p1 = d_nat();`
		1944	`p2 = d_nat();`
		1945	`p3 = d_dg_filename_option();`
		1946	`p4 = d_nat();`
		1947	`p5 = d_nat();`
		1948	`return(f_dg_span_sourcepos(p0, p1, p2, p3, p4, p5));`
2	7u83	1949	`}`
		1950	`}`
7	7u83	1951	`decode_error(ILLEGAL_CODE_dg_sourcepos);`
		1952	`return(f_dummy_dg_sourcepos);`
2	7u83	1953	`}`
		1954
		1955
		1956	`/* DECODE DG_SOURCEPOS_OPTION */`
		1957
7	7u83	1958	`dg_sourcepos_option`
		1959	`d_dg_sourcepos_option(void)`
2	7u83	1960	`{`
7	7u83	1961	`if (getcode(1)) {`
		1962	`dg_sourcepos e;`
		1963	`e = d_dg_sourcepos();`
		1964	`return(yes_dg_sourcepos_option(e));`
2	7u83	1965	`}`
7	7u83	1966	`return(no_dg_sourcepos_option);`
2	7u83	1967	`}`
		1968
		1969
		1970	`/* DECODE DG_TAG */`
		1971
7	7u83	1972	`dg_tag`
		1973	`d_dg_tag(void)`
2	7u83	1974	`{`
7	7u83	1975	`int code = get_big_code(1);`
		1976	`switch (code) {`
		1977	`case e_make_dg_tag: {`
		1978	`tdfint p0;`
		1979	`p0 = d_tdfint();`
		1980	`return(f_make_dg_tag(p0));`
2	7u83	1981	`}`
		1982	`}`
7	7u83	1983	`decode_error(ILLEGAL_CODE_dg_tag);`
		1984	`return(f_dummy_dg_tag);`
2	7u83	1985	`}`
		1986
		1987
		1988	`/* DECODE DG_TAG_LIST */`
		1989
7	7u83	1990	`dg_tag_list`
		1991	`d_dg_tag_list(void)`
2	7u83	1992	`{`
7	7u83	1993	`int i, n;`
		1994	`dg_tag_list temp;`
		1995	`IGNORE getcode(1);`
		1996	`n = small_dtdfint();`
		1997	`temp = new_dg_tag_list(n);`
		1998	`for (i = 0; i < n; i++) {`
		1999	`dg_tag e;`
		2000	`e = d_dg_tag();`
		2001	`temp = add_dg_tag_list(temp, e, i);`
2	7u83	2002	`}`
7	7u83	2003	`return(temp);`
2	7u83	2004	`}`
		2005
		2006
		2007	`/* DECODE DG_TAG_OPTION */`
		2008
7	7u83	2009	`dg_tag_option`
		2010	`d_dg_tag_option(void)`
2	7u83	2011	`{`
7	7u83	2012	`if (getcode(1)) {`
		2013	`dg_tag e;`
		2014	`e = d_dg_tag();`
		2015	`return(yes_dg_tag_option(e));`
2	7u83	2016	`}`
7	7u83	2017	`return(no_dg_tag_option);`
2	7u83	2018	`}`
		2019
		2020
		2021	`/* DECODE DG_TYPE */`
		2022
7	7u83	2023	`dg_type`
		2024	`d_dg_type(void)`
2	7u83	2025	`{`
7	7u83	2026	`int code = get_big_code(6);`
		2027	`switch (code) {`
		2028	`case e_dg_type_apply_token: {`
		2029	`token p0;`
		2030	`bitstream p1;`
		2031	`p0 = d_token();`
		2032	`p1 = d_bitstream();`
		2033	`return(f_dg_type_apply_token(p0, p1));`
2	7u83	2034	`}`
7	7u83	2035	`case e_dg_tag_type: {`
		2036	`dg_tag p0;`
		2037	`dg_type p1;`
		2038	`p0 = d_dg_tag();`
		2039	`p1 = d_dg_type();`
		2040	`return(f_dg_tag_type(p0, p1));`
2	7u83	2041	`}`
7	7u83	2042	`case e_dg_address_type: {`
		2043	`dg_idname p0;`
		2044	`shape p1;`
		2045	`p0 = d_dg_idname();`
		2046	`p1 = d_shape();`
		2047	`return(f_dg_address_type(p0, p1));`
2	7u83	2048	`}`
7	7u83	2049	`case e_dg_array_type: {`
		2050	`dg_type p0;`
		2051	`exp p1;`
		2052	`bool_option p2;`
		2053	`dg_dim_list p3;`
		2054	`p0 = d_dg_type();`
		2055	`p1 = hold_check(d_exp());`
		2056	`p2 = d_bool_option();`
		2057	`p3 = d_dg_dim_list();`
		2058	`return(f_dg_array_type(p0, p1, p2, p3));`
2	7u83	2059	`}`
7	7u83	2060	`case e_dg_bitfield_type: {`
		2061	`dg_type p0;`
		2062	`bitfield_variety p1;`
		2063	`shape p2;`
		2064	`p0 = d_dg_type();`
		2065	`p1 = d_bitfield_variety();`
		2066	`p2 = d_shape();`
		2067	`return(f_dg_bitfield_type(p0, p1, p2));`
2	7u83	2068	`}`
7	7u83	2069	`case e_dg_boolean_type: {`
		2070	`dg_idname p0;`
		2071	`variety p1;`
		2072	`p0 = d_dg_idname();`
		2073	`p1 = d_variety();`
		2074	`return(f_dg_boolean_type(p0, p1));`
2	7u83	2075	`}`
7	7u83	2076	`case e_dg_char_type: {`
		2077	`dg_idname p0;`
		2078	`variety p1;`
		2079	`p0 = d_dg_idname();`
		2080	`p1 = d_variety();`
		2081	`return(f_dg_char_type(p0, p1));`
2	7u83	2082	`}`
7	7u83	2083	`case e_dg_class_type: {`
		2084	`dg_class_base_list p0;`
		2085	`dg_classmem_list p1;`
		2086	`dg_varpart_option p2;`
		2087	`dg_tag_list p3;`
		2088	`shape_option p4;`
		2089	`dg_tag_option p5;`
		2090	`dg_tag_option p6;`
		2091	`dg_idname_option p7;`
		2092	`dg_sourcepos_option p8;`
		2093	`bool p9;`
		2094	`dg_tag_option p10;`
		2095	`dg_tag_option p11;`
		2096	`bool p12;`
		2097	`bool_option p13;`
		2098	`p0 = d_dg_class_base_list();`
		2099	`p1 = d_dg_classmem_list();`
		2100	`p2 = d_dg_varpart_option();`
		2101	`p3 = d_dg_tag_list();`
		2102	`p4 = d_shape_option();`
		2103	`p5 = d_dg_tag_option();`
		2104	`p6 = d_dg_tag_option();`
		2105	`p7 = d_dg_idname_option();`
		2106	`p8 = d_dg_sourcepos_option();`
		2107	`p9 = d_bool();`
		2108	`p10 = d_dg_tag_option();`
		2109	`p11 = d_dg_tag_option();`
		2110	`p12 = d_bool();`
		2111	`p13 = d_bool_option();`
		2112	`return(f_dg_class_type(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13));`
2	7u83	2113	`}`
7	7u83	2114	`case e_dg_complex_float_type: {`
		2115	`dg_idname p0;`
		2116	`floating_variety p1;`
		2117	`p0 = d_dg_idname();`
		2118	`p1 = d_floating_variety();`
		2119	`return(f_dg_complex_float_type(p0, p1));`
2	7u83	2120	`}`
7	7u83	2121	`case e_dg_enum_type: {`
		2122	`dg_enum_list p0;`
		2123	`dg_idname_option p1;`
		2124	`dg_sourcepos_option p2;`
		2125	`shape p3;`
		2126	`bool p4;`
		2127	`p0 = d_dg_enum_list();`
		2128	`p1 = d_dg_idname_option();`
		2129	`p2 = d_dg_sourcepos_option();`
		2130	`p3 = d_shape();`
		2131	`p4 = d_bool();`
		2132	`return(f_dg_enum_type(p0, p1, p2, p3, p4));`
2	7u83	2133	`}`
7	7u83	2134	`case e_dg_file_type: {`
		2135	`dg_type p0;`
		2136	`shape p1;`
		2137	`p0 = d_dg_type();`
		2138	`p1 = d_shape();`
		2139	`return(f_dg_file_type(p0, p1));`
2	7u83	2140	`}`
7	7u83	2141	`case e_dg_fixed_point_type: {`
		2142	`dg_type p0;`
		2143	`exp p1;`
		2144	`exp_option p2;`
		2145	`exp_option p3;`
		2146	`p0 = d_dg_type();`
		2147	`p1 = hold_check(d_exp());`
		2148	`p2 = d_exp_option();`
		2149	`p3 = d_exp_option();`
		2150	`return(f_dg_fixed_point_type(p0, p1, p2, p3));`
2	7u83	2151	`}`
7	7u83	2152	`case e_dg_float_type: {`
		2153	`dg_idname p0;`
		2154	`floating_variety p1;`
		2155	`p0 = d_dg_idname();`
		2156	`p1 = d_floating_variety();`
		2157	`return(f_dg_float_type(p0, p1));`
2	7u83	2158	`}`
7	7u83	2159	`case e_dg_floating_digits_type: {`
		2160	`dg_type p0;`
		2161	`exp p1;`
		2162	`p0 = d_dg_type();`
		2163	`p1 = hold_check(d_exp());`
		2164	`return(f_dg_floating_digits_type(p0, p1));`
2	7u83	2165	`}`
7	7u83	2166	`case e_dg_inlined_type: {`
		2167	`dg_type p0;`
		2168	`dg_tag p1;`
		2169	`p0 = d_dg_type();`
		2170	`p1 = d_dg_tag();`
		2171	`return(f_dg_inlined_type(p0, p1));`
2	7u83	2172	`}`
7	7u83	2173	`case e_dg_integer_type: {`
		2174	`dg_idname p0;`
		2175	`variety p1;`
		2176	`p0 = d_dg_idname();`
		2177	`p1 = d_variety();`
		2178	`return(f_dg_integer_type(p0, p1));`
2	7u83	2179	`}`
7	7u83	2180	`case e_dg_is_spec_type: {`
		2181	`dg_type p0;`
		2182	`p0 = d_dg_type();`
		2183	`return(f_dg_is_spec_type(p0));`
2	7u83	2184	`}`
7	7u83	2185	`case e_dg_modular_type: {`
		2186	`dg_type p0;`
		2187	`exp p1;`
		2188	`p0 = d_dg_type();`
		2189	`p1 = hold_check(d_exp());`
		2190	`return(f_dg_modular_type(p0, p1));`
2	7u83	2191	`}`
7	7u83	2192	`case e_dg_named_type: {`
		2193	`dg_tag p0;`
		2194	`p0 = d_dg_tag();`
		2195	`return(f_dg_named_type(p0));`
2	7u83	2196	`}`
7	7u83	2197	`case e_dg_packed_type: {`
		2198	`dg_type p0;`
		2199	`shape p1;`
		2200	`p0 = d_dg_type();`
		2201	`p1 = d_shape();`
		2202	`return(f_dg_packed_type(p0, p1));`
2	7u83	2203	`}`
7	7u83	2204	`case e_dg_pointer_type: {`
		2205	`dg_type p0;`
		2206	`bool_option p1;`
		2207	`p0 = d_dg_type();`
		2208	`p1 = d_bool_option();`
		2209	`return(f_dg_pointer_type(p0, p1));`
2	7u83	2210	`}`
7	7u83	2211	`case e_dg_proc_type: {`
		2212	`dg_param_list p0;`
		2213	`dg_type p1;`
		2214	`bool_option p2;`
		2215	`nat_option p3;`
		2216	`nat_option p4;`
		2217	`procprops_option p5;`
		2218	`p0 = d_dg_param_list();`
		2219	`p1 = d_dg_type();`
		2220	`p2 = d_bool_option();`
		2221	`p3 = d_nat_option();`
		2222	`p4 = d_nat_option();`
		2223	`p5 = d_procprops_option();`
		2224	`return(f_dg_proc_type(p0, p1, p2, p3, p4, p5));`
2	7u83	2225	`}`
7	7u83	2226	`case e_dg_ptr_memdata_type: {`
		2227	`dg_tag p0;`
		2228	`dg_type p1;`
		2229	`shape p2;`
		2230	`dg_tag_option p3;`
		2231	`p0 = d_dg_tag();`
		2232	`p1 = d_dg_type();`
		2233	`p2 = d_shape();`
		2234	`p3 = d_dg_tag_option();`
		2235	`return(f_dg_ptr_memdata_type(p0, p1, p2, p3));`
2	7u83	2236	`}`
7	7u83	2237	`case e_dg_ptr_memfn_type: {`
		2238	`dg_tag p0;`
		2239	`dg_type p1;`
		2240	`shape p2;`
		2241	`dg_tag_option p3;`
		2242	`p0 = d_dg_tag();`
		2243	`p1 = d_dg_type();`
		2244	`p2 = d_shape();`
		2245	`p3 = d_dg_tag_option();`
		2246	`return(f_dg_ptr_memfn_type(p0, p1, p2, p3));`
2	7u83	2247	`}`
7	7u83	2248	`case e_dg_qualified_type: {`
		2249	`dg_qualifier p0;`
		2250	`dg_type p1;`
		2251	`p0 = d_dg_qualifier();`
		2252	`p1 = d_dg_type();`
		2253	`return(f_dg_qualified_type(p0, p1));`
2	7u83	2254	`}`
7	7u83	2255	`case e_dg_reference_type: {`
		2256	`dg_type p0;`
		2257	`p0 = d_dg_type();`
		2258	`return(f_dg_reference_type(p0));`
2	7u83	2259	`}`
7	7u83	2260	`case e_dg_set_type: {`
		2261	`dg_type p0;`
		2262	`shape p1;`
		2263	`p0 = d_dg_type();`
		2264	`p1 = d_shape();`
		2265	`return(f_dg_set_type(p0, p1));`
2	7u83	2266	`}`
7	7u83	2267	`case e_dg_spec_ref_type: {`
		2268	`dg_tag p0;`
		2269	`dg_type p1;`
		2270	`p0 = d_dg_tag();`
		2271	`p1 = d_dg_type();`
		2272	`return(f_dg_spec_ref_type(p0, p1));`
2	7u83	2273	`}`
7	7u83	2274	`case e_dg_string_type: {`
		2275	`dg_tag p0;`
		2276	`exp p1;`
		2277	`exp p2;`
		2278	`p0 = d_dg_tag();`
		2279	`p1 = hold_check(d_exp());`
		2280	`p2 = hold_check(d_exp());`
		2281	`return(f_dg_string_type(p0, p1, p2));`
2	7u83	2282	`}`
7	7u83	2283	`case e_dg_struct_type: {`
		2284	`dg_classmem_list p0;`
		2285	`shape_option p1;`
		2286	`dg_idname_option p2;`
		2287	`dg_sourcepos_option p3;`
		2288	`dg_varpart_option p4;`
		2289	`bool p5;`
		2290	`bool p6;`
		2291	`p0 = d_dg_classmem_list();`
		2292	`p1 = d_shape_option();`
		2293	`p2 = d_dg_idname_option();`
		2294	`p3 = d_dg_sourcepos_option();`
		2295	`p4 = d_dg_varpart_option();`
		2296	`p5 = d_bool();`
		2297	`p6 = d_bool();`
		2298	`return(f_dg_struct_type(p0, p1, p2, p3, p4, p5, p6));`
2	7u83	2299	`}`
7	7u83	2300	`case e_dg_subrange_type: {`
		2301	`dg_type p0;`
		2302	`dg_bound p1;`
		2303	`dg_bound p2;`
		2304	`p0 = d_dg_type();`
		2305	`p1 = d_dg_bound();`
		2306	`p2 = d_dg_bound();`
		2307	`return(f_dg_subrange_type(p0, p1, p2));`
2	7u83	2308	`}`
7	7u83	2309	`case e_dg_synchronous_type: {`
		2310	`dg_idname p0;`
		2311	`dg_sourcepos p1;`
		2312	`dg_name_list p2;`
		2313	`dg_tag p3;`
		2314	`dg_classmem_list p4;`
		2315	`dg_varpart_option p5;`
		2316	`shape_option p6;`
		2317	`bool p7;`
		2318	`dg_tag_option p8;`
		2319	`p0 = d_dg_idname();`
		2320	`p1 = d_dg_sourcepos();`
		2321	`p2 = d_dg_name_list();`
		2322	`p3 = d_dg_tag();`
		2323	`p4 = d_dg_classmem_list();`
		2324	`p5 = d_dg_varpart_option();`
		2325	`p6 = d_shape_option();`
		2326	`p7 = d_bool();`
		2327	`p8 = d_dg_tag_option();`
		2328	`return(f_dg_synchronous_type(p0, p1, p2, p3, p4, p5, p6, p7, p8));`
2	7u83	2329	`}`
7	7u83	2330	`case e_dg_task_type: {`
		2331	`dg_idname p0;`
		2332	`dg_sourcepos p1;`
		2333	`dg_name_list p2;`
		2334	`dg_tag p3;`
		2335	`dg_tag p4;`
		2336	`dg_classmem_list p5;`
		2337	`dg_varpart_option p6;`
		2338	`shape_option p7;`
		2339	`bool p8;`
		2340	`dg_tag_option p9;`
		2341	`p0 = d_dg_idname();`
		2342	`p1 = d_dg_sourcepos();`
		2343	`p2 = d_dg_name_list();`
		2344	`p3 = d_dg_tag();`
		2345	`p4 = d_dg_tag();`
		2346	`p5 = d_dg_classmem_list();`
		2347	`p6 = d_dg_varpart_option();`
		2348	`p7 = d_shape_option();`
		2349	`p8 = d_bool();`
		2350	`p9 = d_dg_tag_option();`
		2351	`return(f_dg_task_type(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));`
2	7u83	2352	`}`
7	7u83	2353	`case e_dg_unknown_type: {`
		2354	`shape p0;`
		2355	`p0 = d_shape();`
		2356	`return(f_dg_unknown_type(p0));`
2	7u83	2357	`}`
7	7u83	2358	`case e_dg_void_type: {`
		2359	`return(f_dg_void_type);`
2	7u83	2360	`}`
		2361	`}`
7	7u83	2362	`decode_error(ILLEGAL_CODE_dg_type);`
		2363	`return(f_dummy_dg_type);`
2	7u83	2364	`}`
		2365
		2366
		2367	`/* DECODE DG_TYPE_LIST */`
		2368
7	7u83	2369	`dg_type_list`
		2370	`d_dg_type_list(void)`
2	7u83	2371	`{`
7	7u83	2372	`int i, n;`
		2373	`dg_type_list temp;`
		2374	`IGNORE getcode(1);`
		2375	`n = small_dtdfint();`
		2376	`temp = new_dg_type_list(n);`
		2377	`for (i = 0; i < n; i++) {`
		2378	`dg_type e;`
		2379	`e = d_dg_type();`
		2380	`temp = add_dg_type_list(temp, e, i);`
2	7u83	2381	`}`
7	7u83	2382	`return(temp);`
2	7u83	2383	`}`
		2384
		2385
		2386	`/* DECODE DG_TYPE_LIST_OPTION */`
		2387
7	7u83	2388	`dg_type_list_option`
		2389	`d_dg_type_list_option(void)`
2	7u83	2390	`{`
7	7u83	2391	`if (getcode(1)) {`
		2392	`dg_type_list e;`
		2393	`e = d_dg_type_list();`
		2394	`return(yes_dg_type_list_option(e));`
2	7u83	2395	`}`
7	7u83	2396	`return(no_dg_type_list_option);`
2	7u83	2397	`}`
		2398
		2399
		2400	`/* DECODE DG_TYPE_OPTION */`
		2401
7	7u83	2402	`dg_type_option`
		2403	`d_dg_type_option(void)`
2	7u83	2404	`{`
7	7u83	2405	`if (getcode(1)) {`
		2406	`dg_type e;`
		2407	`e = d_dg_type();`
		2408	`return(yes_dg_type_option(e));`
2	7u83	2409	`}`
7	7u83	2410	`return(no_dg_type_option);`
2	7u83	2411	`}`
		2412
		2413
		2414	`/* DECODE DG_VARIANT */`
		2415
7	7u83	2416	`dg_variant`
		2417	`d_dg_variant(void)`
2	7u83	2418	`{`
7	7u83	2419	`int code = get_big_code(1);`
		2420	`switch (code) {`
		2421	`case e_make_dg_variant: {`
		2422	`dg_discrim_list p0;`
		2423	`dg_classmem_list p1;`
		2424	`p0 = d_dg_discrim_list();`
		2425	`p1 = d_dg_classmem_list();`
		2426	`return(f_make_dg_variant(p0, p1));`
2	7u83	2427	`}`
		2428	`}`
7	7u83	2429	`decode_error(ILLEGAL_CODE_dg_variant);`
		2430	`return(f_dummy_dg_variant);`
2	7u83	2431	`}`
		2432
		2433
		2434	`/* DECODE DG_VARIANT_LIST */`
		2435
7	7u83	2436	`dg_variant_list`
		2437	`d_dg_variant_list(void)`
2	7u83	2438	`{`
7	7u83	2439	`int i, n;`
		2440	`dg_variant_list temp;`
		2441	`IGNORE getcode(1);`
		2442	`n = small_dtdfint();`
		2443	`temp = new_dg_variant_list(n);`
		2444	`for (i = 0; i < n; i++) {`
		2445	`dg_variant e;`
		2446	`e = d_dg_variant();`
		2447	`temp = add_dg_variant_list(temp, e, i);`
2	7u83	2448	`}`
7	7u83	2449	`return(temp);`
2	7u83	2450	`}`
		2451
		2452
		2453	`/* DECODE DG_VARPART */`
		2454
7	7u83	2455	`dg_varpart`
		2456	`d_dg_varpart(void)`
2	7u83	2457	`{`
7	7u83	2458	`int code = get_big_code(2);`
		2459	`switch (code) {`
		2460	`case e_dg_discrim_varpart: {`
		2461	`dg_classmem p0;`
		2462	`dg_variant_list p1;`
		2463	`p0 = d_dg_classmem();`
		2464	`p1 = d_dg_variant_list();`
		2465	`return(f_dg_discrim_varpart(p0, p1));`
2	7u83	2466	`}`
7	7u83	2467	`case e_dg_sibl_discrim_varpart: {`
		2468	`dg_tag p0;`
		2469	`dg_variant_list p1;`
		2470	`p0 = d_dg_tag();`
		2471	`p1 = d_dg_variant_list();`
		2472	`return(f_dg_sibl_discrim_varpart(p0, p1));`
2	7u83	2473	`}`
7	7u83	2474	`case e_dg_undiscrim_varpart: {`
		2475	`dg_type p0;`
		2476	`dg_variant_list p1;`
		2477	`p0 = d_dg_type();`
		2478	`p1 = d_dg_variant_list();`
		2479	`return(f_dg_undiscrim_varpart(p0, p1));`
2	7u83	2480	`}`
		2481	`}`
7	7u83	2482	`decode_error(ILLEGAL_CODE_dg_varpart);`
		2483	`return(f_dummy_dg_varpart);`
2	7u83	2484	`}`
		2485
		2486
		2487	`/* DECODE DG_VARPART_OPTION */`
		2488
7	7u83	2489	`dg_varpart_option`
		2490	`d_dg_varpart_option(void)`
2	7u83	2491	`{`
7	7u83	2492	`if (getcode(1)) {`
		2493	`dg_varpart e;`
		2494	`e = d_dg_varpart();`
		2495	`return(yes_dg_varpart_option(e));`
2	7u83	2496	`}`
7	7u83	2497	`return(no_dg_varpart_option);`
2	7u83	2498	`}`
		2499
		2500
		2501	`/* DECODE DG_VIRTUALITY */`
		2502
7	7u83	2503	`dg_virtuality`
		2504	`d_dg_virtuality(void)`
2	7u83	2505	`{`
7	7u83	2506	`int code = get_big_code(2);`
		2507	`switch (code) {`
		2508	`case e_dg_abstract_virtuality: {`
		2509	`return(f_dg_abstract_virtuality);`
2	7u83	2510	`}`
7	7u83	2511	`case e_dg_virtual_virtuality: {`
		2512	`return(f_dg_virtual_virtuality);`
2	7u83	2513	`}`
		2514	`}`
7	7u83	2515	`decode_error(ILLEGAL_CODE_dg_virtuality);`
		2516	`return(f_dummy_dg_virtuality);`
2	7u83	2517	`}`
		2518
		2519
		2520	`/* DECODE DG_VIRTUALITY_OPTION */`
		2521
7	7u83	2522	`dg_virtuality_option`
		2523	`d_dg_virtuality_option(void)`
2	7u83	2524	`{`
7	7u83	2525	`if (getcode(1)) {`
		2526	`dg_virtuality e;`
		2527	`e = d_dg_virtuality();`
		2528	`return(yes_dg_virtuality_option(e));`
2	7u83	2529	`}`
7	7u83	2530	`return(no_dg_virtuality_option);`
2	7u83	2531	`}`
		2532
		2533
		2534	`/* DECODE DIAG_DESCRIPTOR */`
		2535
7	7u83	2536	`diag_descriptor`
		2537	`d_diag_descriptor(void)`
2	7u83	2538	`{`
7	7u83	2539	`int code = get_big_code(2);`
		2540	`switch (code) {`
		2541	`case e_diag_desc_id: {`
		2542	`tdfstring p0;`
		2543	`sourcemark p1;`
		2544	`exp p2;`
		2545	`diag_type p3;`
		2546	`p0 = d_tdfstring();`
		2547	`p1 = d_sourcemark();`
		2548	`p2 = hold_check(d_exp());`
		2549	`p3 = d_diag_type();`
		2550	`return(f_diag_desc_id(p0, p1, p2, p3));`
2	7u83	2551	`}`
7	7u83	2552	`case e_diag_desc_struct: {`
		2553	`tdfstring p0;`
		2554	`sourcemark p1;`
		2555	`diag_type p2;`
		2556	`p0 = d_tdfstring();`
		2557	`p1 = d_sourcemark();`
		2558	`p2 = d_diag_type();`
		2559	`return(f_diag_desc_struct(p0, p1, p2));`
2	7u83	2560	`}`
7	7u83	2561	`case e_diag_desc_typedef: {`
		2562	`tdfstring p0;`
		2563	`sourcemark p1;`
		2564	`diag_type p2;`
		2565	`p0 = d_tdfstring();`
		2566	`p1 = d_sourcemark();`
		2567	`p2 = d_diag_type();`
		2568	`return(f_diag_desc_typedef(p0, p1, p2));`
2	7u83	2569	`}`
		2570	`}`
7	7u83	2571	`decode_error(ILLEGAL_CODE_diag_descriptor);`
		2572	`return(f_dummy_diag_descriptor);`
2	7u83	2573	`}`
		2574
		2575
		2576	`/* DECODE DIAG_DESCRIPTOR_LIST */`
		2577
7	7u83	2578	`diag_descriptor_list`
		2579	`d_diag_descriptor_list(void)`
2	7u83	2580	`{`
7	7u83	2581	`int i, n;`
		2582	`diag_descriptor_list temp;`
		2583	`n = small_dtdfint();`
		2584	`temp = new_diag_descriptor_list(n);`
		2585	`for (i = 0; i < n; i++) {`
		2586	`diag_descriptor e;`
		2587	`e = d_diag_descriptor();`
		2588	`temp = add_diag_descriptor_list(temp, e, i);`
2	7u83	2589	`}`
7	7u83	2590	`return(temp);`
2	7u83	2591	`}`
		2592
		2593
		2594	`/* DECODE DIAG_FIELD */`
		2595
7	7u83	2596	`diag_field`
		2597	`d_diag_field(void)`
2	7u83	2598	`{`
7	7u83	2599	`tdfstring p0;`
		2600	`exp p1;`
		2601	`diag_type p2;`
		2602	`p0 = d_tdfstring();`
		2603	`p1 = hold_check(d_exp());`
		2604	`p2 = d_diag_type();`
		2605	`return(f_make_diag_field(p0, p1, p2));`
2	7u83	2606	`}`
		2607
		2608
		2609	`/* DECODE DIAG_FIELD_LIST */`
		2610
7	7u83	2611	`diag_field_list`
		2612	`d_diag_field_list(void)`
2	7u83	2613	`{`
7	7u83	2614	`int i, n;`
		2615	`diag_field_list temp;`
		2616	`IGNORE getcode(1);`
		2617	`n = small_dtdfint();`
		2618	`temp = new_diag_field_list(n);`
		2619	`for (i = 0; i < n; i++) {`
		2620	`diag_field e;`
		2621	`e = d_diag_field();`
		2622	`temp = add_diag_field_list(temp, e, i);`
2	7u83	2623	`}`
7	7u83	2624	`return(temp);`
2	7u83	2625	`}`
		2626
		2627
		2628	`/* DECODE DIAG_TAG */`
		2629
7	7u83	2630	`diag_tag`
		2631	`d_diag_tag(void)`
2	7u83	2632	`{`
7	7u83	2633	`int code = get_big_code(1);`
		2634	`switch (code) {`
		2635	`case e_make_diag_tag: {`
		2636	`tdfint p0;`
		2637	`p0 = d_tdfint();`
		2638	`return(f_make_diag_tag(p0));`
2	7u83	2639	`}`
		2640	`}`
7	7u83	2641	`decode_error(ILLEGAL_CODE_diag_tag);`
		2642	`return(f_dummy_diag_tag);`
2	7u83	2643	`}`
		2644
		2645
		2646	`/* DECODE DIAG_TAGDEF */`
		2647
7	7u83	2648	`diag_tagdef`
		2649	`d_diag_tagdef(void)`
2	7u83	2650	`{`
7	7u83	2651	`int code = get_big_code(1);`
		2652	`switch (code) {`
		2653	`case e_make_diag_tagdef: {`
		2654	`tdfint p0;`
		2655	`diag_type p1;`
		2656	`p0 = d_tdfint();`
		2657	`p1 = d_diag_type();`
		2658	`return(f_make_diag_tagdef(p0, p1));`
2	7u83	2659	`}`
		2660	`}`
7	7u83	2661	`decode_error(ILLEGAL_CODE_diag_tagdef);`
		2662	`return(f_dummy_diag_tagdef);`
2	7u83	2663	`}`
		2664
		2665
		2666	`/* DECODE DIAG_TAGDEF_LIST */`
		2667
7	7u83	2668	`diag_tagdef_list`
		2669	`d_diag_tagdef_list(void)`
2	7u83	2670	`{`
7	7u83	2671	`int i, n;`
		2672	`diag_tagdef_list temp;`
		2673	`n = small_dtdfint();`
		2674	`temp = new_diag_tagdef_list(n);`
		2675	`for (i = 0; i < n; i++) {`
		2676	`diag_tagdef e;`
		2677	`e = d_diag_tagdef();`
		2678	`temp = add_diag_tagdef_list(temp, e, i);`
2	7u83	2679	`}`
7	7u83	2680	`return(temp);`
2	7u83	2681	`}`
		2682
		2683
		2684	`/* DECODE DIAG_TQ */`
		2685
7	7u83	2686	`diag_tq`
		2687	`d_diag_tq(void)`
2	7u83	2688	`{`
7	7u83	2689	`int code = get_big_code(2);`
		2690	`switch (code) {`
		2691	`case e_add_diag_const: {`
		2692	`diag_tq p0;`
		2693	`p0 = d_diag_tq();`
		2694	`return(f_add_diag_const(p0));`
2	7u83	2695	`}`
7	7u83	2696	`case e_add_diag_volatile: {`
		2697	`diag_tq p0;`
		2698	`p0 = d_diag_tq();`
		2699	`return(f_add_diag_volatile(p0));`
2	7u83	2700	`}`
7	7u83	2701	`case e_diag_tq_null: {`
		2702	`return(f_diag_tq_null);`
2	7u83	2703	`}`
		2704	`}`
7	7u83	2705	`decode_error(ILLEGAL_CODE_diag_tq);`
		2706	`return(f_dummy_diag_tq);`
2	7u83	2707	`}`
		2708
		2709
		2710	`/* DECODE DIAG_TYPE */`
		2711
7	7u83	2712	`diag_type`
		2713	`d_diag_type(void)`
2	7u83	2714	`{`
7	7u83	2715	`int code = get_big_code(4);`
		2716	`switch (code) {`
		2717	`case e_diag_type_apply_token: {`
		2718	`token p0;`
		2719	`bitstream p1;`
		2720	`p0 = d_token();`
		2721	`p1 = d_bitstream();`
		2722	`return(f_diag_type_apply_token(p0, p1));`
2	7u83	2723	`}`
7	7u83	2724	`case e_diag_array: {`
		2725	`diag_type p0;`
		2726	`exp p1;`
		2727	`exp p2;`
		2728	`exp p3;`
		2729	`diag_type p4;`
		2730	`p0 = d_diag_type();`
		2731	`p1 = hold_check(d_exp());`
		2732	`p2 = hold_check(d_exp());`
		2733	`p3 = hold_check(d_exp());`
		2734	`p4 = d_diag_type();`
		2735	`return(f_diag_array(p0, p1, p2, p3, p4));`
2	7u83	2736	`}`
7	7u83	2737	`case e_diag_bitfield: {`
		2738	`diag_type p0;`
		2739	`nat p1;`
		2740	`p0 = d_diag_type();`
		2741	`p1 = d_nat();`
		2742	`return(f_diag_bitfield(p0, p1));`
2	7u83	2743	`}`
7	7u83	2744	`case e_diag_enum: {`
		2745	`diag_type p0;`
		2746	`tdfstring p1;`
		2747	`enum_values_list p2;`
		2748	`p0 = d_diag_type();`
		2749	`p1 = d_tdfstring();`
		2750	`p2 = d_enum_values_list();`
		2751	`return(f_diag_enum(p0, p1, p2));`
2	7u83	2752	`}`
7	7u83	2753	`case e_diag_floating_variety: {`
		2754	`floating_variety p0;`
		2755	`p0 = d_floating_variety();`
		2756	`return(f_diag_floating_variety(p0));`
2	7u83	2757	`}`
7	7u83	2758	`case e_diag_loc: {`
		2759	`diag_type p0;`
		2760	`diag_tq p1;`
		2761	`p0 = d_diag_type();`
		2762	`p1 = d_diag_tq();`
		2763	`return(f_diag_loc(p0, p1));`
2	7u83	2764	`}`
7	7u83	2765	`case e_diag_proc: {`
		2766	`diag_type_list p0;`
		2767	`bool p1;`
		2768	`diag_type p2;`
		2769	`p0 = d_diag_type_list();`
		2770	`p1 = d_bool();`
		2771	`p2 = d_diag_type();`
		2772	`return(f_diag_proc(p0, p1, p2));`
2	7u83	2773	`}`
7	7u83	2774	`case e_diag_ptr: {`
		2775	`diag_type p0;`
		2776	`diag_tq p1;`
		2777	`p0 = d_diag_type();`
		2778	`p1 = d_diag_tq();`
		2779	`return(f_diag_ptr(p0, p1));`
2	7u83	2780	`}`
7	7u83	2781	`case e_diag_struct: {`
		2782	`shape p0;`
		2783	`tdfstring p1;`
		2784	`diag_field_list p2;`
		2785	`p0 = d_shape();`
		2786	`p1 = d_tdfstring();`
		2787	`p2 = d_diag_field_list();`
		2788	`return(f_diag_struct(p0, p1, p2));`
2	7u83	2789	`}`
7	7u83	2790	`case e_diag_type_null: {`
		2791	`return(f_diag_type_null);`
2	7u83	2792	`}`
7	7u83	2793	`case e_diag_union: {`
		2794	`shape p0;`
		2795	`tdfstring p1;`
		2796	`diag_field_list p2;`
		2797	`p0 = d_shape();`
		2798	`p1 = d_tdfstring();`
		2799	`p2 = d_diag_field_list();`
		2800	`return(f_diag_union(p0, p1, p2));`
2	7u83	2801	`}`
7	7u83	2802	`case e_diag_variety: {`
		2803	`variety p0;`
		2804	`p0 = d_variety();`
		2805	`return(f_diag_variety(p0));`
2	7u83	2806	`}`
7	7u83	2807	`case e_use_diag_tag: {`
		2808	`diag_tag p0;`
		2809	`p0 = d_diag_tag();`
		2810	`return(f_use_diag_tag(p0));`
2	7u83	2811	`}`
		2812	`}`
7	7u83	2813	`decode_error(ILLEGAL_CODE_diag_type);`
		2814	`return(f_dummy_diag_type);`
2	7u83	2815	`}`
		2816
		2817
		2818	`/* DECODE DIAG_TYPE_LIST */`
		2819
7	7u83	2820	`diag_type_list`
		2821	`d_diag_type_list(void)`
2	7u83	2822	`{`
7	7u83	2823	`int i, n;`
		2824	`diag_type_list temp;`
		2825	`IGNORE getcode(1);`
		2826	`n = small_dtdfint();`
		2827	`temp = new_diag_type_list(n);`
		2828	`for (i = 0; i < n; i++) {`
		2829	`diag_type e;`
		2830	`e = d_diag_type();`
		2831	`temp = add_diag_type_list(temp, e, i);`
2	7u83	2832	`}`
7	7u83	2833	`return(temp);`
2	7u83	2834	`}`
		2835
		2836
		2837	`/* DECODE DIAG_TYPE_UNIT */`
		2838
7	7u83	2839	`diag_type_unit`
		2840	`d_diag_type_unit(void)`
2	7u83	2841	`{`
7	7u83	2842	`tdfint p0;`
		2843	`diag_tagdef_list p1;`
		2844	`p0 = d_tdfint();`
		2845	`p1 = d_diag_tagdef_list();`
		2846	`return(f_build_diagtype_unit(p0, p1));`
2	7u83	2847	`}`
		2848
		2849
		2850	`/* DECODE DIAG_UNIT */`
		2851
7	7u83	2852	`diag_unit`
		2853	`d_diag_unit(void)`
2	7u83	2854	`{`
7	7u83	2855	`tdfint p0;`
		2856	`diag_descriptor_list p1;`
		2857	`p0 = d_tdfint();`
		2858	`p1 = d_diag_descriptor_list();`
		2859	`return(f_build_diag_unit(p0, p1));`
2	7u83	2860	`}`
		2861
		2862
		2863	`/* DECODE ENUM_VALUES */`
		2864
7	7u83	2865	`enum_values`
		2866	`d_enum_values(void)`
2	7u83	2867	`{`
7	7u83	2868	`exp p0;`
		2869	`tdfstring p1;`
		2870	`p0 = hold_check(d_exp());`
		2871	`p1 = d_tdfstring();`
		2872	`return(f_make_enum_values(p0, p1));`
2	7u83	2873	`}`
		2874
		2875
		2876	`/* DECODE ENUM_VALUES_LIST */`
		2877
7	7u83	2878	`enum_values_list`
		2879	`d_enum_values_list(void)`
2	7u83	2880	`{`
7	7u83	2881	`int i, n;`
		2882	`enum_values_list temp;`
		2883	`IGNORE getcode(1);`
		2884	`n = small_dtdfint();`
		2885	`temp = new_enum_values_list(n);`
		2886	`for (i = 0; i < n; i++) {`
		2887	`enum_values e;`
		2888	`e = d_enum_values();`
		2889	`temp = add_enum_values_list(temp, e, i);`
2	7u83	2890	`}`
7	7u83	2891	`return(temp);`
2	7u83	2892	`}`
		2893
		2894
		2895	`/* DECODE ERROR_CODE */`
		2896
7	7u83	2897	`error_code`
		2898	`d_error_code(void)`
2	7u83	2899	`{`
7	7u83	2900	`int code = get_big_code(2);`
		2901	`switch (code) {`
		2902	`case e_nil_access: {`
		2903	`return(f_nil_access);`
2	7u83	2904	`}`
7	7u83	2905	`case e_overflow: {`
		2906	`return(f_overflow);`
2	7u83	2907	`}`
7	7u83	2908	`case e_stack_overflow: {`
		2909	`return(f_stack_overflow);`
2	7u83	2910	`}`
		2911	`}`
7	7u83	2912	`decode_error(ILLEGAL_CODE_error_code);`
		2913	`return(f_dummy_error_code);`
2	7u83	2914	`}`
		2915
		2916
		2917	`/* DECODE ERROR_CODE_LIST */`
		2918
7	7u83	2919	`error_code_list`
		2920	`d_error_code_list(void)`
2	7u83	2921	`{`
7	7u83	2922	`int i, n;`
		2923	`error_code_list temp;`
		2924	`IGNORE getcode(1);`
		2925	`n = small_dtdfint();`
		2926	`temp = new_error_code_list(n);`
		2927	`for (i = 0; i < n; i++) {`
		2928	`error_code e;`
		2929	`e = d_error_code();`
		2930	`temp = add_error_code_list(temp, e, i);`
2	7u83	2931	`}`
7	7u83	2932	`return(temp);`
2	7u83	2933	`}`
		2934
		2935
		2936	`/* DECODE ERROR_TREATMENT */`
		2937
7	7u83	2938	`error_treatment`
		2939	`d_error_treatment(void)`
2	7u83	2940	`{`
7	7u83	2941	`int code = get_big_code(3);`
		2942	`switch (code) {`
		2943	`case e_errt_apply_token: {`
		2944	`token p0;`
		2945	`bitstream p1;`
		2946	`p0 = d_token();`
		2947	`p1 = d_bitstream();`
		2948	`return(f_errt_apply_token(p0, p1));`
2	7u83	2949	`}`
7	7u83	2950	`case e_errt_cond: {`
		2951	`exp p0;`
		2952	`bitstream p1;`
		2953	`bitstream p2;`
		2954	`p0 = hold_const_check(d_exp());`
		2955	`p1 = d_bitstream();`
		2956	`p2 = d_bitstream();`
		2957	`return(f_errt_cond(p0, p1, p2));`
2	7u83	2958	`}`
7	7u83	2959	`case e_continue: {`
		2960	`return(f_continue);`
2	7u83	2961	`}`
7	7u83	2962	`case e_error_jump: {`
		2963	`label p0;`
		2964	`p0 = d_label();`
		2965	`return(f_error_jump(p0));`
2	7u83	2966	`}`
7	7u83	2967	`case e_trap: {`
		2968	`error_code_list p0;`
		2969	`p0 = d_error_code_list();`
		2970	`return(f_trap(p0));`
2	7u83	2971	`}`
7	7u83	2972	`case e_wrap: {`
		2973	`return(f_wrap);`
2	7u83	2974	`}`
7	7u83	2975	`case e_impossible: {`
		2976	`return(f_impossible);`
2	7u83	2977	`}`
		2978	`}`
7	7u83	2979	`decode_error(ILLEGAL_CODE_error_treatment);`
		2980	`return(f_dummy_error_treatment);`
2	7u83	2981	`}`
		2982
		2983
		2984	`/* DECODE EXP */`
		2985
7	7u83	2986	`exp`
		2987	`d_exp(void)`
2	7u83	2988	`{`
7	7u83	2989	`int code = get_big_code(7);`
		2990	`switch (code) {`
		2991	`case e_exp_apply_token: {`
		2992	`token p0;`
		2993	`bitstream p1;`
		2994	`p0 = d_token();`
		2995	`p1 = d_bitstream();`
		2996	`return(f_exp_apply_token(p0, p1));`
2	7u83	2997	`}`
7	7u83	2998	`case e_exp_cond: {`
		2999	`exp p0;`
		3000	`bitstream p1;`
		3001	`bitstream p2;`
		3002	`p0 = hold_const_check(d_exp());`
		3003	`p1 = d_bitstream();`
		3004	`p2 = d_bitstream();`
		3005	`return(f_exp_cond(p0, p1, p2));`
2	7u83	3006	`}`
7	7u83	3007	`case e_abs: {`
		3008	`error_treatment p0;`
		3009	`exp p1;`
		3010	`p0 = d_error_treatment();`
		3011	`p1 = hold_check(d_exp());`
		3012	`return(f_abs(p0, p1));`
2	7u83	3013	`}`
7	7u83	3014	`case e_add_to_ptr: {`
		3015	`exp p0;`
		3016	`exp p1;`
		3017	`p0 = hold_check(d_exp());`
		3018	`p1 = hold_check(d_exp());`
		3019	`return(f_add_to_ptr(p0, p1));`
2	7u83	3020	`}`
7	7u83	3021	`case e_and: {`
		3022	`exp p0;`
		3023	`exp p1;`
		3024	`p0 = hold_check(d_exp());`
		3025	`p1 = hold_check(d_exp());`
		3026	`return(f_and(p0, p1));`
2	7u83	3027	`}`
7	7u83	3028	`case e_apply_proc: {`
		3029	`shape p0;`
		3030	`exp p1;`
		3031	`exp_list p2;`
		3032	`exp_option p3;`
		3033	`p0 = d_shape();`
		3034	`p1 = hold_check(d_exp());`
		3035	`p2 = d_exp_list();`
		3036	`p3 = d_exp_option();`
		3037	`return(f_apply_proc(p0, p1, p2, p3));`
2	7u83	3038	`}`
7	7u83	3039	`case e_apply_general_proc: {`
		3040	`shape p0;`
		3041	`procprops_option p1;`
		3042	`exp p2;`
		3043	`otagexp_list p3;`
		3044	`callees p4;`
		3045	`exp p5;`
		3046	`p0 = d_shape();`
		3047	`p1 = d_procprops_option();`
		3048	`p2 = hold_check(d_exp());`
		3049	`p3 = d_otagexp_list();`
		3050	`p4 = d_callees();`
		3051	`start_apply_general_proc(p0, p1, p2, p3, p4);`
		3052	`p5 = hold_check(d_exp());`
		3053	`return(f_apply_general_proc(p0, p1, p2, p3, p4, p5));`
2	7u83	3054	`}`
7	7u83	3055	`case e_assign: {`
		3056	`exp p0;`
		3057	`exp p1;`
		3058	`p0 = hold_check(d_exp());`
		3059	`p1 = hold_check(d_exp());`
		3060	`return(f_assign(p0, p1));`
2	7u83	3061	`}`
7	7u83	3062	`case e_assign_with_mode: {`
		3063	`transfer_mode p0;`
		3064	`exp p1;`
		3065	`exp p2;`
		3066	`p0 = d_transfer_mode();`
		3067	`p1 = hold_check(d_exp());`
		3068	`p2 = hold_check(d_exp());`
		3069	`return(f_assign_with_mode(p0, p1, p2));`
2	7u83	3070	`}`
7	7u83	3071	`case e_bitfield_assign: {`
		3072	`exp p0;`
		3073	`exp p1;`
		3074	`exp p2;`
		3075	`p0 = hold_check(d_exp());`
		3076	`p1 = hold_check(d_exp());`
		3077	`p2 = hold_check(d_exp());`
		3078	`return(f_bitfield_assign(p0, p1, p2));`
2	7u83	3079	`}`
7	7u83	3080	`case e_bitfield_assign_with_mode: {`
		3081	`transfer_mode p0;`
		3082	`exp p1;`
		3083	`exp p2;`
		3084	`exp p3;`
		3085	`p0 = d_transfer_mode();`
		3086	`p1 = hold_check(d_exp());`
		3087	`p2 = hold_check(d_exp());`
		3088	`p3 = hold_check(d_exp());`
		3089	`return(f_bitfield_assign_with_mode(p0, p1, p2, p3));`
2	7u83	3090	`}`
7	7u83	3091	`case e_bitfield_contents: {`
		3092	`bitfield_variety p0;`
		3093	`exp p1;`
		3094	`exp p2;`
		3095	`p0 = d_bitfield_variety();`
		3096	`p1 = hold_check(d_exp());`
		3097	`p2 = hold_check(d_exp());`
		3098	`return(f_bitfield_contents(p0, p1, p2));`
2	7u83	3099	`}`
7	7u83	3100	`case e_bitfield_contents_with_mode: {`
		3101	`transfer_mode p0;`
		3102	`bitfield_variety p1;`
		3103	`exp p2;`
		3104	`exp p3;`
		3105	`p0 = d_transfer_mode();`
		3106	`p1 = d_bitfield_variety();`
		3107	`p2 = hold_check(d_exp());`
		3108	`p3 = hold_check(d_exp());`
		3109	`return(f_bitfield_contents_with_mode(p0, p1, p2, p3));`
2	7u83	3110	`}`
7	7u83	3111	`case e_case: {`
		3112	`bool p0;`
		3113	`exp p1;`
		3114	`caselim_list p2;`
		3115	`p0 = d_bool();`
		3116	`p1 = hold_check(d_exp());`
		3117	`p2 = d_caselim_list();`
		3118	`return(f_case(p0, p1, p2));`
2	7u83	3119	`}`
7	7u83	3120	`case e_change_bitfield_to_int: {`
		3121	`variety p0;`
		3122	`exp p1;`
		3123	`p0 = d_variety();`
		3124	`p1 = hold_check(d_exp());`
		3125	`return(f_change_bitfield_to_int(p0, p1));`
2	7u83	3126	`}`
7	7u83	3127	`case e_change_floating_variety: {`
		3128	`error_treatment p0;`
		3129	`floating_variety p1;`
		3130	`exp p2;`
		3131	`p0 = d_error_treatment();`
		3132	`p1 = d_floating_variety();`
		3133	`p2 = hold_check(d_exp());`
		3134	`return(f_change_floating_variety(p0, p1, p2));`
2	7u83	3135	`}`
7	7u83	3136	`case e_change_variety: {`
		3137	`error_treatment p0;`
		3138	`variety p1;`
		3139	`exp p2;`
		3140	`p0 = d_error_treatment();`
		3141	`p1 = d_variety();`
		3142	`p2 = hold_check(d_exp());`
		3143	`return(f_change_variety(p0, p1, p2));`
2	7u83	3144	`}`
7	7u83	3145	`case e_change_int_to_bitfield: {`
		3146	`bitfield_variety p0;`
		3147	`exp p1;`
		3148	`p0 = d_bitfield_variety();`
		3149	`p1 = hold_check(d_exp());`
		3150	`return(f_change_int_to_bitfield(p0, p1));`
2	7u83	3151	`}`
7	7u83	3152	`case e_complex_conjugate: {`
		3153	`exp p0;`
		3154	`p0 = hold_check(d_exp());`
		3155	`return(f_complex_conjugate(p0));`
2	7u83	3156	`}`
7	7u83	3157	`case e_component: {`
		3158	`shape p0;`
		3159	`exp p1;`
		3160	`exp p2;`
		3161	`p0 = d_shape();`
		3162	`p1 = hold_check(d_exp());`
		3163	`p2 = hold_check(d_exp());`
		3164	`return(f_component(p0, p1, p2));`
2	7u83	3165	`}`
7	7u83	3166	`case e_concat_nof: {`
		3167	`exp p0;`
		3168	`exp p1;`
		3169	`p0 = hold_check(d_exp());`
		3170	`p1 = hold_check(d_exp());`
		3171	`return(f_concat_nof(p0, p1));`
2	7u83	3172	`}`
7	7u83	3173	`case e_conditional: {`
		3174	`label p0;`
		3175	`exp p1;`
		3176	`exp p2;`
		3177	`p0 = d_label();`
		3178	`start_conditional(p0);`
		3179	`p1 = hold_check(d_exp());`
		3180	`p2 = hold_check(d_exp());`
		3181	`return(f_conditional(p0, p1, p2));`
2	7u83	3182	`}`
7	7u83	3183	`case e_contents: {`
		3184	`shape p0;`
		3185	`exp p1;`
		3186	`p0 = d_shape();`
		3187	`p1 = hold_check(d_exp());`
		3188	`return(f_contents(p0, p1));`
2	7u83	3189	`}`
7	7u83	3190	`case e_contents_with_mode: {`
		3191	`transfer_mode p0;`
		3192	`shape p1;`
		3193	`exp p2;`
		3194	`p0 = d_transfer_mode();`
		3195	`p1 = d_shape();`
		3196	`p2 = hold_check(d_exp());`
		3197	`return(f_contents_with_mode(p0, p1, p2));`
2	7u83	3198	`}`
7	7u83	3199	`case e_current_env: {`
		3200	`return(f_current_env());`
2	7u83	3201	`}`
7	7u83	3202	`case e_div0: {`
		3203	`error_treatment p0;`
		3204	`error_treatment p1;`
		3205	`exp p2;`
		3206	`exp p3;`
		3207	`p0 = d_error_treatment();`
		3208	`p1 = d_error_treatment();`
		3209	`p2 = hold_check(d_exp());`
		3210	`p3 = hold_check(d_exp());`
		3211	`return(f_div0(p0, p1, p2, p3));`
2	7u83	3212	`}`
7	7u83	3213	`case e_div1: {`
		3214	`error_treatment p0;`
		3215	`error_treatment p1;`
		3216	`exp p2;`
		3217	`exp p3;`
		3218	`p0 = d_error_treatment();`
		3219	`p1 = d_error_treatment();`
		3220	`p2 = hold_check(d_exp());`
		3221	`p3 = hold_check(d_exp());`
		3222	`return(f_div1(p0, p1, p2, p3));`
2	7u83	3223	`}`
7	7u83	3224	`case e_div2: {`
		3225	`error_treatment p0;`
		3226	`error_treatment p1;`
		3227	`exp p2;`
		3228	`exp p3;`
		3229	`p0 = d_error_treatment();`
		3230	`p1 = d_error_treatment();`
		3231	`p2 = hold_check(d_exp());`
		3232	`p3 = hold_check(d_exp());`
		3233	`return(f_div2(p0, p1, p2, p3));`
2	7u83	3234	`}`
7	7u83	3235	`case e_env_offset: {`
		3236	`alignment p0;`
		3237	`alignment p1;`
		3238	`tag p2;`
		3239	`p0 = d_alignment();`
		3240	`p1 = d_alignment();`
		3241	`p2 = d_tag();`
		3242	`return(f_env_offset(p0, p1, p2));`
2	7u83	3243	`}`
7	7u83	3244	`case e_env_size: {`
		3245	`tag p0;`
		3246	`p0 = d_tag();`
		3247	`return(f_env_size(p0));`
2	7u83	3248	`}`
7	7u83	3249	`case e_fail_installer: {`
		3250	`string p0;`
		3251	`p0 = d_string();`
		3252	`return(f_fail_installer(p0));`
2	7u83	3253	`}`
7	7u83	3254	`case e_float_int: {`
		3255	`error_treatment p0;`
		3256	`floating_variety p1;`
		3257	`exp p2;`
		3258	`p0 = d_error_treatment();`
		3259	`p1 = d_floating_variety();`
		3260	`p2 = hold_check(d_exp());`
		3261	`return(f_float_int(p0, p1, p2));`
2	7u83	3262	`}`
7	7u83	3263	`case e_floating_abs: {`
		3264	`error_treatment p0;`
		3265	`exp p1;`
		3266	`p0 = d_error_treatment();`
		3267	`p1 = hold_check(d_exp());`
		3268	`return(f_floating_abs(p0, p1));`
2	7u83	3269	`}`
7	7u83	3270	`case e_floating_div: {`
		3271	`error_treatment p0;`
		3272	`exp p1;`
		3273	`exp p2;`
		3274	`p0 = d_error_treatment();`
		3275	`p1 = hold_check(d_exp());`
		3276	`p2 = hold_check(d_exp());`
		3277	`return(f_floating_div(p0, p1, p2));`
2	7u83	3278	`}`
7	7u83	3279	`case e_floating_minus: {`
		3280	`error_treatment p0;`
		3281	`exp p1;`
		3282	`exp p2;`
		3283	`p0 = d_error_treatment();`
		3284	`p1 = hold_check(d_exp());`
		3285	`p2 = hold_check(d_exp());`
		3286	`return(f_floating_minus(p0, p1, p2));`
2	7u83	3287	`}`
7	7u83	3288	`case e_floating_maximum: {`
		3289	`error_treatment p0;`
		3290	`exp p1;`
		3291	`exp p2;`
		3292	`p0 = d_error_treatment();`
		3293	`p1 = hold_check(d_exp());`
		3294	`p2 = hold_check(d_exp());`
		3295	`return(f_floating_maximum(p0, p1, p2));`
2	7u83	3296	`}`
7	7u83	3297	`case e_floating_minimum: {`
		3298	`error_treatment p0;`
		3299	`exp p1;`
		3300	`exp p2;`
		3301	`p0 = d_error_treatment();`
		3302	`p1 = hold_check(d_exp());`
		3303	`p2 = hold_check(d_exp());`
		3304	`return(f_floating_minimum(p0, p1, p2));`
2	7u83	3305	`}`
7	7u83	3306	`case e_floating_mult: {`
		3307	`error_treatment p0;`
		3308	`exp_list p1;`
		3309	`p0 = d_error_treatment();`
		3310	`p1 = d_exp_list();`
		3311	`return(f_floating_mult(p0, p1));`
2	7u83	3312	`}`
7	7u83	3313	`case e_floating_negate: {`
		3314	`error_treatment p0;`
		3315	`exp p1;`
		3316	`p0 = d_error_treatment();`
		3317	`p1 = hold_check(d_exp());`
		3318	`return(f_floating_negate(p0, p1));`
2	7u83	3319	`}`
7	7u83	3320	`case e_floating_plus: {`
		3321	`error_treatment p0;`
		3322	`exp_list p1;`
		3323	`p0 = d_error_treatment();`
		3324	`p1 = d_exp_list();`
		3325	`return(f_floating_plus(p0, p1));`
2	7u83	3326	`}`
7	7u83	3327	`case e_floating_power: {`
		3328	`error_treatment p0;`
		3329	`exp p1;`
		3330	`exp p2;`
		3331	`p0 = d_error_treatment();`
		3332	`p1 = hold_check(d_exp());`
		3333	`p2 = hold_check(d_exp());`
		3334	`return(f_floating_power(p0, p1, p2));`
2	7u83	3335	`}`
7	7u83	3336	`case e_floating_test: {`
		3337	`nat_option p0;`
		3338	`error_treatment p1;`
		3339	`ntest p2;`
		3340	`label p3;`
		3341	`exp p4;`
		3342	`exp p5;`
		3343	`p0 = d_nat_option();`
		3344	`p1 = d_error_treatment();`
		3345	`p2 = d_ntest();`
		3346	`p3 = d_label();`
		3347	`p4 = hold_check(d_exp());`
		3348	`p5 = hold_check(d_exp());`
		3349	`return(f_floating_test(p0, p1, p2, p3, p4, p5));`
2	7u83	3350	`}`
7	7u83	3351	`case e_goto: {`
		3352	`label p0;`
		3353	`p0 = d_label();`
		3354	`return(f_goto(p0));`
2	7u83	3355	`}`
7	7u83	3356	`case e_goto_local_lv: {`
		3357	`exp p0;`
		3358	`p0 = hold_check(d_exp());`
		3359	`return(f_goto_local_lv(p0));`
2	7u83	3360	`}`
7	7u83	3361	`case e_identify: {`
		3362	`access_option p0;`
		3363	`tag p1;`
		3364	`exp p2;`
		3365	`exp p3;`
		3366	`p0 = d_access_option();`
		3367	`p1 = d_tag();`
		3368	`p2 = hold_check(d_exp());`
		3369	`start_identify(p0, p1, p2);`
		3370	`p3 = hold_check(d_exp());`
		3371	`return(f_identify(p0, p1, p2, p3));`
2	7u83	3372	`}`
7	7u83	3373	`case e_ignorable: {`
		3374	`exp p0;`
		3375	`p0 = hold_check(d_exp());`
		3376	`return(f_ignorable(p0));`
2	7u83	3377	`}`
7	7u83	3378	`case e_imaginary_part: {`
		3379	`exp p0;`
		3380	`p0 = hold_check(d_exp());`
		3381	`return(f_imaginary_part(p0));`
2	7u83	3382	`}`
7	7u83	3383	`case e_initial_value: {`
		3384	`exp p0;`
		3385	`start_initial_value();`
		3386	`p0 = hold_check(d_exp());`
		3387	`return(f_initial_value(p0));`
2	7u83	3388	`}`
7	7u83	3389	`case e_integer_test: {`
		3390	`nat_option p0;`
		3391	`ntest p1;`
		3392	`label p2;`
		3393	`exp p3;`
		3394	`exp p4;`
		3395	`p0 = d_nat_option();`
		3396	`p1 = d_ntest();`
		3397	`p2 = d_label();`
		3398	`p3 = hold_check(d_exp());`
		3399	`p4 = hold_check(d_exp());`
		3400	`return(f_integer_test(p0, p1, p2, p3, p4));`
2	7u83	3401	`}`
7	7u83	3402	`case e_labelled: {`
		3403	`label_list p0;`
		3404	`exp p1;`
		3405	`exp_list p2;`
		3406	`p0 = d_label_list();`
		3407	`start_labelled(p0);`
		3408	`p1 = hold_check(d_exp());`
		3409	`p2 = d_exp_list();`
		3410	`return(f_labelled(p0, p1, p2));`
2	7u83	3411	`}`
7	7u83	3412	`case e_last_local: {`
		3413	`exp p0;`
		3414	`p0 = hold_check(d_exp());`
		3415	`return(f_last_local(p0));`
2	7u83	3416	`}`
7	7u83	3417	`case e_local_alloc: {`
		3418	`exp p0;`
		3419	`p0 = hold_check(d_exp());`
		3420	`return(f_local_alloc(p0));`
2	7u83	3421	`}`
7	7u83	3422	`case e_local_alloc_check: {`
		3423	`exp p0;`
		3424	`p0 = hold_check(d_exp());`
		3425	`return(f_local_alloc_check(p0));`
2	7u83	3426	`}`
7	7u83	3427	`case e_local_free: {`
		3428	`exp p0;`
		3429	`exp p1;`
		3430	`p0 = hold_check(d_exp());`
		3431	`p1 = hold_check(d_exp());`
		3432	`return(f_local_free(p0, p1));`
2	7u83	3433	`}`
7	7u83	3434	`case e_local_free_all: {`
		3435	`return(f_local_free_all());`
2	7u83	3436	`}`
7	7u83	3437	`case e_long_jump: {`
		3438	`exp p0;`
		3439	`exp p1;`
		3440	`p0 = hold_check(d_exp());`
		3441	`p1 = hold_check(d_exp());`
		3442	`return(f_long_jump(p0, p1));`
2	7u83	3443	`}`
7	7u83	3444	`case e_make_complex: {`
		3445	`floating_variety p0;`
		3446	`exp p1;`
		3447	`exp p2;`
		3448	`p0 = d_floating_variety();`
		3449	`p1 = hold_check(d_exp());`
		3450	`p2 = hold_check(d_exp());`
		3451	`return(f_make_complex(p0, p1, p2));`
2	7u83	3452	`}`
7	7u83	3453	`case e_make_compound: {`
		3454	`exp p0;`
		3455	`exp_list p1;`
		3456	`p0 = hold_check(d_exp());`
		3457	`p1 = d_exp_list();`
		3458	`return(f_make_compound(p0, p1));`
2	7u83	3459	`}`
7	7u83	3460	`case e_make_floating: {`
		3461	`floating_variety p0;`
		3462	`rounding_mode p1;`
		3463	`bool p2;`
		3464	`string p3;`
		3465	`nat p4;`
		3466	`signed_nat p5;`
		3467	`p0 = d_floating_variety();`
		3468	`p1 = d_rounding_mode();`
		3469	`p2 = d_bool();`
		3470	`p3 = d_string();`
		3471	`p4 = d_nat();`
		3472	`p5 = d_signed_nat();`
		3473	`return(f_make_floating(p0, p1, p2, p3, p4, p5));`
2	7u83	3474	`}`
7	7u83	3475	`case e_make_general_proc: {`
		3476	`shape p0;`
		3477	`procprops_option p1;`
		3478	`tagshacc_list p2;`
		3479	`tagshacc_list p3;`
		3480	`exp p4;`
		3481	`p0 = d_shape();`
		3482	`p1 = d_procprops_option();`
		3483	`p2 = d_tagshacc_list();`
		3484	`p3 = d_tagshacc_list();`
		3485	`start_make_general_proc(p0, p1, p2, p3);`
		3486	`p4 = hold_check(d_exp());`
		3487	`return(f_make_general_proc(p0, p1, p2, p3, p4));`
2	7u83	3488	`}`
7	7u83	3489	`case e_make_int: {`
		3490	`variety p0;`
		3491	`signed_nat p1;`
		3492	`p0 = d_variety();`
		3493	`p1 = d_signed_nat();`
		3494	`return(f_make_int(p0, p1));`
2	7u83	3495	`}`
7	7u83	3496	`case e_make_local_lv: {`
		3497	`label p0;`
		3498	`p0 = d_label();`
		3499	`return(f_make_local_lv(p0));`
2	7u83	3500	`}`
7	7u83	3501	`case e_make_nof: {`
		3502	`exp_list p0;`
		3503	`p0 = d_exp_list();`
		3504	`return(f_make_nof(p0));`
2	7u83	3505	`}`
7	7u83	3506	`case e_make_nof_int: {`
		3507	`variety p0;`
		3508	`string p1;`
		3509	`p0 = d_variety();`
		3510	`p1 = d_string();`
		3511	`return(f_make_nof_int(p0, p1));`
2	7u83	3512	`}`
7	7u83	3513	`case e_make_null_local_lv: {`
		3514	`return(f_make_null_local_lv());`
2	7u83	3515	`}`
7	7u83	3516	`case e_make_null_proc: {`
		3517	`return(f_make_null_proc());`
2	7u83	3518	`}`
7	7u83	3519	`case e_make_null_ptr: {`
		3520	`alignment p0;`
		3521	`p0 = d_alignment();`
		3522	`return(f_make_null_ptr(p0));`
2	7u83	3523	`}`
7	7u83	3524	`case e_make_proc: {`
		3525	`shape p0;`
		3526	`tagshacc_list p1;`
		3527	`tagacc_option p2;`
		3528	`exp p3;`
		3529	`p0 = d_shape();`
		3530	`p1 = d_tagshacc_list();`
		3531	`p2 = d_tagacc_option();`
		3532	`start_make_proc(p0, p1, p2);`
		3533	`p3 = hold_check(d_exp());`
		3534	`return(f_make_proc(p0, p1, p2, p3));`
2	7u83	3535	`}`
7	7u83	3536	`case e_make_stack_limit: {`
		3537	`exp p0;`
		3538	`exp p1;`
		3539	`exp p2;`
		3540	`p0 = hold_check(d_exp());`
		3541	`p1 = hold_check(d_exp());`
		3542	`p2 = hold_check(d_exp());`
		3543	`return(f_make_stack_limit(p0, p1, p2));`
2	7u83	3544	`}`
7	7u83	3545	`case e_make_top: {`
		3546	`return(f_make_top());`
2	7u83	3547	`}`
7	7u83	3548	`case e_make_value: {`
		3549	`shape p0;`
		3550	`p0 = d_shape();`
		3551	`return(f_make_value(p0));`
2	7u83	3552	`}`
7	7u83	3553	`case e_maximum: {`
		3554	`exp p0;`
		3555	`exp p1;`
		3556	`p0 = hold_check(d_exp());`
		3557	`p1 = hold_check(d_exp());`
		3558	`return(f_maximum(p0, p1));`
2	7u83	3559	`}`
7	7u83	3560	`case e_minimum: {`
		3561	`exp p0;`
		3562	`exp p1;`
		3563	`p0 = hold_check(d_exp());`
		3564	`p1 = hold_check(d_exp());`
		3565	`return(f_minimum(p0, p1));`
2	7u83	3566	`}`
7	7u83	3567	`case e_minus: {`
		3568	`error_treatment p0;`
		3569	`exp p1;`
		3570	`exp p2;`
		3571	`p0 = d_error_treatment();`
		3572	`p1 = hold_check(d_exp());`
		3573	`p2 = hold_check(d_exp());`
		3574	`return(f_minus(p0, p1, p2));`
2	7u83	3575	`}`
7	7u83	3576	`case e_move_some: {`
		3577	`transfer_mode p0;`
		3578	`exp p1;`
		3579	`exp p2;`
		3580	`exp p3;`
		3581	`p0 = d_transfer_mode();`
		3582	`p1 = hold_check(d_exp());`
		3583	`p2 = hold_check(d_exp());`
		3584	`p3 = hold_check(d_exp());`
		3585	`return(f_move_some(p0, p1, p2, p3));`
2	7u83	3586	`}`
7	7u83	3587	`case e_mult: {`
		3588	`error_treatment p0;`
		3589	`exp p1;`
		3590	`exp p2;`
		3591	`p0 = d_error_treatment();`
		3592	`p1 = hold_check(d_exp());`
		3593	`p2 = hold_check(d_exp());`
		3594	`return(f_mult(p0, p1, p2));`
2	7u83	3595	`}`
7	7u83	3596	`case e_n_copies: {`
		3597	`nat p0;`
		3598	`exp p1;`
		3599	`p0 = d_nat();`
		3600	`p1 = hold_check(d_exp());`
		3601	`return(f_n_copies(p0, p1));`
2	7u83	3602	`}`
7	7u83	3603	`case e_negate: {`
		3604	`error_treatment p0;`
		3605	`exp p1;`
		3606	`p0 = d_error_treatment();`
		3607	`p1 = hold_check(d_exp());`
		3608	`return(f_negate(p0, p1));`
2	7u83	3609	`}`
7	7u83	3610	`case e_not: {`
		3611	`exp p0;`
		3612	`p0 = hold_check(d_exp());`
		3613	`return(f_not(p0));`
2	7u83	3614	`}`
7	7u83	3615	`case e_obtain_tag: {`
		3616	`tag p0;`
		3617	`p0 = d_tag();`
		3618	`return(f_obtain_tag(p0));`
2	7u83	3619	`}`
7	7u83	3620	`case e_offset_add: {`
		3621	`exp p0;`
		3622	`exp p1;`
		3623	`p0 = hold_check(d_exp());`
		3624	`p1 = hold_check(d_exp());`
		3625	`return(f_offset_add(p0, p1));`
2	7u83	3626	`}`
7	7u83	3627	`case e_offset_div: {`
		3628	`variety p0;`
		3629	`exp p1;`
		3630	`exp p2;`
		3631	`p0 = d_variety();`
		3632	`p1 = hold_check(d_exp());`
		3633	`p2 = hold_check(d_exp());`
		3634	`return(f_offset_div(p0, p1, p2));`
2	7u83	3635	`}`
7	7u83	3636	`case e_offset_div_by_int: {`
		3637	`exp p0;`
		3638	`exp p1;`
		3639	`p0 = hold_check(d_exp());`
		3640	`p1 = hold_check(d_exp());`
		3641	`return(f_offset_div_by_int(p0, p1));`
2	7u83	3642	`}`
7	7u83	3643	`case e_offset_max: {`
		3644	`exp p0;`
		3645	`exp p1;`
		3646	`p0 = hold_check(d_exp());`
		3647	`p1 = hold_check(d_exp());`
		3648	`return(f_offset_max(p0, p1));`
2	7u83	3649	`}`
7	7u83	3650	`case e_offset_mult: {`
		3651	`exp p0;`
		3652	`exp p1;`
		3653	`p0 = hold_check(d_exp());`
		3654	`p1 = hold_check(d_exp());`
		3655	`return(f_offset_mult(p0, p1));`
2	7u83	3656	`}`
7	7u83	3657	`case e_offset_negate: {`
		3658	`exp p0;`
		3659	`p0 = hold_check(d_exp());`
		3660	`return(f_offset_negate(p0));`
2	7u83	3661	`}`
7	7u83	3662	`case e_offset_pad: {`
		3663	`alignment p0;`
		3664	`exp p1;`
		3665	`p0 = d_alignment();`
		3666	`p1 = hold_check(d_exp());`
		3667	`return(f_offset_pad(p0, p1));`
2	7u83	3668	`}`
7	7u83	3669	`case e_offset_subtract: {`
		3670	`exp p0;`
		3671	`exp p1;`
		3672	`p0 = hold_check(d_exp());`
		3673	`p1 = hold_check(d_exp());`
		3674	`return(f_offset_subtract(p0, p1));`
2	7u83	3675	`}`
7	7u83	3676	`case e_offset_test: {`
		3677	`nat_option p0;`
		3678	`ntest p1;`
		3679	`label p2;`
		3680	`exp p3;`
		3681	`exp p4;`
		3682	`p0 = d_nat_option();`
		3683	`p1 = d_ntest();`
		3684	`p2 = d_label();`
		3685	`p3 = hold_check(d_exp());`
		3686	`p4 = hold_check(d_exp());`
		3687	`return(f_offset_test(p0, p1, p2, p3, p4));`
2	7u83	3688	`}`
7	7u83	3689	`case e_offset_zero: {`
		3690	`alignment p0;`
		3691	`p0 = d_alignment();`
		3692	`return(f_offset_zero(p0));`
2	7u83	3693	`}`
7	7u83	3694	`case e_or: {`
		3695	`exp p0;`
		3696	`exp p1;`
		3697	`p0 = hold_check(d_exp());`
		3698	`p1 = hold_check(d_exp());`
		3699	`return(f_or(p0, p1));`
2	7u83	3700	`}`
7	7u83	3701	`case e_plus: {`
		3702	`error_treatment p0;`
		3703	`exp p1;`
		3704	`exp p2;`
		3705	`p0 = d_error_treatment();`
		3706	`p1 = hold_check(d_exp());`
		3707	`p2 = hold_check(d_exp());`
		3708	`return(f_plus(p0, p1, p2));`
2	7u83	3709	`}`
7	7u83	3710	`case e_pointer_test: {`
		3711	`nat_option p0;`
		3712	`ntest p1;`
		3713	`label p2;`
		3714	`exp p3;`
		3715	`exp p4;`
		3716	`p0 = d_nat_option();`
		3717	`p1 = d_ntest();`
		3718	`p2 = d_label();`
		3719	`p3 = hold_check(d_exp());`
		3720	`p4 = hold_check(d_exp());`
		3721	`return(f_pointer_test(p0, p1, p2, p3, p4));`
2	7u83	3722	`}`
7	7u83	3723	`case e_power: {`
		3724	`error_treatment p0;`
		3725	`exp p1;`
		3726	`exp p2;`
		3727	`p0 = d_error_treatment();`
		3728	`p1 = hold_check(d_exp());`
		3729	`p2 = hold_check(d_exp());`
		3730	`return(f_power(p0, p1, p2));`
2	7u83	3731	`}`
7	7u83	3732	`case e_proc_test: {`
		3733	`nat_option p0;`
		3734	`ntest p1;`
		3735	`label p2;`
		3736	`exp p3;`
		3737	`exp p4;`
		3738	`p0 = d_nat_option();`
		3739	`p1 = d_ntest();`
		3740	`p2 = d_label();`
		3741	`p3 = hold_check(d_exp());`
		3742	`p4 = hold_check(d_exp());`
		3743	`return(f_proc_test(p0, p1, p2, p3, p4));`
2	7u83	3744	`}`
7	7u83	3745	`case e_profile: {`
		3746	`nat p0;`
		3747	`p0 = d_nat();`
		3748	`return(f_profile(p0));`
2	7u83	3749	`}`
7	7u83	3750	`case e_real_part: {`
		3751	`exp p0;`
		3752	`p0 = hold_check(d_exp());`
		3753	`return(f_real_part(p0));`
2	7u83	3754	`}`
7	7u83	3755	`case e_rem0: {`
		3756	`error_treatment p0;`
		3757	`error_treatment p1;`
		3758	`exp p2;`
		3759	`exp p3;`
		3760	`p0 = d_error_treatment();`
		3761	`p1 = d_error_treatment();`
		3762	`p2 = hold_check(d_exp());`
		3763	`p3 = hold_check(d_exp());`
		3764	`return(f_rem0(p0, p1, p2, p3));`
2	7u83	3765	`}`
7	7u83	3766	`case e_rem1: {`
		3767	`error_treatment p0;`
		3768	`error_treatment p1;`
		3769	`exp p2;`
		3770	`exp p3;`
		3771	`p0 = d_error_treatment();`
		3772	`p1 = d_error_treatment();`
		3773	`p2 = hold_check(d_exp());`
		3774	`p3 = hold_check(d_exp());`
		3775	`return(f_rem1(p0, p1, p2, p3));`
2	7u83	3776	`}`
7	7u83	3777	`case e_rem2: {`
		3778	`error_treatment p0;`
		3779	`error_treatment p1;`
		3780	`exp p2;`
		3781	`exp p3;`
		3782	`p0 = d_error_treatment();`
		3783	`p1 = d_error_treatment();`
		3784	`p2 = hold_check(d_exp());`
		3785	`p3 = hold_check(d_exp());`
		3786	`return(f_rem2(p0, p1, p2, p3));`
2	7u83	3787	`}`
7	7u83	3788	`case e_repeat: {`
		3789	`label p0;`
		3790	`exp p1;`
		3791	`exp p2;`
		3792	`p0 = d_label();`
		3793	`start_repeat(p0);`
		3794	`p1 = hold_check(d_exp());`
		3795	`p2 = hold_check(d_exp());`
		3796	`return(f_repeat(p0, p1, p2));`
2	7u83	3797	`}`
7	7u83	3798	`case e_return: {`
		3799	`exp p0;`
		3800	`p0 = hold_check(d_exp());`
		3801	`return(f_return(p0));`
2	7u83	3802	`}`
7	7u83	3803	`case e_return_to_label: {`
		3804	`exp p0;`
		3805	`p0 = hold_check(d_exp());`
		3806	`return(f_return_to_label(p0));`
2	7u83	3807	`}`
7	7u83	3808	`case e_round_with_mode: {`
		3809	`error_treatment p0;`
		3810	`rounding_mode p1;`
		3811	`variety p2;`
		3812	`exp p3;`
		3813	`p0 = d_error_treatment();`
		3814	`p1 = d_rounding_mode();`
		3815	`p2 = d_variety();`
		3816	`p3 = hold_check(d_exp());`
		3817	`return(f_round_with_mode(p0, p1, p2, p3));`
2	7u83	3818	`}`
7	7u83	3819	`case e_rotate_left: {`
		3820	`exp p0;`
		3821	`exp p1;`
		3822	`p0 = hold_check(d_exp());`
		3823	`p1 = hold_check(d_exp());`
		3824	`return(f_rotate_left(p0, p1));`
2	7u83	3825	`}`
7	7u83	3826	`case e_rotate_right: {`
		3827	`exp p0;`
		3828	`exp p1;`
		3829	`p0 = hold_check(d_exp());`
		3830	`p1 = hold_check(d_exp());`
		3831	`return(f_rotate_right(p0, p1));`
2	7u83	3832	`}`
7	7u83	3833	`case e_sequence: {`
		3834	`exp_list p0;`
		3835	`exp p1;`
		3836	`p0 = d_exp_list();`
		3837	`p1 = hold_check(d_exp());`
		3838	`return(f_sequence(p0, p1));`
2	7u83	3839	`}`
7	7u83	3840	`case e_set_stack_limit: {`
		3841	`exp p0;`
		3842	`p0 = hold_check(d_exp());`
		3843	`return(f_set_stack_limit(p0));`
2	7u83	3844	`}`
7	7u83	3845	`case e_shape_offset: {`
		3846	`shape p0;`
		3847	`p0 = d_shape();`
		3848	`return(f_shape_offset(p0));`
2	7u83	3849	`}`
7	7u83	3850	`case e_shift_left: {`
		3851	`error_treatment p0;`
		3852	`exp p1;`
		3853	`exp p2;`
		3854	`p0 = d_error_treatment();`
		3855	`p1 = hold_check(d_exp());`
		3856	`p2 = hold_check(d_exp());`
		3857	`return(f_shift_left(p0, p1, p2));`
2	7u83	3858	`}`
7	7u83	3859	`case e_shift_right: {`
		3860	`exp p0;`
		3861	`exp p1;`
		3862	`p0 = hold_check(d_exp());`
		3863	`p1 = hold_check(d_exp());`
		3864	`return(f_shift_right(p0, p1));`
2	7u83	3865	`}`
7	7u83	3866	`case e_subtract_ptrs: {`
		3867	`exp p0;`
		3868	`exp p1;`
		3869	`p0 = hold_check(d_exp());`
		3870	`p1 = hold_check(d_exp());`
		3871	`return(f_subtract_ptrs(p0, p1));`
2	7u83	3872	`}`
7	7u83	3873	`case e_tail_call: {`
		3874	`procprops_option p0;`
		3875	`exp p1;`
		3876	`callees p2;`
		3877	`p0 = d_procprops_option();`
		3878	`p1 = hold_check(d_exp());`
		3879	`p2 = d_callees();`
		3880	`return(f_tail_call(p0, p1, p2));`
2	7u83	3881	`}`
7	7u83	3882	`case e_untidy_return: {`
		3883	`exp p0;`
		3884	`p0 = hold_check(d_exp());`
		3885	`return(f_untidy_return(p0));`
2	7u83	3886	`}`
7	7u83	3887	`case e_variable: {`
		3888	`access_option p0;`
		3889	`tag p1;`
		3890	`exp p2;`
		3891	`exp p3;`
		3892	`p0 = d_access_option();`
		3893	`p1 = d_tag();`
		3894	`p2 = hold_check(d_exp());`
		3895	`start_variable(p0, p1, p2);`
		3896	`p3 = hold_check(d_exp());`
		3897	`return(f_variable(p0, p1, p2, p3));`
2	7u83	3898	`}`
7	7u83	3899	`case e_xor: {`
		3900	`exp p0;`
		3901	`exp p1;`
		3902	`p0 = hold_check(d_exp());`
		3903	`p1 = hold_check(d_exp());`
		3904	`return(f_xor(p0, p1));`
2	7u83	3905	`}`
		3906	`}`
7	7u83	3907	`decode_error(ILLEGAL_CODE_exp);`
		3908	`return(f_dummy_exp);`
2	7u83	3909	`}`
		3910
		3911
		3912	`/* DECODE EXP_LIST */`
		3913
7	7u83	3914	`exp_list`
		3915	`d_exp_list(void)`
2	7u83	3916	`{`
7	7u83	3917	`int i, n;`
		3918	`exp_list temp;`
		3919	`IGNORE getcode(1);`
		3920	`n = small_dtdfint();`
		3921	`temp = new_exp_list(n);`
		3922	`for (i = 0; i < n; i++) {`
		3923	`exp e;`
		3924	`e = hold_check(d_exp());`
		3925	`temp = add_exp_list(temp, e, i);`
2	7u83	3926	`}`
7	7u83	3927	`return(temp);`
2	7u83	3928	`}`
		3929
		3930
		3931	`/* DECODE EXP_OPTION */`
		3932
7	7u83	3933	`exp_option`
		3934	`d_exp_option(void)`
2	7u83	3935	`{`
7	7u83	3936	`if (getcode(1)) {`
		3937	`exp e;`
		3938	`e = hold_check(d_exp());`
		3939	`return(yes_exp_option(e));`
2	7u83	3940	`}`
7	7u83	3941	`return(no_exp_option);`
2	7u83	3942	`}`
		3943
		3944
		3945	`/* DECODE EXTERN_LINK */`
		3946
7	7u83	3947	`extern_link`
		3948	`d_extern_link(void)`
2	7u83	3949	`{`
7	7u83	3950	`linkextern_list p0;`
		3951	`p0 = d_linkextern_list();`
		3952	`return(f_make_extern_link(p0));`
2	7u83	3953	`}`
		3954
		3955
		3956	`/* DECODE EXTERN_LINK_LIST */`
		3957
7	7u83	3958	`extern_link_list`
		3959	`d_extern_link_list(void)`
2	7u83	3960	`{`
7	7u83	3961	`int i, n;`
		3962	`extern_link_list temp;`
		3963	`n = small_dtdfint();`
		3964	`temp = new_extern_link_list(n);`
		3965	`for (i = 0; i < n; i++) {`
		3966	`extern_link e;`
		3967	`e = d_extern_link();`
		3968	`temp = add_extern_link_list(temp, e, i);`
2	7u83	3969	`}`
7	7u83	3970	`return(temp);`
2	7u83	3971	`}`
		3972
		3973
		3974	`/* DECODE EXTERNAL */`
		3975
7	7u83	3976	`external`
		3977	`d_external(void)`
2	7u83	3978	`{`
7	7u83	3979	`int code = get_big_code(2);`
		3980	`switch (code) {`
		3981	`case e_string_extern: {`
		3982	`tdfident p0;`
		3983	`to_boundary();`
		3984	`p0 = d_tdfident();`
		3985	`return(f_string_extern(p0));`
2	7u83	3986	`}`
7	7u83	3987	`case e_unique_extern: {`
		3988	`unique p0;`
		3989	`to_boundary();`
		3990	`p0 = d_unique();`
		3991	`return(f_unique_extern(p0));`
2	7u83	3992	`}`
7	7u83	3993	`case e_chain_extern: {`
		3994	`tdfident p0;`
		3995	`tdfint p1;`
		3996	`to_boundary();`
		3997	`p0 = d_tdfident();`
		3998	`p1 = d_tdfint();`
		3999	`return(f_chain_extern(p0, p1));`
2	7u83	4000	`}`
		4001	`}`
7	7u83	4002	`decode_error(ILLEGAL_CODE_external);`
		4003	`return(f_dummy_external);`
2	7u83	4004	`}`
		4005
		4006
		4007	`/* DECODE FILENAME */`
		4008
7	7u83	4009	`filename`
		4010	`d_filename(void)`
2	7u83	4011	`{`
7	7u83	4012	`int code = get_big_code(2);`
		4013	`switch (code) {`
		4014	`case e_filename_apply_token: {`
		4015	`token p0;`
		4016	`bitstream p1;`
		4017	`p0 = d_token();`
		4018	`p1 = d_bitstream();`
		4019	`return(f_filename_apply_token(p0, p1));`
2	7u83	4020	`}`
7	7u83	4021	`case e_make_filename: {`
		4022	`nat p0;`
		4023	`tdfstring p1;`
		4024	`tdfstring p2;`
		4025	`p0 = d_nat();`
		4026	`p1 = d_tdfstring();`
		4027	`p2 = d_tdfstring();`
		4028	`return(f_make_filename(p0, p1, p2));`
2	7u83	4029	`}`
		4030	`}`
7	7u83	4031	`decode_error(ILLEGAL_CODE_filename);`
		4032	`return(f_dummy_filename);`
2	7u83	4033	`}`
		4034
		4035
		4036	`/* DECODE FLOATING_VARIETY */`
		4037
7	7u83	4038	`floating_variety`
		4039	`d_floating_variety(void)`
2	7u83	4040	`{`
7	7u83	4041	`int code = get_big_code(3);`
		4042	`switch (code) {`
		4043	`case e_flvar_apply_token: {`
		4044	`token p0;`
		4045	`bitstream p1;`
		4046	`p0 = d_token();`
		4047	`p1 = d_bitstream();`
		4048	`return(f_flvar_apply_token(p0, p1));`
2	7u83	4049	`}`
7	7u83	4050	`case e_flvar_cond: {`
		4051	`exp p0;`
		4052	`bitstream p1;`
		4053	`bitstream p2;`
		4054	`p0 = hold_const_check(d_exp());`
		4055	`p1 = d_bitstream();`
		4056	`p2 = d_bitstream();`
		4057	`return(f_flvar_cond(p0, p1, p2));`
2	7u83	4058	`}`
7	7u83	4059	`case e_flvar_parms: {`
		4060	`nat p0;`
		4061	`nat p1;`
		4062	`nat p2;`
		4063	`nat p3;`
		4064	`p0 = d_nat();`
		4065	`p1 = d_nat();`
		4066	`p2 = d_nat();`
		4067	`p3 = d_nat();`
		4068	`return(f_flvar_parms(p0, p1, p2, p3));`
2	7u83	4069	`}`
7	7u83	4070	`case e_complex_parms: {`
		4071	`nat p0;`
		4072	`nat p1;`
		4073	`nat p2;`
		4074	`nat p3;`
		4075	`p0 = d_nat();`
		4076	`p1 = d_nat();`
		4077	`p2 = d_nat();`
		4078	`p3 = d_nat();`
		4079	`return(f_complex_parms(p0, p1, p2, p3));`
2	7u83	4080	`}`
7	7u83	4081	`case e_float_of_complex: {`
		4082	`shape p0;`
		4083	`p0 = d_shape();`
		4084	`return(f_float_of_complex(p0));`
2	7u83	4085	`}`
7	7u83	4086	`case e_complex_of_float: {`
		4087	`shape p0;`
		4088	`p0 = d_shape();`
		4089	`return(f_complex_of_float(p0));`
2	7u83	4090	`}`
		4091	`}`
7	7u83	4092	`decode_error(ILLEGAL_CODE_floating_variety);`
		4093	`return(f_dummy_floating_variety);`
2	7u83	4094	`}`
		4095
		4096
		4097	`/* DECODE GROUP */`
		4098
7	7u83	4099	`group`
		4100	`d_group(void)`
2	7u83	4101	`{`
7	7u83	4102	`unit_list p0;`
		4103	`p0 = d_unit_list();`
		4104	`return(f_make_group(p0));`
2	7u83	4105	`}`
		4106
		4107
		4108	`/* DECODE GROUP_LIST */`
		4109
7	7u83	4110	`group_list`
		4111	`d_group_list(void)`
2	7u83	4112	`{`
7	7u83	4113	`int i, n;`
		4114	`group_list temp;`
		4115	`n = small_dtdfint();`
		4116	`temp = new_group_list(n);`
		4117	`for (i = 0; i < n; i++) {`
		4118	`group e;`
		4119	`e = d_group();`
		4120	`temp = add_group_list(temp, e, i);`
2	7u83	4121	`}`
7	7u83	4122	`return(temp);`
2	7u83	4123	`}`
		4124
		4125
		4126	`/* DECODE LABEL */`
		4127
7	7u83	4128	`label`
		4129	`d_label(void)`
2	7u83	4130	`{`
7	7u83	4131	`int code = get_big_code(1);`
		4132	`switch (code) {`
		4133	`case e_label_apply_token: {`
		4134	`token p0;`
		4135	`bitstream p1;`
		4136	`p0 = d_token();`
		4137	`p1 = d_bitstream();`
		4138	`return(f_label_apply_token(p0, p1));`
2	7u83	4139	`}`
7	7u83	4140	`case e_make_label: {`
		4141	`tdfint p0;`
		4142	`p0 = d_tdfint();`
		4143	`return(f_make_label(p0));`
2	7u83	4144	`}`
		4145	`}`
7	7u83	4146	`decode_error(ILLEGAL_CODE_label);`
		4147	`return(f_dummy_label);`
2	7u83	4148	`}`
		4149
		4150
		4151	`/* DECODE LABEL_LIST */`
		4152
7	7u83	4153	`label_list`
		4154	`d_label_list(void)`
2	7u83	4155	`{`
7	7u83	4156	`int i, n;`
		4157	`label_list temp;`
		4158	`IGNORE getcode(1);`
		4159	`n = small_dtdfint();`
		4160	`temp = new_label_list(n);`
		4161	`for (i = 0; i < n; i++) {`
		4162	`label e;`
		4163	`e = d_label();`
		4164	`temp = add_label_list(temp, e, i);`
2	7u83	4165	`}`
7	7u83	4166	`return(temp);`
2	7u83	4167	`}`
		4168
		4169
		4170	`/* DECODE LINK */`
		4171
7	7u83	4172	`link`
		4173	`d_link(void)`
2	7u83	4174	`{`
7	7u83	4175	`tdfint p0;`
		4176	`tdfint p1;`
		4177	`p0 = d_tdfint();`
		4178	`p1 = d_tdfint();`
		4179	`return(f_make_link(p0, p1));`
2	7u83	4180	`}`
		4181
		4182
		4183	`/* DECODE LINK_LIST */`
		4184
7	7u83	4185	`link_list`
		4186	`d_link_list(void)`
2	7u83	4187	`{`
7	7u83	4188	`int i, n;`
		4189	`link_list temp;`
		4190	`n = small_dtdfint();`
		4191	`temp = new_link_list(n);`
		4192	`for (i = 0; i < n; i++) {`
		4193	`link e;`
		4194	`e = d_link();`
		4195	`temp = add_link_list(temp, e, i);`
2	7u83	4196	`}`
7	7u83	4197	`return(temp);`
2	7u83	4198	`}`
		4199
		4200
		4201	`/* DECODE LINKEXTERN */`
		4202
7	7u83	4203	`linkextern`
		4204	`d_linkextern(void)`
2	7u83	4205	`{`
7	7u83	4206	`tdfint p0;`
		4207	`external p1;`
		4208	`p0 = d_tdfint();`
		4209	`p1 = d_external();`
		4210	`return(f_make_linkextern(p0, p1));`
2	7u83	4211	`}`
		4212
		4213
		4214	`/* DECODE LINKEXTERN_LIST */`
		4215
7	7u83	4216	`linkextern_list`
		4217	`d_linkextern_list(void)`
2	7u83	4218	`{`
7	7u83	4219	`int i, n;`
		4220	`linkextern_list temp;`
		4221	`n = small_dtdfint();`
		4222	`temp = new_linkextern_list(n);`
		4223	`for (i = 0; i < n; i++) {`
		4224	`linkextern e;`
		4225	`e = d_linkextern();`
		4226	`temp = add_linkextern_list(temp, e, i);`
2	7u83	4227	`}`
7	7u83	4228	`return(temp);`
2	7u83	4229	`}`
		4230
		4231
		4232	`/* DECODE LINKINFO */`
		4233
7	7u83	4234	`linkinfo`
		4235	`d_linkinfo(void)`
2	7u83	4236	`{`
7	7u83	4237	`int code = get_big_code(2);`
		4238	`switch (code) {`
		4239	`case e_static_name_def: {`
		4240	`exp p0;`
		4241	`tdfstring p1;`
		4242	`p0 = hold_check(d_exp());`
		4243	`p1 = d_tdfstring();`
		4244	`return(f_static_name_def(p0, p1));`
2	7u83	4245	`}`
7	7u83	4246	`case e_make_comment: {`
		4247	`tdfstring p0;`
		4248	`p0 = d_tdfstring();`
		4249	`return(f_make_comment(p0));`
2	7u83	4250	`}`
7	7u83	4251	`case e_make_weak_defn: {`
		4252	`exp p0;`
		4253	`exp p1;`
		4254	`p0 = hold_check(d_exp());`
		4255	`p1 = hold_check(d_exp());`
		4256	`return(f_make_weak_defn(p0, p1));`
2	7u83	4257	`}`
7	7u83	4258	`case e_make_weak_symbol: {`
		4259	`tdfstring p0;`
		4260	`exp p1;`
		4261	`p0 = d_tdfstring();`
		4262	`p1 = hold_check(d_exp());`
		4263	`return(f_make_weak_symbol(p0, p1));`
2	7u83	4264	`}`
		4265	`}`
7	7u83	4266	`decode_error(ILLEGAL_CODE_linkinfo);`
		4267	`return(f_dummy_linkinfo);`
2	7u83	4268	`}`
		4269
		4270
		4271	`/* DECODE LINKINFO_LIST */`
		4272
7	7u83	4273	`linkinfo_list`
		4274	`d_linkinfo_list(void)`
2	7u83	4275	`{`
7	7u83	4276	`int i, n;`
		4277	`linkinfo_list temp;`
		4278	`n = small_dtdfint();`
		4279	`temp = new_linkinfo_list(n);`
		4280	`for (i = 0; i < n; i++) {`
		4281	`linkinfo e;`
		4282	`e = d_linkinfo();`
		4283	`temp = add_linkinfo_list(temp, e, i);`
2	7u83	4284	`}`
7	7u83	4285	`return(temp);`
2	7u83	4286	`}`
		4287
		4288
		4289	`/* DECODE LINKINFO_PROPS */`
		4290
7	7u83	4291	`linkinfo_props`
		4292	`d_linkinfo_props(void)`
2	7u83	4293	`{`
7	7u83	4294	`tdfint p0;`
		4295	`linkinfo_list p1;`
		4296	`p0 = d_tdfint();`
		4297	`p1 = d_linkinfo_list();`
		4298	`return(f_make_linkinfos(p0, p1));`
2	7u83	4299	`}`
		4300
		4301
		4302	`/* DECODE LINKS */`
		4303
7	7u83	4304	`links`
		4305	`d_links(void)`
2	7u83	4306	`{`
7	7u83	4307	`link_list p0;`
		4308	`p0 = d_link_list();`
		4309	`return(f_make_links(p0));`
2	7u83	4310	`}`
		4311
		4312
		4313	`/* DECODE LINKS_LIST */`
		4314
7	7u83	4315	`links_list`
		4316	`d_links_list(void)`
2	7u83	4317	`{`
7	7u83	4318	`int i, n;`
		4319	`links_list temp;`
		4320	`n = small_dtdfint();`
		4321	`temp = new_links_list(n);`
		4322	`for (i = 0; i < n; i++) {`
		4323	`links e;`
		4324	`e = d_links();`
		4325	`temp = add_links_list(temp, e, i);`
2	7u83	4326	`}`
7	7u83	4327	`return(temp);`
2	7u83	4328	`}`
		4329
		4330
		4331	`/* DECODE NAT */`
		4332
7	7u83	4333	`nat`
		4334	`d_nat(void)`
2	7u83	4335	`{`
7	7u83	4336	`int code = get_big_code(3);`
		4337	`switch (code) {`
		4338	`case e_nat_apply_token: {`
		4339	`token p0;`
		4340	`bitstream p1;`
		4341	`p0 = d_token();`
		4342	`p1 = d_bitstream();`
		4343	`return(f_nat_apply_token(p0, p1));`
2	7u83	4344	`}`
7	7u83	4345	`case e_nat_cond: {`
		4346	`exp p0;`
		4347	`bitstream p1;`
		4348	`bitstream p2;`
		4349	`p0 = hold_const_check(d_exp());`
		4350	`p1 = d_bitstream();`
		4351	`p2 = d_bitstream();`
		4352	`return(f_nat_cond(p0, p1, p2));`
2	7u83	4353	`}`
7	7u83	4354	`case e_computed_nat: {`
		4355	`exp p0;`
		4356	`p0 = hold_const_check(d_exp());`
		4357	`return(f_computed_nat(p0));`
2	7u83	4358	`}`
7	7u83	4359	`case e_error_val: {`
		4360	`error_code p0;`
		4361	`p0 = d_error_code();`
		4362	`return(f_error_val(p0));`
2	7u83	4363	`}`
7	7u83	4364	`case e_make_nat: {`
		4365	`tdfint p0;`
		4366	`p0 = d_tdfint();`
		4367	`return(f_make_nat(p0));`
2	7u83	4368	`}`
		4369	`}`
7	7u83	4370	`decode_error(ILLEGAL_CODE_nat);`
		4371	`return(f_dummy_nat);`
2	7u83	4372	`}`
		4373
		4374
		4375	`/* DECODE NAT_OPTION */`
		4376
7	7u83	4377	`nat_option`
		4378	`d_nat_option(void)`
2	7u83	4379	`{`
7	7u83	4380	`if (getcode(1)) {`
		4381	`nat e;`
		4382	`e = d_nat();`
		4383	`return(yes_nat_option(e));`
2	7u83	4384	`}`
7	7u83	4385	`return(no_nat_option);`
2	7u83	4386	`}`
		4387
		4388
		4389	`/* DECODE NTEST */`
		4390
7	7u83	4391	`ntest`
		4392	`d_ntest(void)`
2	7u83	4393	`{`
7	7u83	4394	`int code = get_big_code(4);`
		4395	`switch (code) {`
		4396	`case e_ntest_apply_token: {`
		4397	`token p0;`
		4398	`bitstream p1;`
		4399	`p0 = d_token();`
		4400	`p1 = d_bitstream();`
		4401	`return(f_ntest_apply_token(p0, p1));`
2	7u83	4402	`}`
7	7u83	4403	`case e_ntest_cond: {`
		4404	`exp p0;`
		4405	`bitstream p1;`
		4406	`bitstream p2;`
		4407	`p0 = hold_const_check(d_exp());`
		4408	`p1 = d_bitstream();`
		4409	`p2 = d_bitstream();`
		4410	`return(f_ntest_cond(p0, p1, p2));`
2	7u83	4411	`}`
7	7u83	4412	`case e_equal: {`
		4413	`return(f_equal);`
2	7u83	4414	`}`
7	7u83	4415	`case e_greater_than: {`
		4416	`return(f_greater_than);`
2	7u83	4417	`}`
7	7u83	4418	`case e_greater_than_or_equal: {`
		4419	`return(f_greater_than_or_equal);`
2	7u83	4420	`}`
7	7u83	4421	`case e_less_than: {`
		4422	`return(f_less_than);`
2	7u83	4423	`}`
7	7u83	4424	`case e_less_than_or_equal: {`
		4425	`return(f_less_than_or_equal);`
2	7u83	4426	`}`
7	7u83	4427	`case e_not_equal: {`
		4428	`return(f_not_equal);`
2	7u83	4429	`}`
7	7u83	4430	`case e_not_greater_than: {`
		4431	`return(f_not_greater_than);`
2	7u83	4432	`}`
7	7u83	4433	`case e_not_greater_than_or_equal: {`
		4434	`return(f_not_greater_than_or_equal);`
2	7u83	4435	`}`
7	7u83	4436	`case e_not_less_than: {`
		4437	`return(f_not_less_than);`
2	7u83	4438	`}`
7	7u83	4439	`case e_not_less_than_or_equal: {`
		4440	`return(f_not_less_than_or_equal);`
2	7u83	4441	`}`
7	7u83	4442	`case e_less_than_or_greater_than: {`
		4443	`return(f_less_than_or_greater_than);`
2	7u83	4444	`}`
7	7u83	4445	`case e_not_less_than_and_not_greater_than: {`
		4446	`return(f_not_less_than_and_not_greater_than);`
2	7u83	4447	`}`
7	7u83	4448	`case e_comparable: {`
		4449	`return(f_comparable);`
2	7u83	4450	`}`
7	7u83	4451	`case e_not_comparable: {`
		4452	`return(f_not_comparable);`
2	7u83	4453	`}`
		4454	`}`
7	7u83	4455	`decode_error(ILLEGAL_CODE_ntest);`
		4456	`return(f_dummy_ntest);`
2	7u83	4457	`}`
		4458
		4459
		4460	`/* DECODE OTAGEXP */`
		4461
7	7u83	4462	`otagexp`
		4463	`d_otagexp(void)`
2	7u83	4464	`{`
7	7u83	4465	`tag_option p0;`
		4466	`exp p1;`
		4467	`p0 = d_tag_option();`
		4468	`p1 = hold_check(d_exp());`
		4469	`return(f_make_otagexp(p0, p1));`
2	7u83	4470	`}`
		4471
		4472
		4473	`/* DECODE OTAGEXP_LIST */`
		4474
7	7u83	4475	`otagexp_list`
		4476	`d_otagexp_list(void)`
2	7u83	4477	`{`
7	7u83	4478	`int i, n;`
		4479	`otagexp_list temp;`
		4480	`IGNORE getcode(1);`
		4481	`n = small_dtdfint();`
		4482	`temp = new_otagexp_list(n);`
		4483	`for (i = 0; i < n; i++) {`
		4484	`otagexp e;`
		4485	`e = d_otagexp();`
		4486	`temp = add_otagexp_list(temp, e, i);`
2	7u83	4487	`}`
7	7u83	4488	`return(temp);`
2	7u83	4489	`}`
		4490
		4491
		4492	`/* DECODE PROCPROPS */`
		4493
7	7u83	4494	`procprops`
		4495	`d_procprops(void)`
2	7u83	4496	`{`
7	7u83	4497	`int code = get_big_code(4);`
		4498	`switch (code) {`
		4499	`case e_procprops_apply_token: {`
		4500	`token p0;`
		4501	`bitstream p1;`
		4502	`p0 = d_token();`
		4503	`p1 = d_bitstream();`
		4504	`return(f_procprops_apply_token(p0, p1));`
2	7u83	4505	`}`
7	7u83	4506	`case e_procprops_cond: {`
		4507	`exp p0;`
		4508	`bitstream p1;`
		4509	`bitstream p2;`
		4510	`p0 = hold_const_check(d_exp());`
		4511	`p1 = d_bitstream();`
		4512	`p2 = d_bitstream();`
		4513	`return(f_procprops_cond(p0, p1, p2));`
2	7u83	4514	`}`
7	7u83	4515	`case e_add_procprops: {`
		4516	`procprops p0;`
		4517	`procprops p1;`
		4518	`p0 = d_procprops();`
		4519	`p1 = d_procprops();`
		4520	`return(f_add_procprops(p0, p1));`
2	7u83	4521	`}`
7	7u83	4522	`case e_check_stack: {`
		4523	`return(f_check_stack);`
2	7u83	4524	`}`
7	7u83	4525	`case e_inline: {`
		4526	`return(f_inline);`
2	7u83	4527	`}`
7	7u83	4528	`case e_no_long_jump_dest: {`
		4529	`return(f_no_long_jump_dest);`
2	7u83	4530	`}`
7	7u83	4531	`case e_untidy: {`
		4532	`return(f_untidy);`
2	7u83	4533	`}`
7	7u83	4534	`case e_var_callees: {`
		4535	`return(f_var_callees);`
2	7u83	4536	`}`
7	7u83	4537	`case e_var_callers: {`
		4538	`return(f_var_callers);`
2	7u83	4539	`}`
		4540	`}`
7	7u83	4541	`decode_error(ILLEGAL_CODE_procprops);`
		4542	`return(f_dummy_procprops);`
2	7u83	4543	`}`
		4544
		4545
		4546	`/* DECODE PROCPROPS_OPTION */`
		4547
7	7u83	4548	`procprops_option`
		4549	`d_procprops_option(void)`
2	7u83	4550	`{`
7	7u83	4551	`if (getcode(1)) {`
		4552	`procprops e;`
		4553	`e = d_procprops();`
		4554	`return(yes_procprops_option(e));`
2	7u83	4555	`}`
7	7u83	4556	`return(no_procprops_option);`
2	7u83	4557	`}`
		4558
		4559
		4560	`/* DECODE ROUNDING_MODE */`
		4561
7	7u83	4562	`rounding_mode`
		4563	`d_rounding_mode(void)`
2	7u83	4564	`{`
7	7u83	4565	`int code = get_big_code(3);`
		4566	`switch (code) {`
		4567	`case e_rounding_mode_apply_token: {`
		4568	`token p0;`
		4569	`bitstream p1;`
		4570	`p0 = d_token();`
		4571	`p1 = d_bitstream();`
		4572	`return(f_rounding_mode_apply_token(p0, p1));`
2	7u83	4573	`}`
7	7u83	4574	`case e_rounding_mode_cond: {`
		4575	`exp p0;`
		4576	`bitstream p1;`
		4577	`bitstream p2;`
		4578	`p0 = hold_const_check(d_exp());`
		4579	`p1 = d_bitstream();`
		4580	`p2 = d_bitstream();`
		4581	`return(f_rounding_mode_cond(p0, p1, p2));`
2	7u83	4582	`}`
7	7u83	4583	`case e_round_as_state: {`
		4584	`return(f_round_as_state);`
2	7u83	4585	`}`
7	7u83	4586	`case e_to_nearest: {`
		4587	`return(f_to_nearest);`
2	7u83	4588	`}`
7	7u83	4589	`case e_toward_larger: {`
		4590	`return(f_toward_larger);`
2	7u83	4591	`}`
7	7u83	4592	`case e_toward_smaller: {`
		4593	`return(f_toward_smaller);`
2	7u83	4594	`}`
7	7u83	4595	`case e_toward_zero: {`
		4596	`return(f_toward_zero);`
2	7u83	4597	`}`
		4598	`}`
7	7u83	4599	`decode_error(ILLEGAL_CODE_rounding_mode);`
		4600	`return(f_dummy_rounding_mode);`
2	7u83	4601	`}`
		4602
		4603
		4604	`/* DECODE SHAPE */`
		4605
7	7u83	4606	`shape`
		4607	`d_shape(void)`
2	7u83	4608	`{`
7	7u83	4609	`int code = get_big_code(4);`
		4610	`switch (code) {`
		4611	`case e_shape_apply_token: {`
		4612	`token p0;`
		4613	`bitstream p1;`
		4614	`p0 = d_token();`
		4615	`p1 = d_bitstream();`
		4616	`return(f_shape_apply_token(p0, p1));`
2	7u83	4617	`}`
7	7u83	4618	`case e_shape_cond: {`
		4619	`exp p0;`
		4620	`bitstream p1;`
		4621	`bitstream p2;`
		4622	`p0 = hold_const_check(d_exp());`
		4623	`p1 = d_bitstream();`
		4624	`p2 = d_bitstream();`
		4625	`return(f_shape_cond(p0, p1, p2));`
2	7u83	4626	`}`
7	7u83	4627	`case e_bitfield: {`
		4628	`bitfield_variety p0;`
		4629	`p0 = d_bitfield_variety();`
		4630	`return(f_bitfield(p0));`
2	7u83	4631	`}`
7	7u83	4632	`case e_bottom: {`
		4633	`return(f_bottom);`
2	7u83	4634	`}`
7	7u83	4635	`case e_compound: {`
		4636	`exp p0;`
		4637	`p0 = hold_check(d_exp());`
		4638	`return(f_compound(p0));`
2	7u83	4639	`}`
7	7u83	4640	`case e_floating: {`
		4641	`floating_variety p0;`
		4642	`p0 = d_floating_variety();`
		4643	`return(f_floating(p0));`
2	7u83	4644	`}`
7	7u83	4645	`case e_integer: {`
		4646	`variety p0;`
		4647	`p0 = d_variety();`
		4648	`return(f_integer(p0));`
2	7u83	4649	`}`
7	7u83	4650	`case e_nof: {`
		4651	`nat p0;`
		4652	`shape p1;`
		4653	`p0 = d_nat();`
		4654	`p1 = d_shape();`
		4655	`return(f_nof(p0, p1));`
2	7u83	4656	`}`
7	7u83	4657	`case e_offset: {`
		4658	`alignment p0;`
		4659	`alignment p1;`
		4660	`p0 = d_alignment();`
		4661	`p1 = d_alignment();`
		4662	`return(f_offset(p0, p1));`
2	7u83	4663	`}`
7	7u83	4664	`case e_pointer: {`
		4665	`alignment p0;`
		4666	`p0 = d_alignment();`
		4667	`return(f_pointer(p0));`
2	7u83	4668	`}`
7	7u83	4669	`case e_proc: {`
		4670	`return(f_proc);`
2	7u83	4671	`}`
7	7u83	4672	`case e_top: {`
		4673	`return(f_top);`
2	7u83	4674	`}`
		4675	`}`
7	7u83	4676	`decode_error(ILLEGAL_CODE_shape);`
		4677	`return(f_dummy_shape);`
2	7u83	4678	`}`
		4679
		4680
		4681	`/* DECODE SHAPE_OPTION */`
		4682
7	7u83	4683	`shape_option`
		4684	`d_shape_option(void)`
2	7u83	4685	`{`
7	7u83	4686	`if (getcode(1)) {`
		4687	`shape e;`
		4688	`e = d_shape();`
		4689	`return(yes_shape_option(e));`
2	7u83	4690	`}`
7	7u83	4691	`return(no_shape_option);`
2	7u83	4692	`}`
		4693
		4694
		4695	`/* DECODE SIGNED_NAT */`
		4696
7	7u83	4697	`signed_nat`
		4698	`d_signed_nat(void)`
2	7u83	4699	`{`
7	7u83	4700	`int code = get_big_code(3);`
		4701	`switch (code) {`
		4702	`case e_signed_nat_apply_token: {`
		4703	`token p0;`
		4704	`bitstream p1;`
		4705	`p0 = d_token();`
		4706	`p1 = d_bitstream();`
		4707	`return(f_signed_nat_apply_token(p0, p1));`
2	7u83	4708	`}`
7	7u83	4709	`case e_signed_nat_cond: {`
		4710	`exp p0;`
		4711	`bitstream p1;`
		4712	`bitstream p2;`
		4713	`p0 = hold_const_check(d_exp());`
		4714	`p1 = d_bitstream();`
		4715	`p2 = d_bitstream();`
		4716	`return(f_signed_nat_cond(p0, p1, p2));`
2	7u83	4717	`}`
7	7u83	4718	`case e_computed_signed_nat: {`
		4719	`exp p0;`
		4720	`p0 = hold_const_check(d_exp());`
		4721	`return(f_computed_signed_nat(p0));`
2	7u83	4722	`}`
7	7u83	4723	`case e_make_signed_nat: {`
		4724	`tdfbool p0;`
		4725	`tdfint p1;`
		4726	`p0 = d_tdfbool();`
		4727	`p1 = d_tdfint();`
		4728	`return(f_make_signed_nat(p0, p1));`
2	7u83	4729	`}`
7	7u83	4730	`case e_snat_from_nat: {`
		4731	`bool p0;`
		4732	`nat p1;`
		4733	`p0 = d_bool();`
		4734	`p1 = d_nat();`
		4735	`return(f_snat_from_nat(p0, p1));`
2	7u83	4736	`}`
		4737	`}`
7	7u83	4738	`decode_error(ILLEGAL_CODE_signed_nat);`
		4739	`return(f_dummy_signed_nat);`
2	7u83	4740	`}`
		4741
		4742
		4743	`/* DECODE SORTNAME */`
		4744
7	7u83	4745	`sortname`
		4746	`d_sortname(void)`
2	7u83	4747	`{`
7	7u83	4748	`int code = get_big_code(5);`
		4749	`switch (code) {`
		4750	`case e_access: {`
		4751	`return(f_access);`
2	7u83	4752	`}`
7	7u83	4753	`case e_al_tag: {`
		4754	`return(f_al_tag);`
2	7u83	4755	`}`
7	7u83	4756	`case e_alignment_sort: {`
		4757	`return(f_alignment_sort);`
2	7u83	4758	`}`
7	7u83	4759	`case e_bitfield_variety: {`
		4760	`return(f_bitfield_variety);`
2	7u83	4761	`}`
7	7u83	4762	`case e_bool: {`
		4763	`return(f_bool);`
2	7u83	4764	`}`
7	7u83	4765	`case e_error_treatment: {`
		4766	`return(f_error_treatment);`
2	7u83	4767	`}`
7	7u83	4768	`case e_exp: {`
		4769	`return(f_exp);`
2	7u83	4770	`}`
7	7u83	4771	`case e_floating_variety: {`
		4772	`return(f_floating_variety);`
2	7u83	4773	`}`
7	7u83	4774	`case e_foreign_sort: {`
		4775	`string p0;`
		4776	`p0 = d_string();`
		4777	`return(f_foreign_sort(p0));`
2	7u83	4778	`}`
7	7u83	4779	`case e_label: {`
		4780	`return(f_label);`
2	7u83	4781	`}`
7	7u83	4782	`case e_nat: {`
		4783	`return(f_nat);`
2	7u83	4784	`}`
7	7u83	4785	`case e_ntest: {`
		4786	`return(f_ntest);`
2	7u83	4787	`}`
7	7u83	4788	`case e_procprops: {`
		4789	`return(f_procprops);`
2	7u83	4790	`}`
7	7u83	4791	`case e_rounding_mode: {`
		4792	`return(f_rounding_mode);`
2	7u83	4793	`}`
7	7u83	4794	`case e_shape: {`
		4795	`return(f_shape);`
2	7u83	4796	`}`
7	7u83	4797	`case e_signed_nat: {`
		4798	`return(f_signed_nat);`
2	7u83	4799	`}`
7	7u83	4800	`case e_string: {`
		4801	`return(f_string);`
2	7u83	4802	`}`
7	7u83	4803	`case e_tag: {`
		4804	`return(f_tag);`
2	7u83	4805	`}`
7	7u83	4806	`case e_transfer_mode: {`
		4807	`return(f_transfer_mode);`
2	7u83	4808	`}`
7	7u83	4809	`case e_token: {`
		4810	`sortname p0;`
		4811	`sortname_list p1;`
		4812	`p0 = d_sortname();`
		4813	`p1 = d_sortname_list();`
		4814	`return(f_token(p0, p1));`
2	7u83	4815	`}`
7	7u83	4816	`case e_variety: {`
		4817	`return(f_variety);`
2	7u83	4818	`}`
		4819	`}`
7	7u83	4820	`decode_error(ILLEGAL_CODE_sortname);`
		4821	`return(f_dummy_sortname);`
2	7u83	4822	`}`
		4823
		4824
		4825	`/* DECODE SORTNAME_LIST */`
		4826
7	7u83	4827	`sortname_list`
		4828	`d_sortname_list(void)`
2	7u83	4829	`{`
7	7u83	4830	`int i, n;`
		4831	`sortname_list temp;`
		4832	`IGNORE getcode(1);`
		4833	`n = small_dtdfint();`
		4834	`temp = new_sortname_list(n);`
		4835	`for (i = 0; i < n; i++) {`
		4836	`sortname e;`
		4837	`e = d_sortname();`
		4838	`temp = add_sortname_list(temp, e, i);`
2	7u83	4839	`}`
7	7u83	4840	`return(temp);`
2	7u83	4841	`}`
		4842
		4843
		4844	`/* DECODE SOURCEMARK */`
		4845
7	7u83	4846	`sourcemark`
		4847	`d_sourcemark(void)`
2	7u83	4848	`{`
7	7u83	4849	`int code = get_big_code(1);`
		4850	`switch (code) {`
		4851	`case e_make_sourcemark: {`
		4852	`filename p0;`
		4853	`nat p1;`
		4854	`nat p2;`
		4855	`p0 = d_filename();`
		4856	`p1 = d_nat();`
		4857	`p2 = d_nat();`
		4858	`return(f_make_sourcemark(p0, p1, p2));`
2	7u83	4859	`}`
		4860	`}`
7	7u83	4861	`decode_error(ILLEGAL_CODE_sourcemark);`
		4862	`return(f_dummy_sourcemark);`
2	7u83	4863	`}`
		4864
		4865
		4866	`/* DECODE STRING */`
		4867
7	7u83	4868	`string`
		4869	`d_string(void)`
2	7u83	4870	`{`
7	7u83	4871	`int code = get_big_code(3);`
		4872	`switch (code) {`
		4873	`case e_string_apply_token: {`
		4874	`token p0;`
		4875	`bitstream p1;`
		4876	`p0 = d_token();`
		4877	`p1 = d_bitstream();`
		4878	`return(f_string_apply_token(p0, p1));`
2	7u83	4879	`}`
7	7u83	4880	`case e_string_cond: {`
		4881	`exp p0;`
		4882	`bitstream p1;`
		4883	`bitstream p2;`
		4884	`p0 = hold_const_check(d_exp());`
		4885	`p1 = d_bitstream();`
		4886	`p2 = d_bitstream();`
		4887	`return(f_string_cond(p0, p1, p2));`
2	7u83	4888	`}`
7	7u83	4889	`case e_concat_string: {`
		4890	`string p0;`
		4891	`string p1;`
		4892	`p0 = d_string();`
		4893	`p1 = d_string();`
		4894	`return(f_concat_string(p0, p1));`
2	7u83	4895	`}`
7	7u83	4896	`case e_make_string: {`
		4897	`tdfstring p0;`
		4898	`p0 = d_tdfstring();`
		4899	`return(f_make_string(p0));`
2	7u83	4900	`}`
		4901	`}`
7	7u83	4902	`decode_error(ILLEGAL_CODE_string);`
		4903	`return(f_dummy_string);`
2	7u83	4904	`}`
		4905
		4906
		4907	`/* DECODE STRING_LIST */`
		4908
7	7u83	4909	`string_list`
		4910	`d_string_list(void)`
2	7u83	4911	`{`
7	7u83	4912	`int i, n;`
		4913	`string_list temp;`
		4914	`IGNORE getcode(1);`
		4915	`n = small_dtdfint();`
		4916	`temp = new_string_list(n);`
		4917	`for (i = 0; i < n; i++) {`
		4918	`string e;`
		4919	`e = d_string();`
		4920	`temp = add_string_list(temp, e, i);`
2	7u83	4921	`}`
7	7u83	4922	`return(temp);`
2	7u83	4923	`}`
		4924
		4925
		4926	`/* DECODE STRING_OPTION */`
		4927
7	7u83	4928	`string_option`
		4929	`d_string_option(void)`
2	7u83	4930	`{`
7	7u83	4931	`if (getcode(1)) {`
		4932	`string e;`
		4933	`e = d_string();`
		4934	`return(yes_string_option(e));`
2	7u83	4935	`}`
7	7u83	4936	`return(no_string_option);`
2	7u83	4937	`}`
		4938
		4939
		4940	`/* DECODE TAG */`
		4941
7	7u83	4942	`tag`
		4943	`d_tag(void)`
2	7u83	4944	`{`
7	7u83	4945	`int code = get_big_code(1);`
		4946	`switch (code) {`
		4947	`case e_tag_apply_token: {`
		4948	`token p0;`
		4949	`bitstream p1;`
		4950	`p0 = d_token();`
		4951	`p1 = d_bitstream();`
		4952	`return(f_tag_apply_token(p0, p1));`
2	7u83	4953	`}`
7	7u83	4954	`case e_make_tag: {`
		4955	`tdfint p0;`
		4956	`p0 = d_tdfint();`
		4957	`return(f_make_tag(p0));`
2	7u83	4958	`}`
		4959	`}`
7	7u83	4960	`decode_error(ILLEGAL_CODE_tag);`
		4961	`return(f_dummy_tag);`
2	7u83	4962	`}`
		4963
		4964
		4965	`/* DECODE TAG_OPTION */`
		4966
7	7u83	4967	`tag_option`
		4968	`d_tag_option(void)`
2	7u83	4969	`{`
7	7u83	4970	`if (getcode(1)) {`
		4971	`tag e;`
		4972	`e = d_tag();`
		4973	`return(yes_tag_option(e));`
2	7u83	4974	`}`
7	7u83	4975	`return(no_tag_option);`
2	7u83	4976	`}`
		4977
		4978
		4979	`/* DECODE TAGACC */`
		4980
7	7u83	4981	`tagacc`
		4982	`d_tagacc(void)`
2	7u83	4983	`{`
7	7u83	4984	`tag p0;`
		4985	`access_option p1;`
		4986	`p0 = d_tag();`
		4987	`p1 = d_access_option();`
		4988	`return(f_make_tagacc(p0, p1));`
2	7u83	4989	`}`
		4990
		4991
		4992	`/* DECODE TAGACC_OPTION */`
		4993
7	7u83	4994	`tagacc_option`
		4995	`d_tagacc_option(void)`
2	7u83	4996	`{`
7	7u83	4997	`if (getcode(1)) {`
		4998	`tagacc e;`
		4999	`e = d_tagacc();`
		5000	`return(yes_tagacc_option(e));`
2	7u83	5001	`}`
7	7u83	5002	`return(no_tagacc_option);`
2	7u83	5003	`}`
		5004
		5005
		5006	`/* DECODE TAGDEC */`
		5007
7	7u83	5008	`tagdec`
		5009	`d_tagdec(void)`
2	7u83	5010	`{`
7	7u83	5011	`int code = get_big_code(2);`
		5012	`switch (code) {`
		5013	`case e_make_id_tagdec: {`
		5014	`tdfint p0;`
		5015	`access_option p1;`
		5016	`string_option p2;`
		5017	`shape p3;`
		5018	`p0 = d_tdfint();`
		5019	`p1 = d_access_option();`
		5020	`p2 = d_string_option();`
		5021	`p3 = d_shape();`
		5022	`return(f_make_id_tagdec(p0, p1, p2, p3));`
2	7u83	5023	`}`
7	7u83	5024	`case e_make_var_tagdec: {`
		5025	`tdfint p0;`
		5026	`access_option p1;`
		5027	`string_option p2;`
		5028	`shape p3;`
		5029	`p0 = d_tdfint();`
		5030	`p1 = d_access_option();`
		5031	`p2 = d_string_option();`
		5032	`p3 = d_shape();`
		5033	`return(f_make_var_tagdec(p0, p1, p2, p3));`
2	7u83	5034	`}`
7	7u83	5035	`case e_common_tagdec: {`
		5036	`tdfint p0;`
		5037	`access_option p1;`
		5038	`string_option p2;`
		5039	`shape p3;`
		5040	`p0 = d_tdfint();`
		5041	`p1 = d_access_option();`
		5042	`p2 = d_string_option();`
		5043	`p3 = d_shape();`
		5044	`return(f_common_tagdec(p0, p1, p2, p3));`
2	7u83	5045	`}`
		5046	`}`
7	7u83	5047	`decode_error(ILLEGAL_CODE_tagdec);`
		5048	`return(f_dummy_tagdec);`
2	7u83	5049	`}`
		5050
		5051
		5052	`/* DECODE TAGDEC_LIST */`
		5053
7	7u83	5054	`tagdec_list`
		5055	`d_tagdec_list(void)`
2	7u83	5056	`{`
7	7u83	5057	`int i, n;`
		5058	`tagdec_list temp;`
		5059	`n = small_dtdfint();`
		5060	`temp = new_tagdec_list(n);`
		5061	`for (i = 0; i < n; i++) {`
		5062	`tagdec e;`
		5063	`e = d_tagdec();`
		5064	`temp = add_tagdec_list(temp, e, i);`
2	7u83	5065	`}`
7	7u83	5066	`return(temp);`
2	7u83	5067	`}`
		5068
		5069
		5070	`/* DECODE TAGDEC_PROPS */`
		5071
7	7u83	5072	`tagdec_props`
		5073	`d_tagdec_props(void)`
2	7u83	5074	`{`
7	7u83	5075	`tdfint p0;`
		5076	`tagdec_list p1;`
		5077	`p0 = d_tdfint();`
		5078	`p1 = d_tagdec_list();`
		5079	`return(f_make_tagdecs(p0, p1));`
2	7u83	5080	`}`
		5081
		5082
		5083	`/* DECODE TAGDEF */`
		5084
7	7u83	5085	`tagdef`
		5086	`d_tagdef(void)`
2	7u83	5087	`{`
7	7u83	5088	`int code = get_big_code(2);`
		5089	`switch (code) {`
		5090	`case e_make_id_tagdef: {`
		5091	`tdfint p0;`
		5092	`string_option p1;`
		5093	`exp p2;`
		5094	`p0 = d_tdfint();`
		5095	`start_make_id_tagdef(p0);`
		5096	`p1 = d_string_option();`
		5097	`p2 = hold_check(d_exp());`
		5098	`return(f_make_id_tagdef(p0, p1, p2));`
2	7u83	5099	`}`
7	7u83	5100	`case e_make_var_tagdef: {`
		5101	`tdfint p0;`
		5102	`access_option p1;`
		5103	`string_option p2;`
		5104	`exp p3;`
		5105	`p0 = d_tdfint();`
		5106	`start_make_var_tagdef(p0);`
		5107	`p1 = d_access_option();`
		5108	`p2 = d_string_option();`
		5109	`p3 = hold_const_check(d_exp());`
		5110	`return(f_make_var_tagdef(p0, p1, p2, p3));`
2	7u83	5111	`}`
7	7u83	5112	`case e_common_tagdef: {`
		5113	`tdfint p0;`
		5114	`access_option p1;`
		5115	`string_option p2;`
		5116	`exp p3;`
		5117	`p0 = d_tdfint();`
		5118	`start_common_tagdef(p0);`
		5119	`p1 = d_access_option();`
		5120	`p2 = d_string_option();`
		5121	`p3 = hold_const_check(d_exp());`
		5122	`return(f_common_tagdef(p0, p1, p2, p3));`
2	7u83	5123	`}`
		5124	`}`
7	7u83	5125	`decode_error(ILLEGAL_CODE_tagdef);`
		5126	`return(f_dummy_tagdef);`
2	7u83	5127	`}`
		5128
		5129
		5130	`/* DECODE TAGDEF_LIST */`
		5131
7	7u83	5132	`tagdef_list`
		5133	`d_tagdef_list(void)`
2	7u83	5134	`{`
7	7u83	5135	`int i, n;`
		5136	`tagdef_list temp;`
		5137	`n = small_dtdfint();`
		5138	`temp = new_tagdef_list(n);`
		5139	`for (i = 0; i < n; i++) {`
		5140	`tagdef e;`
		5141	`e = d_tagdef();`
		5142	`temp = add_tagdef_list(temp, e, i);`
2	7u83	5143	`}`
7	7u83	5144	`return(temp);`
2	7u83	5145	`}`
		5146
		5147
		5148	`/* DECODE TAGDEF_PROPS */`
		5149
7	7u83	5150	`tagdef_props`
		5151	`d_tagdef_props(void)`
2	7u83	5152	`{`
7	7u83	5153	`tdfint p0;`
		5154	`tagdef_list p1;`
		5155	`p0 = d_tdfint();`
		5156	`p1 = d_tagdef_list();`
		5157	`return(f_make_tagdefs(p0, p1));`
2	7u83	5158	`}`
		5159
		5160
		5161	`/* DECODE TAGSHACC */`
		5162
7	7u83	5163	`tagshacc`
		5164	`d_tagshacc(void)`
2	7u83	5165	`{`
7	7u83	5166	`shape p0;`
		5167	`access_option p1;`
		5168	`tag p2;`
		5169	`p0 = d_shape();`
		5170	`p1 = d_access_option();`
		5171	`p2 = d_tag();`
		5172	`return(f_make_tagshacc(p0, p1, p2));`
2	7u83	5173	`}`
		5174
		5175
		5176	`/* DECODE TAGSHACC_LIST */`
		5177
7	7u83	5178	`tagshacc_list`
		5179	`d_tagshacc_list(void)`
2	7u83	5180	`{`
7	7u83	5181	`int i, n;`
		5182	`tagshacc_list temp;`
		5183	`IGNORE getcode(1);`
		5184	`n = small_dtdfint();`
		5185	`temp = new_tagshacc_list(n);`
		5186	`for (i = 0; i < n; i++) {`
		5187	`tagshacc e;`
		5188	`e = d_tagshacc();`
		5189	`temp = add_tagshacc_list(temp, e, i);`
2	7u83	5190	`}`
7	7u83	5191	`return(temp);`
2	7u83	5192	`}`
		5193
		5194
		5195	`/* DECODE TDFIDENT_LIST */`
		5196
7	7u83	5197	`tdfident_list`
		5198	`d_tdfident_list(void)`
2	7u83	5199	`{`
7	7u83	5200	`int i, n;`
		5201	`tdfident_list temp;`
		5202	`n = small_dtdfint();`
		5203	`temp = new_tdfident_list(n);`
		5204	`for (i = 0; i < n; i++) {`
		5205	`tdfident e;`
		5206	`e = d_tdfident();`
		5207	`temp = add_tdfident_list(temp, e, i);`
2	7u83	5208	`}`
7	7u83	5209	`return(temp);`
2	7u83	5210	`}`
		5211
		5212
		5213	`/* DECODE TDFINT_LIST */`
		5214
7	7u83	5215	`tdfint_list`
		5216	`d_tdfint_list(void)`
2	7u83	5217	`{`
7	7u83	5218	`int i, n;`
		5219	`tdfint_list temp;`
		5220	`n = small_dtdfint();`
		5221	`temp = new_tdfint_list(n);`
		5222	`for (i = 0; i < n; i++) {`
		5223	`tdfint e;`
		5224	`e = d_tdfint();`
		5225	`temp = add_tdfint_list(temp, e, i);`
2	7u83	5226	`}`
7	7u83	5227	`return(temp);`
2	7u83	5228	`}`
		5229
		5230
		5231	`/* DECODE TOKDEC */`
		5232
7	7u83	5233	`tokdec`
		5234	`d_tokdec(void)`
2	7u83	5235	`{`
7	7u83	5236	`int code = get_big_code(1);`
		5237	`switch (code) {`
		5238	`case e_make_tokdec: {`
		5239	`tdfint p0;`
		5240	`string_option p1;`
		5241	`sortname p2;`
		5242	`p0 = d_tdfint();`
		5243	`p1 = d_string_option();`
		5244	`p2 = d_sortname();`
		5245	`return(f_make_tokdec(p0, p1, p2));`
2	7u83	5246	`}`
		5247	`}`
7	7u83	5248	`decode_error(ILLEGAL_CODE_tokdec);`
		5249	`return(f_dummy_tokdec);`
2	7u83	5250	`}`
		5251
		5252
		5253	`/* DECODE TOKDEC_LIST */`
		5254
7	7u83	5255	`tokdec_list`
		5256	`d_tokdec_list(void)`
2	7u83	5257	`{`
7	7u83	5258	`int i, n;`
		5259	`tokdec_list temp;`
		5260	`n = small_dtdfint();`
		5261	`temp = new_tokdec_list(n);`
		5262	`for (i = 0; i < n; i++) {`
		5263	`tokdec e;`
		5264	`e = d_tokdec();`
		5265	`temp = add_tokdec_list(temp, e, i);`
2	7u83	5266	`}`
7	7u83	5267	`return(temp);`
2	7u83	5268	`}`
		5269
		5270
		5271	`/* DECODE TOKDEC_PROPS */`
		5272
7	7u83	5273	`tokdec_props`
		5274	`d_tokdec_props(void)`
2	7u83	5275	`{`
7	7u83	5276	`tokdec_list p0;`
		5277	`p0 = d_tokdec_list();`
		5278	`return(f_make_tokdecs(p0));`
2	7u83	5279	`}`
		5280
		5281
		5282	`/* DECODE TOKDEF */`
		5283
7	7u83	5284	`tokdef`
		5285	`d_tokdef(void)`
2	7u83	5286	`{`
7	7u83	5287	`int code = get_big_code(1);`
		5288	`switch (code) {`
		5289	`case e_make_tokdef: {`
		5290	`tdfint p0;`
		5291	`string_option p1;`
		5292	`bitstream p2;`
		5293	`p0 = d_tdfint();`
		5294	`p1 = d_string_option();`
		5295	`p2 = d_bitstream();`
		5296	`return(f_make_tokdef(p0, p1, p2));`
2	7u83	5297	`}`
		5298	`}`
7	7u83	5299	`decode_error(ILLEGAL_CODE_tokdef);`
		5300	`return(f_dummy_tokdef);`
2	7u83	5301	`}`
		5302
		5303
		5304	`/* DECODE TOKDEF_LIST */`
		5305
7	7u83	5306	`tokdef_list`
		5307	`d_tokdef_list(void)`
2	7u83	5308	`{`
7	7u83	5309	`int i, n;`
		5310	`tokdef_list temp;`
		5311	`n = small_dtdfint();`
		5312	`temp = new_tokdef_list(n);`
		5313	`for (i = 0; i < n; i++) {`
		5314	`tokdef e;`
		5315	`e = d_tokdef();`
		5316	`temp = add_tokdef_list(temp, e, i);`
2	7u83	5317	`}`
7	7u83	5318	`return(temp);`
2	7u83	5319	`}`
		5320
		5321
		5322	`/* DECODE TOKDEF_PROPS */`
		5323
7	7u83	5324	`tokdef_props`
		5325	`d_tokdef_props(void)`
2	7u83	5326	`{`
7	7u83	5327	`tdfint p0;`
		5328	`tokdef_list p1;`
		5329	`p0 = d_tdfint();`
		5330	`p1 = d_tokdef_list();`
		5331	`return(f_make_tokdefs(p0, p1));`
2	7u83	5332	`}`
		5333
		5334
		5335	`/* DECODE TOKEN */`
		5336
7	7u83	5337	`token`
		5338	`d_token(void)`
2	7u83	5339	`{`
7	7u83	5340	`int code = get_big_code(2);`
		5341	`switch (code) {`
		5342	`case e_token_apply_token: {`
		5343	`token p0;`
		5344	`bitstream p1;`
		5345	`p0 = d_token();`
		5346	`p1 = d_bitstream();`
		5347	`return(f_token_apply_token(p0, p1));`
2	7u83	5348	`}`
7	7u83	5349	`case e_make_tok: {`
		5350	`tdfint p0;`
		5351	`p0 = d_tdfint();`
		5352	`return(f_make_tok(p0));`
2	7u83	5353	`}`
7	7u83	5354	`case e_use_tokdef: {`
		5355	`bitstream p0;`
		5356	`p0 = d_bitstream();`
		5357	`return(f_use_tokdef(p0));`
2	7u83	5358	`}`
		5359	`}`
7	7u83	5360	`decode_error(ILLEGAL_CODE_token);`
		5361	`return(f_dummy_token);`
2	7u83	5362	`}`
		5363
		5364
		5365	`/* DECODE TOKEN_DEFN */`
		5366
7	7u83	5367	`token_defn`
		5368	`d_token_defn(void)`
2	7u83	5369	`{`
7	7u83	5370	`int code = get_big_code(1);`
		5371	`switch (code) {`
		5372	`case e_token_definition: {`
		5373	`sortname p0;`
		5374	`tokformals_list p1;`
		5375	`p0 = d_sortname();`
		5376	`p1 = d_tokformals_list();`
		5377	`return(f_token_definition(p0, p1));`
2	7u83	5378	`}`
		5379	`}`
7	7u83	5380	`decode_error(ILLEGAL_CODE_token_defn);`
		5381	`return(f_dummy_token_defn);`
2	7u83	5382	`}`
		5383
		5384
		5385	`/* DECODE TOKEN_OPTION */`
		5386
7	7u83	5387	`token_option`
		5388	`d_token_option(void)`
2	7u83	5389	`{`
7	7u83	5390	`if (getcode(1)) {`
		5391	`token e;`
		5392	`e = d_token();`
		5393	`return(yes_token_option(e));`
2	7u83	5394	`}`
7	7u83	5395	`return(no_token_option);`
2	7u83	5396	`}`
		5397
		5398
		5399	`/* DECODE TOKFORMALS */`
		5400
7	7u83	5401	`tokformals`
		5402	`d_tokformals(void)`
2	7u83	5403	`{`
7	7u83	5404	`sortname p0;`
		5405	`tdfint p1;`
		5406	`p0 = d_sortname();`
		5407	`p1 = d_tdfint();`
		5408	`return(f_make_tokformals(p0, p1));`
2	7u83	5409	`}`
		5410
		5411
		5412	`/* DECODE TOKFORMALS_LIST */`
		5413
7	7u83	5414	`tokformals_list`
		5415	`d_tokformals_list(void)`
2	7u83	5416	`{`
7	7u83	5417	`int i, n;`
		5418	`tokformals_list temp;`
		5419	`IGNORE getcode(1);`
		5420	`n = small_dtdfint();`
		5421	`temp = new_tokformals_list(n);`
		5422	`for (i = 0; i < n; i++) {`
		5423	`tokformals e;`
		5424	`e = d_tokformals();`
		5425	`temp = add_tokformals_list(temp, e, i);`
2	7u83	5426	`}`
7	7u83	5427	`return(temp);`
2	7u83	5428	`}`
		5429
		5430
		5431	`/* DECODE TRANSFER_MODE */`
		5432
7	7u83	5433	`transfer_mode`
		5434	`d_transfer_mode(void)`
2	7u83	5435	`{`
7	7u83	5436	`int code = get_big_code(3);`
		5437	`switch (code) {`
		5438	`case e_transfer_mode_apply_token: {`
		5439	`token p0;`
		5440	`bitstream p1;`
		5441	`p0 = d_token();`
		5442	`p1 = d_bitstream();`
		5443	`return(f_transfer_mode_apply_token(p0, p1));`
2	7u83	5444	`}`
7	7u83	5445	`case e_transfer_mode_cond: {`
		5446	`exp p0;`
		5447	`bitstream p1;`
		5448	`bitstream p2;`
		5449	`p0 = hold_const_check(d_exp());`
		5450	`p1 = d_bitstream();`
		5451	`p2 = d_bitstream();`
		5452	`return(f_transfer_mode_cond(p0, p1, p2));`
2	7u83	5453	`}`
7	7u83	5454	`case e_add_modes: {`
		5455	`transfer_mode p0;`
		5456	`transfer_mode p1;`
		5457	`p0 = d_transfer_mode();`
		5458	`p1 = d_transfer_mode();`
		5459	`return(f_add_modes(p0, p1));`
2	7u83	5460	`}`
7	7u83	5461	`case e_overlap: {`
		5462	`return(f_overlap);`
2	7u83	5463	`}`
7	7u83	5464	`case e_standard_transfer_mode: {`
		5465	`return(f_standard_transfer_mode);`
2	7u83	5466	`}`
7	7u83	5467	`case e_trap_on_nil: {`
		5468	`return(f_trap_on_nil);`
2	7u83	5469	`}`
7	7u83	5470	`case e_volatile: {`
		5471	`return(f_volatile);`
2	7u83	5472	`}`
7	7u83	5473	`case e_complete: {`
		5474	`return(f_complete);`
2	7u83	5475	`}`
		5476	`}`
7	7u83	5477	`decode_error(ILLEGAL_CODE_transfer_mode);`
		5478	`return(f_dummy_transfer_mode);`
2	7u83	5479	`}`
		5480
		5481
		5482	`/* DECODE UNIQUE */`
		5483
7	7u83	5484	`unique`
		5485	`d_unique(void)`
2	7u83	5486	`{`
7	7u83	5487	`tdfident_list p0;`
		5488	`p0 = d_tdfident_list();`
		5489	`return(f_make_unique(p0));`
2	7u83	5490	`}`
		5491
		5492
		5493	`/* DECODE UNIT */`
		5494
7	7u83	5495	`unit`
		5496	`d_unit(void)`
2	7u83	5497	`{`
7	7u83	5498	`tdfint_list p0;`
		5499	`links_list p1;`
		5500	`bytestream p2;`
		5501	`p0 = d_tdfint_list();`
		5502	`start_make_unit(p0);`
		5503	`p1 = d_links_list();`
		5504	`p2 = d_bytestream();`
		5505	`return(f_make_unit(p0, p1, p2));`
2	7u83	5506	`}`
		5507
		5508
		5509	`/* DECODE UNIT_LIST */`
		5510
7	7u83	5511	`unit_list`
		5512	`d_unit_list(void)`
2	7u83	5513	`{`
7	7u83	5514	`int i, n;`
		5515	`unit_list temp;`
		5516	`n = small_dtdfint();`
		5517	`temp = new_unit_list(n);`
		5518	`for (i = 0; i < n; i++) {`
		5519	`unit e;`
		5520	`e = d_unit();`
		5521	`temp = add_unit_list(temp, e, i);`
2	7u83	5522	`}`
7	7u83	5523	`return(temp);`
2	7u83	5524	`}`
		5525
		5526
		5527	`/* DECODE VARIETY */`
		5528
7	7u83	5529	`variety`
		5530	`d_variety(void)`
2	7u83	5531	`{`
7	7u83	5532	`int code = get_big_code(2);`
		5533	`switch (code) {`
		5534	`case e_var_apply_token: {`
		5535	`token p0;`
		5536	`bitstream p1;`
		5537	`p0 = d_token();`
		5538	`p1 = d_bitstream();`
		5539	`return(f_var_apply_token(p0, p1));`
2	7u83	5540	`}`
7	7u83	5541	`case e_var_cond: {`
		5542	`exp p0;`
		5543	`bitstream p1;`
		5544	`bitstream p2;`
		5545	`p0 = hold_const_check(d_exp());`
		5546	`p1 = d_bitstream();`
		5547	`p2 = d_bitstream();`
		5548	`return(f_var_cond(p0, p1, p2));`
2	7u83	5549	`}`
7	7u83	5550	`case e_var_limits: {`
		5551	`signed_nat p0;`
		5552	`signed_nat p1;`
		5553	`p0 = d_signed_nat();`
		5554	`p1 = d_signed_nat();`
		5555	`return(f_var_limits(p0, p1));`
2	7u83	5556	`}`
7	7u83	5557	`case e_var_width: {`
		5558	`bool p0;`
		5559	`nat p1;`
		5560	`p0 = d_bool();`
		5561	`p1 = d_nat();`
		5562	`return(f_var_width(p0, p1));`
2	7u83	5563	`}`
		5564	`}`
7	7u83	5565	`decode_error(ILLEGAL_CODE_variety);`
		5566	`return(f_dummy_variety);`
2	7u83	5567	`}`
		5568
		5569
		5570	`/* DECODE VERSION */`
		5571
7	7u83	5572	`version`
		5573	`d_version(void)`
2	7u83	5574	`{`
7	7u83	5575	`int code = get_big_code(1);`
		5576	`switch (code) {`
		5577	`case e_make_version: {`
		5578	`tdfint p0;`
		5579	`tdfint p1;`
		5580	`p0 = d_tdfint();`
		5581	`p1 = d_tdfint();`
		5582	`return(f_make_version(p0, p1));`
2	7u83	5583	`}`
7	7u83	5584	`case e_user_info: {`
		5585	`string p0;`
		5586	`p0 = d_string();`
		5587	`return(f_user_info(p0));`
2	7u83	5588	`}`
		5589	`}`
7	7u83	5590	`decode_error(ILLEGAL_CODE_version);`
		5591	`return(f_dummy_version);`
2	7u83	5592	`}`
		5593
		5594
		5595	`/* DECODE VERSION_LIST */`
		5596
7	7u83	5597	`version_list`
		5598	`d_version_list(void)`
2	7u83	5599	`{`
7	7u83	5600	`int i, n;`
		5601	`version_list temp;`
		5602	`n = small_dtdfint();`
		5603	`temp = new_version_list(n);`
		5604	`for (i = 0; i < n; i++) {`
		5605	`version e;`
		5606	`e = d_version();`
		5607	`temp = add_version_list(temp, e, i);`
2	7u83	5608	`}`
7	7u83	5609	`return(temp);`
2	7u83	5610	`}`
		5611
		5612
		5613	`/* DECODE VERSION_PROPS */`
		5614
7	7u83	5615	`version_props`
		5616	`d_version_props(void)`
2	7u83	5617	`{`
7	7u83	5618	`version_list p0;`
		5619	`p0 = d_version_list();`
		5620	`return(f_make_versions(p0));`
2	7u83	5621	`}`

Subversion Repositories tendra.SVN

(root)/trunk/src/installers/common/reader/decoder.c – Rev 7