Subversion Repositories tendra.SVN

Rev

Rev 5 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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