Subversion Repositories tendra.SVN

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

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