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 "types.h"
35 
#include "basic.h"
36 
#include "binding.h"
37 
#include "file.h"
38 
#include "sort.h"
39 
#include "tdf.h"
40 
#include "tree.h"
41 
#include "unit.h"
42 
#include "utility.h"
43 
 
44 
 
45 
/* DECODE A ACCESS */
46 
 
47 
long de_access
48 
    PROTO_Z ()
49 
{
50 
    long n = fetch_extn ( 4 ) ;
51 
    switch ( n ) {
52 
	case 1 : {
53 
	    IGNORE de_token_aux ( sort_access, "access" ) ;
54 
	    break ;
55 
	}
56 
	case 2 : {
57 
	    format ( VERT_BRACKETS, "access_cond", "x@[u]@[u]" ) ;
58 
	    break ;
59 
	}
60 
	case 3 : {
61 
	    format ( VERT_BRACKETS, "add_accesses", "uu" ) ;
62 
	    break ;
63 
	}
64 
	case 4 : {
65 
	    out ( "constant" ) ;
66 
	    break ;
67 
	}
68 
	case 5 : {
69 
	    out ( "long_jump_access" ) ;
70 
	    break ;
71 
	}
72 
	case 6 : {
73 
	    out ( "no_other_read" ) ;
74 
	    break ;
75 
	}
76 
	case 7 : {
77 
	    out ( "no_other_write" ) ;
78 
	    break ;
79 
	}
80 
	case 8 : {
81 
	    out ( "out_par" ) ;
82 
	    break ;
83 
	}
84 
	case 9 : {
85 
	    out ( "preserve" ) ;
86 
	    break ;
87 
	}
88 
	case 10 : {
89 
	    out ( "register" ) ;
90 
	    break ;
91 
	}
92 
	case 11 : {
93 
	    out ( "standard_access" ) ;
94 
	    break ;
95 
	}
96 
	case 12 : {
97 
	    out ( "used_as_volatile" ) ;
98 
	    break ;
99 
	}
100 
	case 13 : {
101 
	    out ( "visible" ) ;
102 
	    break ;
103 
	}
104 
	default : {
105 
	    out ( "<error>" ) ;
106 
	    input_error ( "Illegal ACCESS value, %ld", n ) ;
107 
	    n = -1 ;
108 
	    break ;
109 
	}
110 
    }
111 
    return ( n ) ;
112 
}
113 
 
114 
 
115 
/* DECODE A AL_TAG */
116 
 
117 
long de_al_tag
118 
    PROTO_Z ()
119 
{
120 
    long n = fetch_extn ( 1 ) ;
121 
    switch ( n ) {
122 
	case 2 : {
123 
	    IGNORE de_token_aux ( sort_al_tag, "al_tag" ) ;
124 
	    break ;
125 
	}
126 
	case 1 : {
127 
	    long t = tdf_int () ;
128 
	    out_object ( t, ( object * ) null, var_al_tag ) ;
129 
	    break ;
130 
	}
131 
	default : {
132 
	    out ( "<error>" ) ;
133 
	    input_error ( "Illegal AL_TAG value, %ld", n ) ;
134 
	    n = -1 ;
135 
	    break ;
136 
	}
137 
    }
138 
    return ( n ) ;
139 
}
140 
 
141 
 
142 
/* DECODE A AL_TAGDEF */
143 
 
144 
long de_al_tagdef
145 
    PROTO_Z ()
146 
{
147 
    long n = fetch_extn ( 1 ) ;
148 
    if ( n < 1 || n > 1 ) {
149 
	out ( "<error>" ) ;
150 
	input_error ( "Illegal AL_TAGDEF value, %ld", n ) ;
151 
	n = -1 ;
152 
    }
153 
    return ( n ) ;
154 
}
155 
 
156 
 
157 
/* DECODE A ALIGNMENT */
158 
 
159 
long de_alignment
160 
    PROTO_Z ()
161 
{
162 
    long n = fetch_extn ( 4 ) ;
163 
    switch ( n ) {
164 
	case 1 : {
165 
	    IGNORE de_token_aux ( sort_alignment, "alignment" ) ;
166 
	    break ;
167 
	}
168 
	case 2 : {
169 
	    format ( VERT_BRACKETS, "alignment_cond", "x@[a]@[a]" ) ;
170 
	    break ;
171 
	}
172 
	case 3 : {
173 
	    format ( HORIZ_BRACKETS, "alignment", "S" ) ;
174 
	    break ;
175 
	}
176 
	case 4 : {
177 
	    out ( "alloca_alignment" ) ;
178 
	    break ;
179 
	}
180 
	case 5 : {
181 
	    format ( VERT_BRACKETS, "callees_alignment", "b" ) ;
182 
	    break ;
183 
	}
184 
	case 6 : {
185 
	    format ( VERT_BRACKETS, "callers_alignment", "b" ) ;
186 
	    break ;
187 
	}
188 
	case 7 : {
189 
	    out ( "code_alignment" ) ;
190 
	    break ;
191 
	}
192 
	case 8 : {
193 
	    out ( "locals_alignment" ) ;
194 
	    break ;
195 
	}
196 
	case 9 : {
197 
	    format ( HORIZ_BRACKETS, "obtain_al_tag", "A" ) ;
198 
	    break ;
199 
	}
200 
	case 10 : {
201 
	    format ( VERT_BRACKETS, "parameter_alignment", "S" ) ;
202 
	    break ;
203 
	}
204 
	case 11 : {
205 
	    format ( VERT_BRACKETS, "unite_alignments", "aa" ) ;
206 
	    break ;
207 
	}
208 
	case 12 : {
209 
	    out ( "var_param_alignment" ) ;
210 
	    break ;
211 
	}
212 
	default : {
213 
	    out ( "<error>" ) ;
214 
	    input_error ( "Illegal ALIGNMENT value, %ld", n ) ;
215 
	    n = -1 ;
216 
	    break ;
217 
	}
218 
    }
219 
    return ( n ) ;
220 
}
221 
 
222 
 
223 
/* DECODE A BITFIELD_VARIETY */
224 
 
225 
long de_bitfield_variety
226 
    PROTO_Z ()
227 
{
228 
    long n = fetch_extn ( 2 ) ;
229 
    switch ( n ) {
230 
	case 1 : {
231 
	    IGNORE de_token_aux ( sort_bitfield_variety, "bitfield_variety" ) ;
232 
	    break ;
233 
	}
234 
	case 2 : {
235 
	    format ( VERT_BRACKETS, "bfvar_cond", "x@[B]@[B]" ) ;
236 
	    break ;
237 
	}
238 
	case 3 : {
239 
	    format ( HORIZ_BRACKETS, "bfvar_bits", "bn" ) ;
240 
	    break ;
241 
	}
242 
	default : {
243 
	    out ( "<error>" ) ;
244 
	    input_error ( "Illegal BITFIELD_VARIETY value, %ld", n ) ;
245 
	    n = -1 ;
246 
	    break ;
247 
	}
248 
    }
249 
    return ( n ) ;
250 
}
251 
 
252 
 
253 
/* DECODE A BOOL */
254 
 
255 
long de_bool
256 
    PROTO_Z ()
257 
{
258 
    long n = fetch_extn ( 3 ) ;
259 
    switch ( n ) {
260 
	case 1 : {
261 
	    IGNORE de_token_aux ( sort_bool, "bool" ) ;
262 
	    break ;
263 
	}
264 
	case 2 : {
265 
	    format ( VERT_BRACKETS, "bool_cond", "x@[b]@[b]" ) ;
266 
	    break ;
267 
	}
268 
	case 3 : {
269 
	    out ( "false" ) ;
270 
	    break ;
271 
	}
272 
	case 4 : {
273 
	    out ( "true" ) ;
274 
	    break ;
275 
	}
276 
	default : {
277 
	    out ( "<error>" ) ;
278 
	    input_error ( "Illegal BOOL value, %ld", n ) ;
279 
	    n = -1 ;
280 
	    break ;
281 
	}
282 
    }
283 
    return ( n ) ;
284 
}
285 
 
286 
 
287 
/* DECODE A CALLEES */
288 
 
289 
long de_callees
290 
    PROTO_Z ()
291 
{
292 
    long n = fetch_extn ( 2 ) ;
293 
    switch ( n ) {
294 
	case 1 : {
295 
	    format ( VERT_BRACKETS, "make_callee_list", "*[x]" ) ;
296 
	    break ;
297 
	}
298 
	case 2 : {
299 
	    format ( VERT_BRACKETS, "make_dynamic_callees", "xx" ) ;
300 
	    break ;
301 
	}
302 
	case 3 : {
303 
	    out ( "same_callees" ) ;
304 
	    break ;
305 
	}
306 
	default : {
307 
	    out ( "<error>" ) ;
308 
	    input_error ( "Illegal CALLEES value, %ld", n ) ;
309 
	    n = -1 ;
310 
	    break ;
311 
	}
312 
    }
313 
    return ( n ) ;
314 
}
315 
 
316 
 
317 
/* DECODE A DG */
318 
 
319 
long de_dg
320 
    PROTO_Z ()
321 
{
322 
    long n = fetch_extn ( 6 ) ;
323 
    switch ( n ) {
324 
	case 1 : {
325 
	    sortname sn = find_sortname ( 'G' ) ;
326 
	    IGNORE de_token_aux ( sn, "dg" ) ;
327 
	    break ;
328 
	}
329 
	case 2 : {
330 
	    format ( VERT_BRACKETS, "make_tag_dg", "JG" ) ;
331 
	    break ;
332 
	}
333 
	case 3 : {
334 
	    format ( VERT_BRACKETS, "abortable_part_dg", "Wb" ) ;
335 
	    break ;
336 
	}
337 
	case 4 : {
338 
	    format ( VERT_BRACKETS, "accept_dg", "WJ*[h]b?[J]" ) ;
339 
	    break ;
340 
	}
341 
	case 5 : {
342 
	    format ( VERT_BRACKETS, "barrier_dg", "WJ" ) ;
343 
	    break ;
344 
	}
345 
	case 6 : {
346 
	    format ( VERT_BRACKETS, "branch_dg", "W" ) ;
347 
	    break ;
348 
	}
349 
	case 7 : {
350 
	    format ( VERT_BRACKETS, "call_dg", "?[Y]W?[n]?[J]?[J]" ) ;
351 
	    break ;
352 
	}
353 
	case 8 : {
354 
	    format ( VERT_BRACKETS, "compilation_dg", "J" ) ;
355 
	    break ;
356 
	}
357 
	case 9 : {
358 
	    format ( VERT_BRACKETS, "destructor_dg", "W?[x]" ) ;
359 
	    break ;
360 
	}
361 
	case 10 : {
362 
	    format ( VERT_BRACKETS, "exception_handler_dg", "?[h]" ) ;
363 
	    break ;
364 
	}
365 
	case 11 : {
366 
	    format ( VERT_BRACKETS, "exception_scope_dg", "*[J]" ) ;
367 
	    break ;
368 
	}
369 
	case 12 : {
370 
	    format ( VERT_BRACKETS, "inline_call_dg", "J*[h]?[n]" ) ;
371 
	    break ;
372 
	}
373 
	case 13 : {
374 
	    format ( VERT_BRACKETS, "inline_result_dg", "J" ) ;
375 
	    break ;
376 
	}
377 
	case 14 : {
378 
	    format ( VERT_BRACKETS, "inlined_dg", "GJ" ) ;
379 
	    break ;
380 
	}
381 
	case 15 : {
382 
	    format ( VERT_BRACKETS, "jump_dg", "W" ) ;
383 
	    break ;
384 
	}
385 
	case 16 : {
386 
	    format ( VERT_BRACKETS, "label_dg", "YW" ) ;
387 
	    break ;
388 
	}
389 
	case 17 : {
390 
	    format ( VERT_BRACKETS, "lexical_block_dg", "?[Y]W" ) ;
391 
	    break ;
392 
	}
393 
	case 18 : {
394 
	    format ( VERT_BRACKETS, "list_dg", "*[G]" ) ;
395 
	    break ;
396 
	}
397 
	case 19 : {
398 
	    format ( VERT_BRACKETS, "long_jump_dg", "W" ) ;
399 
	    break ;
400 
	}
401 
	case 20 : {
402 
	    format ( VERT_BRACKETS, "name_decl_dg", "h" ) ;
403 
	    break ;
404 
	}
405 
	case 21 : {
406 
	    format ( VERT_BRACKETS, "params_dg", "*[h]?[x]" ) ;
407 
	    break ;
408 
	}
409 
	case 22 : {
410 
	    format ( VERT_BRACKETS, "raise_dg", "W?[\015]?[x]" ) ;
411 
	    break ;
412 
	}
413 
	case 23 : {
414 
	    format ( VERT_BRACKETS, "requeue_dg", "WJb" ) ;
415 
	    break ;
416 
	}
417 
	case 24 : {
418 
	    format ( VERT_BRACKETS, "rts_call_dg", "Wn?[J]?[J]" ) ;
419 
	    break ;
420 
	}
421 
	case 25 : {
422 
	    format ( VERT_BRACKETS, "select_dg", "Wb" ) ;
423 
	    break ;
424 
	}
425 
	case 26 : {
426 
	    format ( VERT_BRACKETS, "select_alternative_dg", "Wnbx" ) ;
427 
	    break ;
428 
	}
429 
	case 27 : {
430 
	    format ( VERT_BRACKETS, "select_guard_dg", "WJ" ) ;
431 
	    break ;
432 
	}
433 
	case 28 : {
434 
	    format ( VERT_BRACKETS, "singlestep_dg", "W" ) ;
435 
	    break ;
436 
	}
437 
	case 29 : {
438 
	    format ( VERT_BRACKETS, "source_language_dg", "n" ) ;
439 
	    break ;
440 
	}
441 
	case 30 : {
442 
	    format ( VERT_BRACKETS, "sourcepos_dg", "W" ) ;
443 
	    break ;
444 
	}
445 
	case 31 : {
446 
	    format ( VERT_BRACKETS, "statement_part_dg", "J" ) ;
447 
	    break ;
448 
	}
449 
	case 32 : {
450 
	    format ( VERT_BRACKETS, "test_dg", "Wb" ) ;
451 
	    break ;
452 
	}
453 
	case 33 : {
454 
	    format ( VERT_BRACKETS, "triggering_alternative_dg", "Wnb" ) ;
455 
	    break ;
456 
	}
457 
	case 34 : {
458 
	    format ( VERT_BRACKETS, "with_dg", "\015x" ) ;
459 
	    break ;
460 
	}
461 
	default : {
462 
	    out ( "<error>" ) ;
463 
	    input_error ( "Illegal DG value, %ld", n ) ;
464 
	    n = -1 ;
465 
	    break ;
466 
	}
467 
    }
468 
    return ( n ) ;
469 
}
470 
 
471 
 
472 
/* DECODE A DG_ACCESSIBILITY */
473 
 
474 
long de_dg_accessibility
475 
    PROTO_Z ()
476 
{
477 
    long n = fetch_extn ( 2 ) ;
478 
    switch ( n ) {
479 
	case 1 : {
480 
	    out ( "dg_local_accessibility" ) ;
481 
	    break ;
482 
	}
483 
	case 2 : {
484 
	    out ( "dg_private_accessibility" ) ;
485 
	    break ;
486 
	}
487 
	case 3 : {
488 
	    out ( "dg_protected_accessibility" ) ;
489 
	    break ;
490 
	}
491 
	case 4 : {
492 
	    out ( "dg_public_accessibility" ) ;
493 
	    break ;
494 
	}
495 
	default : {
496 
	    out ( "<error>" ) ;
497 
	    input_error ( "Illegal DG_ACCESSIBILITY value, %ld", n ) ;
498 
	    n = -1 ;
499 
	    break ;
500 
	}
501 
    }
502 
    return ( n ) ;
503 
}
504 
 
505 
 
506 
/* DECODE A DG_APPEND */
507 
 
508 
long de_dg_append
509 
    PROTO_Z ()
510 
{
511 
    long n = fetch_extn ( 1 ) ;
512 
    switch ( n ) {
513 
	case 1 : {
514 
	    format ( VERT_BRACKETS, "dg_name_append", "Jh" ) ;
515 
	    break ;
516 
	}
517 
	default : {
518 
	    out ( "<error>" ) ;
519 
	    input_error ( "Illegal DG_APPEND value, %ld", n ) ;
520 
	    n = -1 ;
521 
	    break ;
522 
	}
523 
    }
524 
    return ( n ) ;
525 
}
526 
 
527 
 
528 
/* DECODE A DG_BOUND */
529 
 
530 
long de_dg_bound
531 
    PROTO_Z ()
532 
{
533 
    long n = fetch_extn ( 2 ) ;
534 
    switch ( n ) {
535 
	case 1 : {
536 
	    format ( VERT_BRACKETS, "dg_dynamic_bound", "JS" ) ;
537 
	    break ;
538 
	}
539 
	case 2 : {
540 
	    format ( VERT_BRACKETS, "dg_static_bound", "x" ) ;
541 
	    break ;
542 
	}
543 
	case 3 : {
544 
	    format ( VERT_BRACKETS, "dg_unknown_bound", "S" ) ;
545 
	    break ;
546 
	}
547 
	default : {
548 
	    out ( "<error>" ) ;
549 
	    input_error ( "Illegal DG_BOUND value, %ld", n ) ;
550 
	    n = -1 ;
551 
	    break ;
552 
	}
553 
    }
554 
    return ( n ) ;
555 
}
556 
 
557 
 
558 
/* DECODE A DG_CLASS_BASE */
559 
 
560 
long de_dg_class_base
561 
    PROTO_Z ()
562 
{
563 
    long n = fetch_extn ( 1 ) ;
564 
    switch ( n ) {
565 
	case 1 : {
566 
	    format ( VERT_BRACKETS, "make_dg_class_base", "J?[W]?[T]?[o]?[\020]" ) ;
567 
	    break ;
568 
	}
569 
	default : {
570 
	    out ( "<error>" ) ;
571 
	    input_error ( "Illegal DG_CLASS_BASE value, %ld", n ) ;
572 
	    n = -1 ;
573 
	    break ;
574 
	}
575 
    }
576 
    return ( n ) ;
577 
}
578 
 
579 
 
580 
/* DECODE A DG_CLASSMEM */
581 
 
582 
long de_dg_classmem
583 
    PROTO_Z ()
584 
{
585 
    long n = fetch_extn ( 3 ) ;
586 
    switch ( n ) {
587 
	case 1 : {
588 
	    format ( VERT_BRACKETS, "dg_tag_classmem", "Jz" ) ;
589 
	    break ;
590 
	}
591 
	case 2 : {
592 
	    format ( VERT_BRACKETS, "dg_field_classmem", "YWx\015?[o]?[b]?[\012]" ) ;
593 
	    break ;
594 
	}
595 
	case 3 : {
596 
	    format ( VERT_BRACKETS, "dg_function_classmem", "h?[x]" ) ;
597 
	    break ;
598 
	}
599 
	case 4 : {
600 
	    format ( VERT_BRACKETS, "dg_indirect_classmem", "YWT\015" ) ;
601 
	    break ;
602 
	}
603 
	case 5 : {
604 
	    format ( VERT_BRACKETS, "dg_name_classmem", "h" ) ;
605 
	    break ;
606 
	}
607 
	default : {
608 
	    out ( "<error>" ) ;
609 
	    input_error ( "Illegal DG_CLASSMEM value, %ld", n ) ;
610 
	    n = -1 ;
611 
	    break ;
612 
	}
613 
    }
614 
    return ( n ) ;
615 
}
616 
 
617 
 
618 
/* DECODE A DG_COMPILATION */
619 
 
620 
long de_dg_compilation
621 
    PROTO_Z ()
622 
{
623 
    long n = fetch_extn ( 2 ) ;
624 
    switch ( n ) {
625 
	case 1 : {
626 
	    format ( VERT_BRACKETS, "dg_tag_compilation", "JC" ) ;
627 
	    break ;
628 
	}
629 
	case 2 : {
630 
	    format ( VERT_BRACKETS, "make_dg_compilation", "U*[X]*[Z]UnnnX*[X]k" ) ;
631 
	    break ;
632 
	}
633 
	default : {
634 
	    out ( "<error>" ) ;
635 
	    input_error ( "Illegal DG_COMPILATION value, %ld", n ) ;
636 
	    n = -1 ;
637 
	    break ;
638 
	}
639 
    }
640 
    return ( n ) ;
641 
}
642 
 
643 
 
644 
/* DECODE A DG_CONSTRAINT */
645 
 
646 
long de_dg_constraint
647 
    PROTO_Z ()
648 
{
649 
    long n = fetch_extn ( 2 ) ;
650 
    switch ( n ) {
651 
	case 1 : {
652 
	    format ( VERT_BRACKETS, "dg_type_constraint", "?[J]\015" ) ;
653 
	    break ;
654 
	}
655 
	case 2 : {
656 
	    format ( VERT_BRACKETS, "dg_value_constraint", "?[J]x" ) ;
657 
	    break ;
658 
	}
659 
	default : {
660 
	    out ( "<error>" ) ;
661 
	    input_error ( "Illegal DG_CONSTRAINT value, %ld", n ) ;
662 
	    n = -1 ;
663 
	    break ;
664 
	}
665 
    }
666 
    return ( n ) ;
667 
}
668 
 
669 
 
670 
/* DECODE A DG_DEFAULT */
671 
 
672 
long de_dg_default
673 
    PROTO_Z ()
674 
{
675 
    long n = fetch_extn ( 1 ) ;
676 
    switch ( n ) {
677 
	case 1 : {
678 
	    format ( VERT_BRACKETS, "make_dg_default", "?[x]?[W]" ) ;
679 
	    break ;
680 
	}
681 
	default : {
682 
	    out ( "<error>" ) ;
683 
	    input_error ( "Illegal DG_DEFAULT value, %ld", n ) ;
684 
	    n = -1 ;
685 
	    break ;
686 
	}
687 
    }
688 
    return ( n ) ;
689 
}
690 
 
691 
 
692 
/* DECODE A DG_DIM */
693 
 
694 
long de_dg_dim
695 
    PROTO_Z ()
696 
{
697 
    long n = fetch_extn ( 3 ) ;
698 
    switch ( n ) {
699 
	case 1 : {
700 
	    sortname sn = find_sortname ( 'O' ) ;
701 
	    IGNORE de_token_aux ( sn, "dg_dim" ) ;
702 
	    break ;
703 
	}
704 
	case 2 : {
705 
	    format ( VERT_BRACKETS, "dg_tag_dim", "JO" ) ;
706 
	    break ;
707 
	}
708 
	case 3 : {
709 
	    format ( VERT_BRACKETS, "dg_bounds_dim", "ww\015" ) ;
710 
	    break ;
711 
	}
712 
	case 4 : {
713 
	    format ( VERT_BRACKETS, "dg_count_dim", "ww\015" ) ;
714 
	    break ;
715 
	}
716 
	case 5 : {
717 
	    format ( VERT_BRACKETS, "dg_type_dim", "\015?[n]" ) ;
718 
	    break ;
719 
	}
720 
	case 6 : {
721 
	    out ( "dg_unspecified_dim" ) ;
722 
	    break ;
723 
	}
724 
	default : {
725 
	    out ( "<error>" ) ;
726 
	    input_error ( "Illegal DG_DIM value, %ld", n ) ;
727 
	    n = -1 ;
728 
	    break ;
729 
	}
730 
    }
731 
    return ( n ) ;
732 
}
733 
 
734 
 
735 
/* DECODE A DG_DISCRIM */
736 
 
737 
long de_dg_discrim
738 
    PROTO_Z ()
739 
{
740 
    long n = fetch_extn ( 1 ) ;
741 
    switch ( n ) {
742 
	case 1 : {
743 
	    format ( VERT_BRACKETS, "make_dg_discrim", "xx" ) ;
744 
	    break ;
745 
	}
746 
	default : {
747 
	    out ( "<error>" ) ;
748 
	    input_error ( "Illegal DG_DISCRIM value, %ld", n ) ;
749 
	    n = -1 ;
750 
	    break ;
751 
	}
752 
    }
753 
    return ( n ) ;
754 
}
755 
 
756 
 
757 
/* DECODE A DG_ENUM */
758 
 
759 
long de_dg_enum
760 
    PROTO_Z ()
761 
{
762 
    long n = fetch_extn ( 2 ) ;
763 
    switch ( n ) {
764 
	case 1 : {
765 
	    format ( VERT_BRACKETS, "dg_tag_enum", "JE" ) ;
766 
	    break ;
767 
	}
768 
	case 2 : {
769 
	    format ( VERT_BRACKETS, "make_dg_enum", "xYW" ) ;
770 
	    break ;
771 
	}
772 
	case 3 : {
773 
	    format ( VERT_BRACKETS, "dg_char_enum", "xnW" ) ;
774 
	    break ;
775 
	}
776 
	default : {
777 
	    out ( "<error>" ) ;
778 
	    input_error ( "Illegal DG_ENUM value, %ld", n ) ;
779 
	    n = -1 ;
780 
	    break ;
781 
	}
782 
    }
783 
    return ( n ) ;
784 
}
785 
 
786 
 
787 
/* DECODE A DG_FILENAME */
788 
 
789 
long de_dg_filename
790 
    PROTO_Z ()
791 
{
792 
    long n = fetch_extn ( 2 ) ;
793 
    switch ( n ) {
794 
	case 1 : {
795 
	    sortname sn = find_sortname ( 'U' ) ;
796 
	    IGNORE de_token_aux ( sn, "dg_filename" ) ;
797 
	    break ;
798 
	}
799 
	case 2 : {
800 
	    format ( VERT_BRACKETS, "make_dg_filename", "nXXX" ) ;
801 
	    break ;
802 
	}
803 
	default : {
804 
	    out ( "<error>" ) ;
805 
	    input_error ( "Illegal DG_FILENAME value, %ld", n ) ;
806 
	    n = -1 ;
807 
	    break ;
808 
	}
809 
    }
810 
    return ( n ) ;
811 
}
812 
 
813 
 
814 
/* DECODE A DG_IDNAME */
815 
 
816 
long de_dg_idname
817 
    PROTO_Z ()
818 
{
819 
    long n = fetch_extn ( 3 ) ;
820 
    switch ( n ) {
821 
	case 1 : {
822 
	    sortname sn = find_sortname ( 'Y' ) ;
823 
	    IGNORE de_token_aux ( sn, "dg_idname" ) ;
824 
	    break ;
825 
	}
826 
	case 2 : {
827 
	    format ( VERT_BRACKETS, "dg_anonymous_idname", "?[X]" ) ;
828 
	    break ;
829 
	}
830 
	case 3 : {
831 
	    format ( VERT_BRACKETS, "dg_artificial_idname", "?[X]" ) ;
832 
	    break ;
833 
	}
834 
	case 4 : {
835 
	    format ( VERT_BRACKETS, "dg_external_idname", "X" ) ;
836 
	    break ;
837 
	}
838 
	case 5 : {
839 
	    format ( VERT_BRACKETS, "dg_instance_idname", "?[Y]YW*[h]" ) ;
840 
	    break ;
841 
	}
842 
	case 6 : {
843 
	    format ( VERT_BRACKETS, "dg_sourcestring_idname", "X" ) ;
844 
	    break ;
845 
	}
846 
	default : {
847 
	    out ( "<error>" ) ;
848 
	    input_error ( "Illegal DG_IDNAME value, %ld", n ) ;
849 
	    n = -1 ;
850 
	    break ;
851 
	}
852 
    }
853 
    return ( n ) ;
854 
}
855 
 
856 
 
857 
/* DECODE A DG_MACRO */
858 
 
859 
long de_dg_macro
860 
    PROTO_Z ()
861 
{
862 
    long n = fetch_extn ( 2 ) ;
863 
    switch ( n ) {
864 
	case 1 : {
865 
	    format ( VERT_BRACKETS, "dg_function_macro", "WY*[Y]X" ) ;
866 
	    break ;
867 
	}
868 
	case 2 : {
869 
	    format ( VERT_BRACKETS, "dg_include_macro", "WU*[Z]" ) ;
870 
	    break ;
871 
	}
872 
	case 3 : {
873 
	    format ( VERT_BRACKETS, "dg_object_macro", "WYX" ) ;
874 
	    break ;
875 
	}
876 
	case 4 : {
877 
	    format ( VERT_BRACKETS, "dg_undef_macro", "WY" ) ;
878 
	    break ;
879 
	}
880 
	default : {
881 
	    out ( "<error>" ) ;
882 
	    input_error ( "Illegal DG_MACRO value, %ld", n ) ;
883 
	    n = -1 ;
884 
	    break ;
885 
	}
886 
    }
887 
    return ( n ) ;
888 
}
889 
 
890 
 
891 
/* DECODE A DG_NAME */
892 
 
893 
long de_dg_name
894 
    PROTO_Z ()
895 
{
896 
    long n = fetch_extn ( 5 ) ;
897 
    switch ( n ) {
898 
	case 1 : {
899 
	    sortname sn = find_sortname ( 'h' ) ;
900 
	    IGNORE de_token_aux ( sn, "dg_name" ) ;
901 
	    break ;
902 
	}
903 
	case 2 : {
904 
	    format ( VERT_BRACKETS, "dg_tag_name", "Jh" ) ;
905 
	    break ;
906 
	}
907 
	case 3 : {
908 
	    format ( VERT_BRACKETS, "dg_constant_name", "h" ) ;
909 
	    break ;
910 
	}
911 
	case 4 : {
912 
	    format ( VERT_BRACKETS, "dg_entry_family_name", "hO" ) ;
913 
	    break ;
914 
	}
915 
	case 5 : {
916 
	    format ( VERT_BRACKETS, "dg_entry_name", "YW\015?[o]?[O]" ) ;
917 
	    break ;
918 
	}
919 
	case 6 : {
920 
	    format ( VERT_BRACKETS, "dg_inlined_name", "hJ" ) ;
921 
	    break ;
922 
	}
923 
	case 7 : {
924 
	    format ( VERT_BRACKETS, "dg_is_spec_name", "h?[b]" ) ;
925 
	    break ;
926 
	}
927 
	case 8 : {
928 
	    format ( VERT_BRACKETS, "dg_module_name", "YWk?[x]?[J]" ) ;
929 
	    break ;
930 
	}
931 
	case 9 : {
932 
	    format ( VERT_BRACKETS, "dg_namespace_name", "YWk" ) ;
933 
	    break ;
934 
	}
935 
	case 10 : {
936 
	    format ( VERT_BRACKETS, "dg_object_name", "YW\015?[x]?[o]" ) ;
937 
	    break ;
938 
	}
939 
	case 11 : {
940 
	    format ( VERT_BRACKETS, "dg_proc_name", "YW\015?[x]?[o]?[\020]b?[*[\015]]?[J]" ) ;
941 
	    break ;
942 
	}
943 
	case 12 : {
944 
	    format ( VERT_BRACKETS, "dg_program_name", "YWx" ) ;
945 
	    break ;
946 
	}
947 
	case 13 : {
948 
	    format ( VERT_BRACKETS, "dg_rep_clause_name", "hx" ) ;
949 
	    break ;
950 
	}
951 
	case 14 : {
952 
	    format ( VERT_BRACKETS, "dg_spec_ref_name", "Jh" ) ;
953 
	    break ;
954 
	}
955 
	case 15 : {
956 
	    format ( VERT_BRACKETS, "dg_subunit_name", "Jhn?[o]" ) ;
957 
	    break ;
958 
	}
959 
	case 16 : {
960 
	    format ( VERT_BRACKETS, "dg_type_name", "?[Y]W?[o]?[\015]b?[b]?[*[\011]]" ) ;
961 
	    break ;
962 
	}
963 
	case 17 : {
964 
	    format ( VERT_BRACKETS, "dg_visibility_name", "Jn?[Y]?[W]?[o]?[\015]" ) ;
965 
	    break ;
966 
	}
967 
	default : {
968 
	    out ( "<error>" ) ;
969 
	    input_error ( "Illegal DG_NAME value, %ld", n ) ;
970 
	    n = -1 ;
971 
	    break ;
972 
	}
973 
    }
974 
    return ( n ) ;
975 
}
976 
 
977 
 
978 
/* DECODE A DG_NAMELIST */
979 
 
980 
long de_dg_namelist
981 
    PROTO_Z ()
982 
{
983 
    long n = fetch_extn ( 2 ) ;
984 
    switch ( n ) {
985 
	case 1 : {
986 
	    format ( VERT_BRACKETS, "dg_tag_namelist", "Jk" ) ;
987 
	    break ;
988 
	}
989 
	case 2 : {
990 
	    format ( VERT_BRACKETS, "make_dg_namelist", "*[h]" ) ;
991 
	    break ;
992 
	}
993 
	default : {
994 
	    out ( "<error>" ) ;
995 
	    input_error ( "Illegal DG_NAMELIST value, %ld", n ) ;
996 
	    n = -1 ;
997 
	    break ;
998 
	}
999 
    }
1000 
    return ( n ) ;
1001 
}
1002 
 
1003 
 
1004 
/* DECODE A DG_PARAM */
1005 
 
1006 
long de_dg_param
1007 
    PROTO_Z ()
1008 
{
1009 
    long n = fetch_extn ( 2 ) ;
1010 
    switch ( n ) {
1011 
	case 1 : {
1012 
	    format ( VERT_BRACKETS, "dg_object_param", "?[Y]?[W]?[\013]\015?[\012]" ) ;
1013 
	    break ;
1014 
	}
1015 
	case 2 : {
1016 
	    format ( VERT_BRACKETS, "dg_type_param", "?[Y]?[W]*[p]" ) ;
1017 
	    break ;
1018 
	}
1019 
	default : {
1020 
	    out ( "<error>" ) ;
1021 
	    input_error ( "Illegal DG_PARAM value, %ld", n ) ;
1022 
	    n = -1 ;
1023 
	    break ;
1024 
	}
1025 
    }
1026 
    return ( n ) ;
1027 
}
1028 
 
1029 
 
1030 
/* DECODE A DG_PARAM_MODE */
1031 
 
1032 
long de_dg_param_mode
1033 
    PROTO_Z ()
1034 
{
1035 
    long n = fetch_extn ( 2 ) ;
1036 
    switch ( n ) {
1037 
	case 1 : {
1038 
	    out ( "dg_in_mode" ) ;
1039 
	    break ;
1040 
	}
1041 
	case 2 : {
1042 
	    out ( "dg_inout_mode" ) ;
1043 
	    break ;
1044 
	}
1045 
	case 3 : {
1046 
	    out ( "dg_out_mode" ) ;
1047 
	    break ;
1048 
	}
1049 
	default : {
1050 
	    out ( "<error>" ) ;
1051 
	    input_error ( "Illegal DG_PARAM_MODE value, %ld", n ) ;
1052 
	    n = -1 ;
1053 
	    break ;
1054 
	}
1055 
    }
1056 
    return ( n ) ;
1057 
}
1058 
 
1059 
 
1060 
/* DECODE A DG_QUALIFIER */
1061 
 
1062 
long de_dg_qualifier
1063 
    PROTO_Z ()
1064 
{
1065 
    long n = fetch_extn ( 3 ) ;
1066 
    switch ( n ) {
1067 
	case 1 : {
1068 
	    out ( "dg_aliased_qualifier" ) ;
1069 
	    break ;
1070 
	}
1071 
	case 2 : {
1072 
	    out ( "dg_class_wide_qualifier" ) ;
1073 
	    break ;
1074 
	}
1075 
	case 3 : {
1076 
	    out ( "dg_const_qualifier" ) ;
1077 
	    break ;
1078 
	}
1079 
	case 4 : {
1080 
	    out ( "dg_limited_qualifier" ) ;
1081 
	    break ;
1082 
	}
1083 
	case 5 : {
1084 
	    out ( "dg_volatile_qualifier" ) ;
1085 
	    break ;
1086 
	}
1087 
	default : {
1088 
	    out ( "<error>" ) ;
1089 
	    input_error ( "Illegal DG_QUALIFIER value, %ld", n ) ;
1090 
	    n = -1 ;
1091 
	    break ;
1092 
	}
1093 
    }
1094 
    return ( n ) ;
1095 
}
1096 
 
1097 
 
1098 
/* DECODE A DG_SOURCEPOS */
1099 
 
1100 
long de_dg_sourcepos
1101 
    PROTO_Z ()
1102 
{
1103 
    long n = fetch_extn ( 3 ) ;
1104 
    switch ( n ) {
1105 
	case 1 : {
1106 
	    format ( HORIZ_BRACKETS, "dg_file_sourcepos", "U" ) ;
1107 
	    break ;
1108 
	}
1109 
	case 2 : {
1110 
	    out ( "dg_global_sourcepos" ) ;
1111 
	    break ;
1112 
	}
1113 
	case 3 : {
1114 
	    format ( HORIZ_BRACKETS, "dg_mark_sourcepos", "Unn" ) ;
1115 
	    break ;
1116 
	}
1117 
	case 4 : {
1118 
	    out ( "dg_null_sourcepos" ) ;
1119 
	    break ;
1120 
	}
1121 
	case 5 : {
1122 
	    format ( HORIZ_BRACKETS, "dg_span_sourcepos", "Unn?[U]nn" ) ;
1123 
	    break ;
1124 
	}
1125 
	default : {
1126 
	    out ( "<error>" ) ;
1127 
	    input_error ( "Illegal DG_SOURCEPOS value, %ld", n ) ;
1128 
	    n = -1 ;
1129 
	    break ;
1130 
	}
1131 
    }
1132 
    return ( n ) ;
1133 
}
1134 
 
1135 
 
1136 
/* DECODE A DG_TAG */
1137 
 
1138 
long de_dg_tag
1139 
    PROTO_Z ()
1140 
{
1141 
    long n = fetch_extn ( 1 ) ;
1142 
    switch ( n ) {
1143 
	case 1 : {
1144 
	    long t = tdf_int () ;
1145 
	    out_object ( t, ( object * ) null, var_dg_tag ) ;
1146 
	    break ;
1147 
	}
1148 
	default : {
1149 
	    out ( "<error>" ) ;
1150 
	    input_error ( "Illegal DG_TAG value, %ld", n ) ;
1151 
	    n = -1 ;
1152 
	    break ;
1153 
	}
1154 
    }
1155 
    return ( n ) ;
1156 
}
1157 
 
1158 
 
1159 
/* DECODE A DG_TYPE */
1160 
 
1161 
long de_dg_type
1162 
    PROTO_Z ()
1163 
{
1164 
    long n = fetch_extn ( 6 ) ;
1165 
    switch ( n ) {
1166 
	case 1 : {
1167 
	    sortname sn = find_sortname ( '\015' ) ;
1168 
	    IGNORE de_token_aux ( sn, "dg_type" ) ;
1169 
	    break ;
1170 
	}
1171 
	case 2 : {
1172 
	    format ( VERT_BRACKETS, "dg_tag_type", "J\015" ) ;
1173 
	    break ;
1174 
	}
1175 
	case 3 : {
1176 
	    format ( VERT_BRACKETS, "dg_address_type", "YS" ) ;
1177 
	    break ;
1178 
	}
1179 
	case 4 : {
1180 
	    format ( VERT_BRACKETS, "dg_array_type", "\015x?[b]*[O]" ) ;
1181 
	    break ;
1182 
	}
1183 
	case 5 : {
1184 
	    format ( VERT_BRACKETS, "dg_bitfield_type", "\015BS" ) ;
1185 
	    break ;
1186 
	}
1187 
	case 6 : {
1188 
	    format ( VERT_BRACKETS, "dg_boolean_type", "Yv" ) ;
1189 
	    break ;
1190 
	}
1191 
	case 7 : {
1192 
	    format ( VERT_BRACKETS, "dg_char_type", "Yv" ) ;
1193 
	    break ;
1194 
	}
1195 
	case 8 : {
1196 
	    format ( VERT_BRACKETS, "dg_class_type", "*[y]*[z]?[\017]*[J]?[S]?[J]?[J]?[Y]?[W]b?[J]?[J]b?[b]" ) ;
1197 
	    break ;
1198 
	}
1199 
	case 9 : {
1200 
	    format ( VERT_BRACKETS, "dg_complex_float_type", "Yf" ) ;
1201 
	    break ;
1202 
	}
1203 
	case 10 : {
1204 
	    format ( VERT_BRACKETS, "dg_enum_type", "*[E]?[Y]?[W]Sb" ) ;
1205 
	    break ;
1206 
	}
1207 
	case 11 : {
1208 
	    format ( VERT_BRACKETS, "dg_file_type", "\015S" ) ;
1209 
	    break ;
1210 
	}
1211 
	case 12 : {
1212 
	    format ( VERT_BRACKETS, "dg_fixed_point_type", "\015x?[x]?[x]" ) ;
1213 
	    break ;
1214 
	}
1215 
	case 13 : {
1216 
	    format ( VERT_BRACKETS, "dg_float_type", "Yf" ) ;
1217 
	    break ;
1218 
	}
1219 
	case 14 : {
1220 
	    format ( VERT_BRACKETS, "dg_floating_digits_type", "\015x" ) ;
1221 
	    break ;
1222 
	}
1223 
	case 15 : {
1224 
	    format ( VERT_BRACKETS, "dg_inlined_type", "\015J" ) ;
1225 
	    break ;
1226 
	}
1227 
	case 16 : {
1228 
	    format ( VERT_BRACKETS, "dg_integer_type", "Yv" ) ;
1229 
	    break ;
1230 
	}
1231 
	case 17 : {
1232 
	    format ( VERT_BRACKETS, "dg_is_spec_type", "\015" ) ;
1233 
	    break ;
1234 
	}
1235 
	case 18 : {
1236 
	    format ( VERT_BRACKETS, "dg_modular_type", "\015x" ) ;
1237 
	    break ;
1238 
	}
1239 
	case 19 : {
1240 
	    format ( VERT_BRACKETS, "dg_named_type", "J" ) ;
1241 
	    break ;
1242 
	}
1243 
	case 20 : {
1244 
	    format ( VERT_BRACKETS, "dg_packed_type", "\015S" ) ;
1245 
	    break ;
1246 
	}
1247 
	case 21 : {
1248 
	    format ( VERT_BRACKETS, "dg_pointer_type", "\015?[b]" ) ;
1249 
	    break ;
1250 
	}
1251 
	case 22 : {
1252 
	    format ( VERT_BRACKETS, "dg_proc_type", "*[p]\015?[b]?[n]?[n]?[P]" ) ;
1253 
	    break ;
1254 
	}
1255 
	case 23 : {
1256 
	    format ( VERT_BRACKETS, "dg_ptr_memdata_type", "J\015S?[J]" ) ;
1257 
	    break ;
1258 
	}
1259 
	case 24 : {
1260 
	    format ( VERT_BRACKETS, "dg_ptr_memfn_type", "J\015S?[J]" ) ;
1261 
	    break ;
1262 
	}
1263 
	case 25 : {
1264 
	    format ( VERT_BRACKETS, "dg_qualified_type", "\014\015" ) ;
1265 
	    break ;
1266 
	}
1267 
	case 26 : {
1268 
	    format ( VERT_BRACKETS, "dg_reference_type", "\015" ) ;
1269 
	    break ;
1270 
	}
1271 
	case 27 : {
1272 
	    format ( VERT_BRACKETS, "dg_set_type", "\015S" ) ;
1273 
	    break ;
1274 
	}
1275 
	case 28 : {
1276 
	    format ( VERT_BRACKETS, "dg_spec_ref_type", "J\015" ) ;
1277 
	    break ;
1278 
	}
1279 
	case 29 : {
1280 
	    format ( VERT_BRACKETS, "dg_string_type", "Jxx" ) ;
1281 
	    break ;
1282 
	}
1283 
	case 30 : {
1284 
	    format ( VERT_BRACKETS, "dg_struct_type", "*[z]?[S]?[Y]?[W]?[\017]bb" ) ;
1285 
	    break ;
1286 
	}
1287 
	case 31 : {
1288 
	    format ( VERT_BRACKETS, "dg_subrange_type", "\015ww" ) ;
1289 
	    break ;
1290 
	}
1291 
	case 32 : {
1292 
	    format ( VERT_BRACKETS, "dg_synchronous_type", "YW*[h]J*[z]?[\017]?[S]b?[J]" ) ;
1293 
	    break ;
1294 
	}
1295 
	case 33 : {
1296 
	    format ( VERT_BRACKETS, "dg_task_type", "YW*[h]JJ*[z]?[\017]?[S]b?[J]" ) ;
1297 
	    break ;
1298 
	}
1299 
	case 34 : {
1300 
	    format ( VERT_BRACKETS, "dg_unknown_type", "S" ) ;
1301 
	    break ;
1302 
	}
1303 
	case 35 : {
1304 
	    out ( "dg_void_type" ) ;
1305 
	    break ;
1306 
	}
1307 
	default : {
1308 
	    out ( "<error>" ) ;
1309 
	    input_error ( "Illegal DG_TYPE value, %ld", n ) ;
1310 
	    n = -1 ;
1311 
	    break ;
1312 
	}
1313 
    }
1314 
    return ( n ) ;
1315 
}
1316 
 
1317 
 
1318 
/* DECODE A DG_VARIANT */
1319 
 
1320 
long de_dg_variant
1321 
    PROTO_Z ()
1322 
{
1323 
    long n = fetch_extn ( 1 ) ;
1324 
    switch ( n ) {
1325 
	case 1 : {
1326 
	    format ( VERT_BRACKETS, "make_dg_variant", "*[K]*[z]" ) ;
1327 
	    break ;
1328 
	}
1329 
	default : {
1330 
	    out ( "<error>" ) ;
1331 
	    input_error ( "Illegal DG_VARIANT value, %ld", n ) ;
1332 
	    n = -1 ;
1333 
	    break ;
1334 
	}
1335 
    }
1336 
    return ( n ) ;
1337 
}
1338 
 
1339 
 
1340 
/* DECODE A DG_VARPART */
1341 
 
1342 
long de_dg_varpart
1343 
    PROTO_Z ()
1344 
{
1345 
    long n = fetch_extn ( 2 ) ;
1346 
    switch ( n ) {
1347 
	case 1 : {
1348 
	    format ( VERT_BRACKETS, "dg_discrim_varpart", "z*[\016]" ) ;
1349 
	    break ;
1350 
	}
1351 
	case 2 : {
1352 
	    format ( VERT_BRACKETS, "dg_sibl_discrim_varpart", "J*[\016]" ) ;
1353 
	    break ;
1354 
	}
1355 
	case 3 : {
1356 
	    format ( VERT_BRACKETS, "dg_undiscrim_varpart", "\015*[\016]" ) ;
1357 
	    break ;
1358 
	}
1359 
	default : {
1360 
	    out ( "<error>" ) ;
1361 
	    input_error ( "Illegal DG_VARPART value, %ld", n ) ;
1362 
	    n = -1 ;
1363 
	    break ;
1364 
	}
1365 
    }
1366 
    return ( n ) ;
1367 
}
1368 
 
1369 
 
1370 
/* DECODE A DG_VIRTUALITY */
1371 
 
1372 
long de_dg_virtuality
1373 
    PROTO_Z ()
1374 
{
1375 
    long n = fetch_extn ( 2 ) ;
1376 
    switch ( n ) {
1377 
	case 1 : {
1378 
	    out ( "dg_abstract_virtuality" ) ;
1379 
	    break ;
1380 
	}
1381 
	case 2 : {
1382 
	    out ( "dg_virtual_virtuality" ) ;
1383 
	    break ;
1384 
	}
1385 
	default : {
1386 
	    out ( "<error>" ) ;
1387 
	    input_error ( "Illegal DG_VIRTUALITY value, %ld", n ) ;
1388 
	    n = -1 ;
1389 
	    break ;
1390 
	}
1391 
    }
1392 
    return ( n ) ;
1393 
}
1394 
 
1395 
 
1396 
/* DECODE A DIAG_DESCRIPTOR */
1397 
 
1398 
long de_diag_descriptor
1399 
    PROTO_Z ()
1400 
{
1401 
    long n = fetch_extn ( 2 ) ;
1402 
    switch ( n ) {
1403 
	case 1 : {
1404 
	    format ( VERT_BRACKETS, "diag_desc_id", "$Mxd" ) ;
1405 
	    break ;
1406 
	}
1407 
	case 2 : {
1408 
	    format ( VERT_BRACKETS, "diag_desc_struct", "$Md" ) ;
1409 
	    break ;
1410 
	}
1411 
	case 3 : {
1412 
	    format ( VERT_BRACKETS, "diag_desc_typedef", "$Md" ) ;
1413 
	    break ;
1414 
	}
1415 
	default : {
1416 
	    out ( "<error>" ) ;
1417 
	    input_error ( "Illegal DIAG_DESCRIPTOR value, %ld", n ) ;
1418 
	    n = -1 ;
1419 
	    break ;
1420 
	}
1421 
    }
1422 
    return ( n ) ;
1423 
}
1424 
 
1425 
 
1426 
/* DECODE A DIAG_TAG */
1427 
 
1428 
long de_diag_tag
1429 
    PROTO_Z ()
1430 
{
1431 
    long n = fetch_extn ( 1 ) ;
1432 
    switch ( n ) {
1433 
	case 1 : {
1434 
	    long t = tdf_int () ;
1435 
	    out_object ( t, ( object * ) null, var_diag_tag ) ;
1436 
	    break ;
1437 
	}
1438 
	default : {
1439 
	    out ( "<error>" ) ;
1440 
	    input_error ( "Illegal DIAG_TAG value, %ld", n ) ;
1441 
	    n = -1 ;
1442 
	    break ;
1443 
	}
1444 
    }
1445 
    return ( n ) ;
1446 
}
1447 
 
1448 
 
1449 
/* DECODE A DIAG_TAGDEF */
1450 
 
1451 
long de_diag_tagdef
1452 
    PROTO_Z ()
1453 
{
1454 
    long n = fetch_extn ( 1 ) ;
1455 
    if ( n < 1 || n > 1 ) {
1456 
	out ( "<error>" ) ;
1457 
	input_error ( "Illegal DIAG_TAGDEF value, %ld", n ) ;
1458 
	n = -1 ;
1459 
    }
1460 
    return ( n ) ;
1461 
}
1462 
 
1463 
 
1464 
/* DECODE A DIAG_TQ */
1465 
 
1466 
long de_diag_tq
1467 
    PROTO_Z ()
1468 
{
1469 
    long n = fetch_extn ( 2 ) ;
1470 
    switch ( n ) {
1471 
	case 1 : {
1472 
	    format ( VERT_BRACKETS, "add_diag_const", "g" ) ;
1473 
	    break ;
1474 
	}
1475 
	case 2 : {
1476 
	    format ( VERT_BRACKETS, "add_diag_volatile", "g" ) ;
1477 
	    break ;
1478 
	}
1479 
	case 3 : {
1480 
	    out ( "diag_tq_null" ) ;
1481 
	    break ;
1482 
	}
1483 
	default : {
1484 
	    out ( "<error>" ) ;
1485 
	    input_error ( "Illegal DIAG_TQ value, %ld", n ) ;
1486 
	    n = -1 ;
1487 
	    break ;
1488 
	}
1489 
    }
1490 
    return ( n ) ;
1491 
}
1492 
 
1493 
 
1494 
/* DECODE A DIAG_TYPE */
1495 
 
1496 
long de_diag_type
1497 
    PROTO_Z ()
1498 
{
1499 
    long n = fetch_extn ( 4 ) ;
1500 
    switch ( n ) {
1501 
	case 1 : {
1502 
	    sortname sn = find_sortname ( 'd' ) ;
1503 
	    IGNORE de_token_aux ( sn, "diag_type" ) ;
1504 
	    break ;
1505 
	}
1506 
	case 2 : {
1507 
	    format ( VERT_BRACKETS, "diag_array", "dxxxd" ) ;
1508 
	    break ;
1509 
	}
1510 
	case 3 : {
1511 
	    format ( HORIZ_BRACKETS, "diag_bitfield", "dn" ) ;
1512 
	    break ;
1513 
	}
1514 
	case 4 : {
1515 
	    format ( VERT_BRACKETS, "diag_enum", "d$*[x$]" ) ;
1516 
	    break ;
1517 
	}
1518 
	case 5 : {
1519 
	    format ( VERT_BRACKETS, "diag_floating_variety", "f" ) ;
1520 
	    break ;
1521 
	}
1522 
	case 6 : {
1523 
	    format ( VERT_BRACKETS, "diag_loc", "dg" ) ;
1524 
	    break ;
1525 
	}
1526 
	case 7 : {
1527 
	    format ( VERT_BRACKETS, "diag_proc", "*[d]bd" ) ;
1528 
	    break ;
1529 
	}
1530 
	case 8 : {
1531 
	    format ( VERT_BRACKETS, "diag_ptr", "dg" ) ;
1532 
	    break ;
1533 
	}
1534 
	case 9 : {
1535 
	    format ( VERT_BRACKETS, "diag_struct", "S$*[$xd]" ) ;
1536 
	    break ;
1537 
	}
1538 
	case 10 : {
1539 
	    out ( "diag_type_null" ) ;
1540 
	    break ;
1541 
	}
1542 
	case 11 : {
1543 
	    format ( VERT_BRACKETS, "diag_union", "S$*[$xd]" ) ;
1544 
	    break ;
1545 
	}
1546 
	case 12 : {
1547 
	    format ( VERT_BRACKETS, "diag_variety", "v" ) ;
1548 
	    break ;
1549 
	}
1550 
	case 13 : {
1551 
	    format ( VERT_BRACKETS, "use_diag_tag", "I" ) ;
1552 
	    break ;
1553 
	}
1554 
	default : {
1555 
	    out ( "<error>" ) ;
1556 
	    input_error ( "Illegal DIAG_TYPE value, %ld", n ) ;
1557 
	    n = -1 ;
1558 
	    break ;
1559 
	}
1560 
    }
1561 
    return ( n ) ;
1562 
}
1563 
 
1564 
 
1565 
/* DECODE A ERROR_CODE */
1566 
 
1567 
long de_error_code
1568 
    PROTO_Z ()
1569 
{
1570 
    long n = fetch_extn ( 2 ) ;
1571 
    switch ( n ) {
1572 
	case 1 : {
1573 
	    out ( "nil_access" ) ;
1574 
	    break ;
1575 
	}
1576 
	case 2 : {
1577 
	    out ( "overflow" ) ;
1578 
	    break ;
1579 
	}
1580 
	case 3 : {
1581 
	    out ( "stack_overflow" ) ;
1582 
	    break ;
1583 
	}
1584 
	default : {
1585 
	    out ( "<error>" ) ;
1586 
	    input_error ( "Illegal ERROR_CODE value, %ld", n ) ;
1587 
	    n = -1 ;
1588 
	    break ;
1589 
	}
1590 
    }
1591 
    return ( n ) ;
1592 
}
1593 
 
1594 
 
1595 
/* DECODE A ERROR_TREATMENT */
1596 
 
1597 
long de_error_treatment
1598 
    PROTO_Z ()
1599 
{
1600 
    long n = fetch_extn ( 3 ) ;
1601 
    switch ( n ) {
1602 
	case 1 : {
1603 
	    IGNORE de_token_aux ( sort_error_treatment, "error_treatment" ) ;
1604 
	    break ;
1605 
	}
1606 
	case 2 : {
1607 
	    format ( VERT_BRACKETS, "errt_cond", "x@[e]@[e]" ) ;
1608 
	    break ;
1609 
	}
1610 
	case 3 : {
1611 
	    out ( "continue" ) ;
1612 
	    break ;
1613 
	}
1614 
	case 4 : {
1615 
	    format ( VERT_BRACKETS, "error_jump", "l" ) ;
1616 
	    break ;
1617 
	}
1618 
	case 5 : {
1619 
	    format ( VERT_BRACKETS, "trap", "*[c]" ) ;
1620 
	    break ;
1621 
	}
1622 
	case 6 : {
1623 
	    out ( "wrap" ) ;
1624 
	    break ;
1625 
	}
1626 
	case 7 : {
1627 
	    out ( "impossible" ) ;
1628 
	    break ;
1629 
	}
1630 
	default : {
1631 
	    out ( "<error>" ) ;
1632 
	    input_error ( "Illegal ERROR_TREATMENT value, %ld", n ) ;
1633 
	    n = -1 ;
1634 
	    break ;
1635 
	}
1636 
    }
1637 
    return ( n ) ;
1638 
}
1639 
 
1640 
 
1641 
/* DECODE A EXP */
1642 
 
1643 
long de_exp
1644 
    PROTO_Z ()
1645 
{
1646 
    long n = fetch_extn ( 7 ) ;
1647 
    switch ( n ) {
1648 
	case 1 : {
1649 
	    IGNORE de_token_aux ( sort_exp, "exp" ) ;
1650 
	    break ;
1651 
	}
1652 
	case 2 : {
1653 
	    format ( VERT_BRACKETS, "exp_cond", "x@[x]@[x]" ) ;
1654 
	    break ;
1655 
	}
1656 
	case 3 : {
1657 
	    format ( VERT_BRACKETS, "abs", "ex" ) ;
1658 
	    break ;
1659 
	}
1660 
	case 4 : {
1661 
	    format ( VERT_BRACKETS, "add_to_ptr", "xx" ) ;
1662 
	    break ;
1663 
	}
1664 
	case 5 : {
1665 
	    format ( VERT_BRACKETS, "and", "xx" ) ;
1666 
	    break ;
1667 
	}
1668 
	case 6 : {
1669 
	    format ( VERT_BRACKETS, "apply_proc", "Sx*[x]?[x]" ) ;
1670 
	    break ;
1671 
	}
1672 
	case 7 : {
1673 
	    format ( VERT_BRACKETS, "apply_general_proc", "S?[P]x*[?[t&]x]q{x}" ) ;
1674 
	    break ;
1675 
	}
1676 
	case 8 : {
1677 
	    format ( VERT_BRACKETS, "assign", "xx" ) ;
1678 
	    break ;
1679 
	}
1680 
	case 9 : {
1681 
	    format ( VERT_BRACKETS, "assign_with_mode", "mxx" ) ;
1682 
	    break ;
1683 
	}
1684 
	case 10 : {
1685 
	    format ( VERT_BRACKETS, "bitfield_assign", "xxx" ) ;
1686 
	    break ;
1687 
	}
1688 
	case 11 : {
1689 
	    format ( VERT_BRACKETS, "bitfield_assign_with_mode", "mxxx" ) ;
1690 
	    break ;
1691 
	}
1692 
	case 12 : {
1693 
	    format ( VERT_BRACKETS, "bitfield_contents", "Bxx" ) ;
1694 
	    break ;
1695 
	}
1696 
	case 13 : {
1697 
	    format ( VERT_BRACKETS, "bitfield_contents_with_mode", "mBxx" ) ;
1698 
	    break ;
1699 
	}
1700 
	case 14 : {
1701 
	    /* Decode string "bx*[lss]" */
1702 
	    de_case ( "case" ) ;
1703 
	    break ;
1704 
	}
1705 
	case 15 : {
1706 
	    format ( VERT_BRACKETS, "change_bitfield_to_int", "vx" ) ;
1707 
	    break ;
1708 
	}
1709 
	case 16 : {
1710 
	    format ( VERT_BRACKETS, "change_floating_variety", "efx" ) ;
1711 
	    break ;
1712 
	}
1713 
	case 17 : {
1714 
	    format ( VERT_BRACKETS, "change_variety", "evx" ) ;
1715 
	    break ;
1716 
	}
1717 
	case 18 : {
1718 
	    format ( VERT_BRACKETS, "change_int_to_bitfield", "Bx" ) ;
1719 
	    break ;
1720 
	}
1721 
	case 19 : {
1722 
	    format ( VERT_BRACKETS, "complex_conjugate", "x" ) ;
1723 
	    break ;
1724 
	}
1725 
	case 20 : {
1726 
	    format ( VERT_BRACKETS, "component", "Sxx" ) ;
1727 
	    break ;
1728 
	}
1729 
	case 21 : {
1730 
	    format ( VERT_BRACKETS, "concat_nof", "xx" ) ;
1731 
	    break ;
1732 
	}
1733 
	case 22 : {
1734 
	    format ( VERT_BRACKETS, "conditional", "l&{xx}" ) ;
1735 
	    break ;
1736 
	}
1737 
	case 23 : {
1738 
	    format ( VERT_BRACKETS, "contents", "Sx" ) ;
1739 
	    break ;
1740 
	}
1741 
	case 24 : {
1742 
	    format ( VERT_BRACKETS, "contents_with_mode", "mSx" ) ;
1743 
	    break ;
1744 
	}
1745 
	case 25 : {
1746 
	    out ( "current_env" ) ;
1747 
	    break ;
1748 
	}
1749 
	case 26 : {
1750 
	    format ( VERT_BRACKETS, "div0", "eexx" ) ;
1751 
	    break ;
1752 
	}
1753 
	case 27 : {
1754 
	    format ( VERT_BRACKETS, "div1", "eexx" ) ;
1755 
	    break ;
1756 
	}
1757 
	case 28 : {
1758 
	    format ( VERT_BRACKETS, "div2", "eexx" ) ;
1759 
	    break ;
1760 
	}
1761 
	case 29 : {
1762 
	    format ( VERT_BRACKETS, "env_offset", "aat" ) ;
1763 
	    break ;
1764 
	}
1765 
	case 30 : {
1766 
	    format ( VERT_BRACKETS, "env_size", "t" ) ;
1767 
	    break ;
1768 
	}
1769 
	case 31 : {
1770 
	    format ( VERT_BRACKETS, "fail_installer", "X" ) ;
1771 
	    break ;
1772 
	}
1773 
	case 32 : {
1774 
	    format ( VERT_BRACKETS, "float_int", "efx" ) ;
1775 
	    break ;
1776 
	}
1777 
	case 33 : {
1778 
	    format ( VERT_BRACKETS, "floating_abs", "ex" ) ;
1779 
	    break ;
1780 
	}
1781 
	case 34 : {
1782 
	    format ( VERT_BRACKETS, "floating_div", "exx" ) ;
1783 
	    break ;
1784 
	}
1785 
	case 35 : {
1786 
	    format ( VERT_BRACKETS, "floating_minus", "exx" ) ;
1787 
	    break ;
1788 
	}
1789 
	case 36 : {
1790 
	    format ( VERT_BRACKETS, "floating_maximum", "exx" ) ;
1791 
	    break ;
1792 
	}
1793 
	case 37 : {
1794 
	    format ( VERT_BRACKETS, "floating_minimum", "exx" ) ;
1795 
	    break ;
1796 
	}
1797 
	case 38 : {
1798 
	    format ( VERT_BRACKETS, "floating_mult", "e*[x]" ) ;
1799 
	    break ;
1800 
	}
1801 
	case 39 : {
1802 
	    format ( VERT_BRACKETS, "floating_negate", "ex" ) ;
1803 
	    break ;
1804 
	}
1805 
	case 40 : {
1806 
	    format ( VERT_BRACKETS, "floating_plus", "e*[x]" ) ;
1807 
	    break ;
1808 
	}
1809 
	case 41 : {
1810 
	    format ( VERT_BRACKETS, "floating_power", "exx" ) ;
1811 
	    break ;
1812 
	}
1813 
	case 42 : {
1814 
	    format ( VERT_BRACKETS, "floating_test", "?[n]eNlxx" ) ;
1815 
	    break ;
1816 
	}
1817 
	case 43 : {
1818 
	    format ( VERT_BRACKETS, "goto", "l" ) ;
1819 
	    break ;
1820 
	}
1821 
	case 44 : {
1822 
	    format ( VERT_BRACKETS, "goto_local_lv", "x" ) ;
1823 
	    break ;
1824 
	}
1825 
	case 45 : {
1826 
	    format ( VERT_BRACKETS, "identify", "?[u]t&x{x}" ) ;
1827 
	    break ;
1828 
	}
1829 
	case 46 : {
1830 
	    format ( VERT_BRACKETS, "ignorable", "x" ) ;
1831 
	    break ;
1832 
	}
1833 
	case 47 : {
1834 
	    format ( VERT_BRACKETS, "imaginary_part", "x" ) ;
1835 
	    break ;
1836 
	}
1837 
	case 48 : {
1838 
	    format ( VERT_BRACKETS, "initial_value", "{x}" ) ;
1839 
	    break ;
1840 
	}
1841 
	case 49 : {
1842 
	    format ( VERT_BRACKETS, "integer_test", "?[n]Nlxx" ) ;
1843 
	    break ;
1844 
	}
1845 
	case 50 : {
1846 
	    /* Decode string "*[l&]{x*[x]}" */
1847 
	    de_labelled ( "labelled" ) ;
1848 
	    break ;
1849 
	}
1850 
	case 51 : {
1851 
	    format ( VERT_BRACKETS, "last_local", "x" ) ;
1852 
	    break ;
1853 
	}
1854 
	case 52 : {
1855 
	    format ( VERT_BRACKETS, "local_alloc", "x" ) ;
1856 
	    break ;
1857 
	}
1858 
	case 53 : {
1859 
	    format ( VERT_BRACKETS, "local_alloc_check", "x" ) ;
1860 
	    break ;
1861 
	}
1862 
	case 54 : {
1863 
	    format ( VERT_BRACKETS, "local_free", "xx" ) ;
1864 
	    break ;
1865 
	}
1866 
	case 55 : {
1867 
	    out ( "local_free_all" ) ;
1868 
	    break ;
1869 
	}
1870 
	case 56 : {
1871 
	    format ( VERT_BRACKETS, "long_jump", "xx" ) ;
1872 
	    break ;
1873 
	}
1874 
	case 57 : {
1875 
	    format ( VERT_BRACKETS, "make_complex", "fxx" ) ;
1876 
	    break ;
1877 
	}
1878 
	case 58 : {
1879 
	    format ( VERT_BRACKETS, "make_compound", "x*[x]" ) ;
1880 
	    break ;
1881 
	}
1882 
	case 59 : {
1883 
	    format ( VERT_BRACKETS, "make_floating", "frbXns" ) ;
1884 
	    break ;
1885 
	}
1886 
	case 60 : {
1887 
	    format ( VERT_BRACKETS, "make_general_proc", "S?[P]*[S?[u]t&]*[S?[u]t&]{x}" ) ;
1888 
	    break ;
1889 
	}
1890 
	case 61 : {
1891 
	    format ( HORIZ_BRACKETS, "make_int", "vs" ) ;
1892 
	    break ;
1893 
	}
1894 
	case 62 : {
1895 
	    format ( VERT_BRACKETS, "make_local_lv", "l" ) ;
1896 
	    break ;
1897 
	}
1898 
	case 63 : {
1899 
	    format ( VERT_BRACKETS, "make_nof", "*[x]" ) ;
1900 
	    break ;
1901 
	}
1902 
	case 64 : {
1903 
	    format ( VERT_BRACKETS, "make_nof_int", "vX" ) ;
1904 
	    break ;
1905 
	}
1906 
	case 65 : {
1907 
	    out ( "make_null_local_lv" ) ;
1908 
	    break ;
1909 
	}
1910 
	case 66 : {
1911 
	    out ( "make_null_proc" ) ;
1912 
	    break ;
1913 
	}
1914 
	case 67 : {
1915 
	    format ( VERT_BRACKETS, "make_null_ptr", "a" ) ;
1916 
	    break ;
1917 
	}
1918 
	case 68 : {
1919 
	    /* Decode string "S*[S?[u]t&]?[t&?[u]]{x}" */
1920 
	    de_make_proc ( "make_proc" ) ;
1921 
	    break ;
1922 
	}
1923 
	case 116 : {
1924 
	    format ( VERT_BRACKETS, "make_stack_limit", "xxx" ) ;
1925 
	    break ;
1926 
	}
1927 
	case 69 : {
1928 
	    out ( "make_top" ) ;
1929 
	    break ;
1930 
	}
1931 
	case 70 : {
1932 
	    format ( VERT_BRACKETS, "make_value", "S" ) ;
1933 
	    break ;
1934 
	}
1935 
	case 71 : {
1936 
	    format ( VERT_BRACKETS, "maximum", "xx" ) ;
1937 
	    break ;
1938 
	}
1939 
	case 72 : {
1940 
	    format ( VERT_BRACKETS, "minimum", "xx" ) ;
1941 
	    break ;
1942 
	}
1943 
	case 73 : {
1944 
	    format ( VERT_BRACKETS, "minus", "exx" ) ;
1945 
	    break ;
1946 
	}
1947 
	case 74 : {
1948 
	    format ( VERT_BRACKETS, "move_some", "mxxx" ) ;
1949 
	    break ;
1950 
	}
1951 
	case 75 : {
1952 
	    format ( VERT_BRACKETS, "mult", "exx" ) ;
1953 
	    break ;
1954 
	}
1955 
	case 76 : {
1956 
	    format ( VERT_BRACKETS, "n_copies", "nx" ) ;
1957 
	    break ;
1958 
	}
1959 
	case 77 : {
1960 
	    format ( VERT_BRACKETS, "negate", "ex" ) ;
1961 
	    break ;
1962 
	}
1963 
	case 78 : {
1964 
	    format ( VERT_BRACKETS, "not", "x" ) ;
1965 
	    break ;
1966 
	}
1967 
	case 79 : {
1968 
	    format ( HORIZ_BRACKETS, "obtain_tag", "t" ) ;
1969 
	    break ;
1970 
	}
1971 
	case 80 : {
1972 
	    format ( VERT_BRACKETS, "offset_add", "xx" ) ;
1973 
	    break ;
1974 
	}
1975 
	case 81 : {
1976 
	    format ( VERT_BRACKETS, "offset_div", "vxx" ) ;
1977 
	    break ;
1978 
	}
1979 
	case 82 : {
1980 
	    format ( VERT_BRACKETS, "offset_div_by_int", "xx" ) ;
1981 
	    break ;
1982 
	}
1983 
	case 83 : {
1984 
	    format ( VERT_BRACKETS, "offset_max", "xx" ) ;
1985 
	    break ;
1986 
	}
1987 
	case 84 : {
1988 
	    format ( VERT_BRACKETS, "offset_mult", "xx" ) ;
1989 
	    break ;
1990 
	}
1991 
	case 85 : {
1992 
	    format ( VERT_BRACKETS, "offset_negate", "x" ) ;
1993 
	    break ;
1994 
	}
1995 
	case 86 : {
1996 
	    format ( VERT_BRACKETS, "offset_pad", "ax" ) ;
1997 
	    break ;
1998 
	}
1999 
	case 87 : {
2000 
	    format ( VERT_BRACKETS, "offset_subtract", "xx" ) ;
2001 
	    break ;
2002 
	}
2003 
	case 88 : {
2004 
	    format ( VERT_BRACKETS, "offset_test", "?[n]Nlxx" ) ;
2005 
	    break ;
2006 
	}
2007 
	case 89 : {
2008 
	    format ( HORIZ_BRACKETS, "offset_zero", "a" ) ;
2009 
	    break ;
2010 
	}
2011 
	case 90 : {
2012 
	    format ( VERT_BRACKETS, "or", "xx" ) ;
2013 
	    break ;
2014 
	}
2015 
	case 91 : {
2016 
	    format ( VERT_BRACKETS, "plus", "exx" ) ;
2017 
	    break ;
2018 
	}
2019 
	case 92 : {
2020 
	    format ( VERT_BRACKETS, "pointer_test", "?[n]Nlxx" ) ;
2021 
	    break ;
2022 
	}
2023 
	case 93 : {
2024 
	    format ( VERT_BRACKETS, "power", "exx" ) ;
2025 
	    break ;
2026 
	}
2027 
	case 94 : {
2028 
	    format ( VERT_BRACKETS, "proc_test", "?[n]Nlxx" ) ;
2029 
	    break ;
2030 
	}
2031 
	case 95 : {
2032 
	    format ( VERT_BRACKETS, "profile", "n" ) ;
2033 
	    break ;
2034 
	}
2035 
	case 96 : {
2036 
	    format ( VERT_BRACKETS, "real_part", "x" ) ;
2037 
	    break ;
2038 
	}
2039 
	case 97 : {
2040 
	    format ( VERT_BRACKETS, "rem0", "eexx" ) ;
2041 
	    break ;
2042 
	}
2043 
	case 98 : {
2044 
	    format ( VERT_BRACKETS, "rem1", "eexx" ) ;
2045 
	    break ;
2046 
	}
2047 
	case 99 : {
2048 
	    format ( VERT_BRACKETS, "rem2", "eexx" ) ;
2049 
	    break ;
2050 
	}
2051 
	case 100 : {
2052 
	    format ( VERT_BRACKETS, "repeat", "l&{xx}" ) ;
2053 
	    break ;
2054 
	}
2055 
	case 101 : {
2056 
	    format ( VERT_BRACKETS, "return", "x" ) ;
2057 
	    break ;
2058 
	}
2059 
	case 102 : {
2060 
	    format ( VERT_BRACKETS, "return_to_label", "x" ) ;
2061 
	    break ;
2062 
	}
2063 
	case 103 : {
2064 
	    format ( VERT_BRACKETS, "round_with_mode", "ervx" ) ;
2065 
	    break ;
2066 
	}
2067 
	case 104 : {
2068 
	    format ( VERT_BRACKETS, "rotate_left", "xx" ) ;
2069 
	    break ;
2070 
	}
2071 
	case 105 : {
2072 
	    format ( VERT_BRACKETS, "rotate_right", "xx" ) ;
2073 
	    break ;
2074 
	}
2075 
	case 106 : {
2076 
	    /* Decode string "*[x]x" */
2077 
	    de_sequence ( "sequence" ) ;
2078 
	    break ;
2079 
	}
2080 
	case 107 : {
2081 
	    format ( VERT_BRACKETS, "set_stack_limit", "x" ) ;
2082 
	    break ;
2083 
	}
2084 
	case 108 : {
2085 
	    format ( VERT_BRACKETS, "shape_offset", "S" ) ;
2086 
	    break ;
2087 
	}
2088 
	case 109 : {
2089 
	    format ( VERT_BRACKETS, "shift_left", "exx" ) ;
2090 
	    break ;
2091 
	}
2092 
	case 110 : {
2093 
	    format ( VERT_BRACKETS, "shift_right", "xx" ) ;
2094 
	    break ;
2095 
	}
2096 
	case 111 : {
2097 
	    format ( VERT_BRACKETS, "subtract_ptrs", "xx" ) ;
2098 
	    break ;
2099 
	}
2100 
	case 112 : {
2101 
	    format ( VERT_BRACKETS, "tail_call", "?[P]xq" ) ;
2102 
	    break ;
2103 
	}
2104 
	case 113 : {
2105 
	    format ( VERT_BRACKETS, "untidy_return", "x" ) ;
2106 
	    break ;
2107 
	}
2108 
	case 114 : {
2109 
	    format ( VERT_BRACKETS, "variable", "?[u]t&x{x}" ) ;
2110 
	    break ;
2111 
	}
2112 
	case 115 : {
2113 
	    format ( VERT_BRACKETS, "xor", "xx" ) ;
2114 
	    break ;
2115 
	}
2116 
	default : {
2117 
	    out ( "<error>" ) ;
2118 
	    input_error ( "Illegal EXP value, %ld", n ) ;
2119 
	    n = -1 ;
2120 
	    break ;
2121 
	}
2122 
    }
2123 
    return ( n ) ;
2124 
}
2125 
 
2126 
 
2127 
/* DECODE A EXTERNAL */
2128 
 
2129 
long de_external
2130 
    PROTO_Z ()
2131 
{
2132 
    long n = fetch_extn ( 2 ) ;
2133 
    if ( n < 1 || n > 3 ) {
2134 
	out ( "<error>" ) ;
2135 
	input_error ( "Illegal EXTERNAL value, %ld", n ) ;
2136 
	n = -1 ;
2137 
    }
2138 
    return ( n ) ;
2139 
}
2140 
 
2141 
 
2142 
/* DECODE A FILENAME */
2143 
 
2144 
long de_filename
2145 
    PROTO_Z ()
2146 
{
2147 
    long n = fetch_extn ( 2 ) ;
2148 
    switch ( n ) {
2149 
	case 1 : {
2150 
	    sortname sn = find_sortname ( 'Q' ) ;
2151 
	    IGNORE de_token_aux ( sn, "filename" ) ;
2152 
	    break ;
2153 
	}
2154 
	case 2 : {
2155 
	    format ( VERT_BRACKETS, "make_filename", "n$$" ) ;
2156 
	    break ;
2157 
	}
2158 
	default : {
2159 
	    out ( "<error>" ) ;
2160 
	    input_error ( "Illegal FILENAME value, %ld", n ) ;
2161 
	    n = -1 ;
2162 
	    break ;
2163 
	}
2164 
    }
2165 
    return ( n ) ;
2166 
}
2167 
 
2168 
 
2169 
/* DECODE A FLOATING_VARIETY */
2170 
 
2171 
long de_floating_variety
2172 
    PROTO_Z ()
2173 
{
2174 
    long n = fetch_extn ( 3 ) ;
2175 
    switch ( n ) {
2176 
	case 1 : {
2177 
	    IGNORE de_token_aux ( sort_floating_variety, "floating_variety" ) ;
2178 
	    break ;
2179 
	}
2180 
	case 2 : {
2181 
	    format ( VERT_BRACKETS, "flvar_cond", "x@[f]@[f]" ) ;
2182 
	    break ;
2183 
	}
2184 
	case 3 : {
2185 
	    format ( HORIZ_BRACKETS, "flvar_parms", "nnnn" ) ;
2186 
	    break ;
2187 
	}
2188 
	case 4 : {
2189 
	    format ( VERT_BRACKETS, "complex_parms", "nnnn" ) ;
2190 
	    break ;
2191 
	}
2192 
	case 5 : {
2193 
	    format ( VERT_BRACKETS, "float_of_complex", "S" ) ;
2194 
	    break ;
2195 
	}
2196 
	case 6 : {
2197 
	    format ( VERT_BRACKETS, "complex_of_float", "S" ) ;
2198 
	    break ;
2199 
	}
2200 
	default : {
2201 
	    out ( "<error>" ) ;
2202 
	    input_error ( "Illegal FLOATING_VARIETY value, %ld", n ) ;
2203 
	    n = -1 ;
2204 
	    break ;
2205 
	}
2206 
    }
2207 
    return ( n ) ;
2208 
}
2209 
 
2210 
 
2211 
/* DECODE A LABEL */
2212 
 
2213 
long de_label
2214 
    PROTO_Z ()
2215 
{
2216 
    long n = fetch_extn ( 1 ) ;
2217 
    switch ( n ) {
2218 
	case 2 : {
2219 
	    IGNORE de_token_aux ( sort_label, "label" ) ;
2220 
	    break ;
2221 
	}
2222 
	case 1 : {
2223 
	    long t = tdf_int () ;
2224 
	    de_make_label ( t ) ;
2225 
	    break ;
2226 
	}
2227 
	default : {
2228 
	    out ( "<error>" ) ;
2229 
	    input_error ( "Illegal LABEL value, %ld", n ) ;
2230 
	    n = -1 ;
2231 
	    break ;
2232 
	}
2233 
    }
2234 
    return ( n ) ;
2235 
}
2236 
 
2237 
 
2238 
/* DECODE A LINKINFO */
2239 
 
2240 
long de_linkinfo
2241 
    PROTO_Z ()
2242 
{
2243 
    long n = fetch_extn ( 2 ) ;
2244 
    switch ( n ) {
2245 
	case 1 : {
2246 
	    format ( VERT_BRACKETS, "static_name_def", "x$" ) ;
2247 
	    break ;
2248 
	}
2249 
	case 2 : {
2250 
	    format ( VERT_BRACKETS, "make_comment", "$" ) ;
2251 
	    break ;
2252 
	}
2253 
	case 3 : {
2254 
	    format ( VERT_BRACKETS, "make_weak_defn", "xx" ) ;
2255 
	    break ;
2256 
	}
2257 
	case 4 : {
2258 
	    format ( VERT_BRACKETS, "make_weak_symbol", "$x" ) ;
2259 
	    break ;
2260 
	}
2261 
	default : {
2262 
	    out ( "<error>" ) ;
2263 
	    input_error ( "Illegal LINKINFO value, %ld", n ) ;
2264 
	    n = -1 ;
2265 
	    break ;
2266 
	}
2267 
    }
2268 
    return ( n ) ;
2269 
}
2270 
 
2271 
 
2272 
/* DECODE A NAT */
2273 
 
2274 
long de_nat
2275 
    PROTO_Z ()
2276 
{
2277 
    long n = fetch_extn ( 3 ) ;
2278 
    switch ( n ) {
2279 
	case 1 : {
2280 
	    IGNORE de_token_aux ( sort_nat, "nat" ) ;
2281 
	    break ;
2282 
	}
2283 
	case 2 : {
2284 
	    format ( VERT_BRACKETS, "nat_cond", "x@[n]@[n]" ) ;
2285 
	    break ;
2286 
	}
2287 
	case 3 : {
2288 
	    format ( VERT_BRACKETS, "computed_nat", "x" ) ;
2289 
	    break ;
2290 
	}
2291 
	case 4 : {
2292 
	    format ( VERT_BRACKETS, "error_val", "c" ) ;
2293 
	    break ;
2294 
	}
2295 
	case 5 : {
2296 
	    /* Decode string "i" */
2297 
	    de_make_nat ( "make_nat" ) ;
2298 
	    break ;
2299 
	}
2300 
	default : {
2301 
	    out ( "<error>" ) ;
2302 
	    input_error ( "Illegal NAT value, %ld", n ) ;
2303 
	    n = -1 ;
2304 
	    break ;
2305 
	}
2306 
    }
2307 
    return ( n ) ;
2308 
}
2309 
 
2310 
 
2311 
/* DECODE A NTEST */
2312 
 
2313 
long de_ntest
2314 
    PROTO_Z ()
2315 
{
2316 
    long n = fetch_extn ( 4 ) ;
2317 
    switch ( n ) {
2318 
	case 1 : {
2319 
	    IGNORE de_token_aux ( sort_ntest, "ntest" ) ;
2320 
	    break ;
2321 
	}
2322 
	case 2 : {
2323 
	    format ( VERT_BRACKETS, "ntest_cond", "x@[N]@[N]" ) ;
2324 
	    break ;
2325 
	}
2326 
	case 3 : {
2327 
	    out ( "equal" ) ;
2328 
	    break ;
2329 
	}
2330 
	case 4 : {
2331 
	    out ( "greater_than" ) ;
2332 
	    break ;
2333 
	}
2334 
	case 5 : {
2335 
	    out ( "greater_than_or_equal" ) ;
2336 
	    break ;
2337 
	}
2338 
	case 6 : {
2339 
	    out ( "less_than" ) ;
2340 
	    break ;
2341 
	}
2342 
	case 7 : {
2343 
	    out ( "less_than_or_equal" ) ;
2344 
	    break ;
2345 
	}
2346 
	case 8 : {
2347 
	    out ( "not_equal" ) ;
2348 
	    break ;
2349 
	}
2350 
	case 9 : {
2351 
	    out ( "not_greater_than" ) ;
2352 
	    break ;
2353 
	}
2354 
	case 10 : {
2355 
	    out ( "not_greater_than_or_equal" ) ;
2356 
	    break ;
2357 
	}
2358 
	case 11 : {
2359 
	    out ( "not_less_than" ) ;
2360 
	    break ;
2361 
	}
2362 
	case 12 : {
2363 
	    out ( "not_less_than_or_equal" ) ;
2364 
	    break ;
2365 
	}
2366 
	case 13 : {
2367 
	    out ( "less_than_or_greater_than" ) ;
2368 
	    break ;
2369 
	}
2370 
	case 14 : {
2371 
	    out ( "not_less_than_and_not_greater_than" ) ;
2372 
	    break ;
2373 
	}
2374 
	case 15 : {
2375 
	    out ( "comparable" ) ;
2376 
	    break ;
2377 
	}
2378 
	case 16 : {
2379 
	    out ( "not_comparable" ) ;
2380 
	    break ;
2381 
	}
2382 
	default : {
2383 
	    out ( "<error>" ) ;
2384 
	    input_error ( "Illegal NTEST value, %ld", n ) ;
2385 
	    n = -1 ;
2386 
	    break ;
2387 
	}
2388 
    }
2389 
    return ( n ) ;
2390 
}
2391 
 
2392 
 
2393 
/* DECODE A PROCPROPS */
2394 
 
2395 
long de_procprops
2396 
    PROTO_Z ()
2397 
{
2398 
    long n = fetch_extn ( 4 ) ;
2399 
    switch ( n ) {
2400 
	case 1 : {
2401 
	    IGNORE de_token_aux ( sort_procprops, "procprops" ) ;
2402 
	    break ;
2403 
	}
2404 
	case 2 : {
2405 
	    format ( VERT_BRACKETS, "procprops_cond", "x@[P]@[P]" ) ;
2406 
	    break ;
2407 
	}
2408 
	case 3 : {
2409 
	    format ( VERT_BRACKETS, "add_procprops", "PP" ) ;
2410 
	    break ;
2411 
	}
2412 
	case 4 : {
2413 
	    out ( "check_stack" ) ;
2414 
	    break ;
2415 
	}
2416 
	case 5 : {
2417 
	    out ( "inline" ) ;
2418 
	    break ;
2419 
	}
2420 
	case 6 : {
2421 
	    out ( "no_long_jump_dest" ) ;
2422 
	    break ;
2423 
	}
2424 
	case 7 : {
2425 
	    out ( "untidy" ) ;
2426 
	    break ;
2427 
	}
2428 
	case 8 : {
2429 
	    out ( "var_callees" ) ;
2430 
	    break ;
2431 
	}
2432 
	case 9 : {
2433 
	    out ( "var_callers" ) ;
2434 
	    break ;
2435 
	}
2436 
	default : {
2437 
	    out ( "<error>" ) ;
2438 
	    input_error ( "Illegal PROCPROPS value, %ld", n ) ;
2439 
	    n = -1 ;
2440 
	    break ;
2441 
	}
2442 
    }
2443 
    return ( n ) ;
2444 
}
2445 
 
2446 
 
2447 
/* DECODE A ROUNDING_MODE */
2448 
 
2449 
long de_rounding_mode
2450 
    PROTO_Z ()
2451 
{
2452 
    long n = fetch_extn ( 3 ) ;
2453 
    switch ( n ) {
2454 
	case 1 : {
2455 
	    IGNORE de_token_aux ( sort_rounding_mode, "rounding_mode" ) ;
2456 
	    break ;
2457 
	}
2458 
	case 2 : {
2459 
	    format ( VERT_BRACKETS, "rounding_mode_cond", "x@[r]@[r]" ) ;
2460 
	    break ;
2461 
	}
2462 
	case 3 : {
2463 
	    out ( "round_as_state" ) ;
2464 
	    break ;
2465 
	}
2466 
	case 4 : {
2467 
	    out ( "to_nearest" ) ;
2468 
	    break ;
2469 
	}
2470 
	case 5 : {
2471 
	    out ( "toward_larger" ) ;
2472 
	    break ;
2473 
	}
2474 
	case 6 : {
2475 
	    out ( "toward_smaller" ) ;
2476 
	    break ;
2477 
	}
2478 
	case 7 : {
2479 
	    out ( "toward_zero" ) ;
2480 
	    break ;
2481 
	}
2482 
	default : {
2483 
	    out ( "<error>" ) ;
2484 
	    input_error ( "Illegal ROUNDING_MODE value, %ld", n ) ;
2485 
	    n = -1 ;
2486 
	    break ;
2487 
	}
2488 
    }
2489 
    return ( n ) ;
2490 
}
2491 
 
2492 
 
2493 
/* DECODE A SHAPE */
2494 
 
2495 
long de_shape
2496 
    PROTO_Z ()
2497 
{
2498 
    long n = fetch_extn ( 4 ) ;
2499 
    switch ( n ) {
2500 
	case 1 : {
2501 
	    IGNORE de_token_aux ( sort_shape, "shape" ) ;
2502 
	    break ;
2503 
	}
2504 
	case 2 : {
2505 
	    format ( VERT_BRACKETS, "shape_cond", "x@[S]@[S]" ) ;
2506 
	    break ;
2507 
	}
2508 
	case 3 : {
2509 
	    format ( VERT_BRACKETS, "bitfield", "B" ) ;
2510 
	    break ;
2511 
	}
2512 
	case 4 : {
2513 
	    out ( "bottom" ) ;
2514 
	    break ;
2515 
	}
2516 
	case 5 : {
2517 
	    format ( VERT_BRACKETS, "compound", "x" ) ;
2518 
	    break ;
2519 
	}
2520 
	case 6 : {
2521 
	    format ( VERT_BRACKETS, "floating", "f" ) ;
2522 
	    break ;
2523 
	}
2524 
	case 7 : {
2525 
	    format ( HORIZ_BRACKETS, "integer", "v" ) ;
2526 
	    break ;
2527 
	}
2528 
	case 8 : {
2529 
	    format ( HORIZ_BRACKETS, "nof", "nS" ) ;
2530 
	    break ;
2531 
	}
2532 
	case 9 : {
2533 
	    format ( VERT_BRACKETS, "offset", "aa" ) ;
2534 
	    break ;
2535 
	}
2536 
	case 10 : {
2537 
	    format ( HORIZ_BRACKETS, "pointer", "a" ) ;
2538 
	    break ;
2539 
	}
2540 
	case 11 : {
2541 
	    out ( "proc" ) ;
2542 
	    break ;
2543 
	}
2544 
	case 12 : {
2545 
	    out ( "top" ) ;
2546 
	    break ;
2547 
	}
2548 
	default : {
2549 
	    out ( "<error>" ) ;
2550 
	    input_error ( "Illegal SHAPE value, %ld", n ) ;
2551 
	    n = -1 ;
2552 
	    break ;
2553 
	}
2554 
    }
2555 
    return ( n ) ;
2556 
}
2557 
 
2558 
 
2559 
/* DECODE A SIGNED_NAT */
2560 
 
2561 
long de_signed_nat
2562 
    PROTO_Z ()
2563 
{
2564 
    long n = fetch_extn ( 3 ) ;
2565 
    switch ( n ) {
2566 
	case 1 : {
2567 
	    IGNORE de_token_aux ( sort_signed_nat, "signed_nat" ) ;
2568 
	    break ;
2569 
	}
2570 
	case 2 : {
2571 
	    format ( VERT_BRACKETS, "signed_nat_cond", "x@[s]@[s]" ) ;
2572 
	    break ;
2573 
	}
2574 
	case 3 : {
2575 
	    format ( VERT_BRACKETS, "computed_signed_nat", "x" ) ;
2576 
	    break ;
2577 
	}
2578 
	case 4 : {
2579 
	    /* Decode string "ji" */
2580 
	    de_make_signed_nat ( "make_signed_nat" ) ;
2581 
	    break ;
2582 
	}
2583 
	case 5 : {
2584 
	    format ( VERT_BRACKETS, "snat_from_nat", "bn" ) ;
2585 
	    break ;
2586 
	}
2587 
	default : {
2588 
	    out ( "<error>" ) ;
2589 
	    input_error ( "Illegal SIGNED_NAT value, %ld", n ) ;
2590 
	    n = -1 ;
2591 
	    break ;
2592 
	}
2593 
    }
2594 
    return ( n ) ;
2595 
}
2596 
 
2597 
 
2598 
/* DECODE A SORTNAME */
2599 
 
2600 
long de_sortname
2601 
    PROTO_Z ()
2602 
{
2603 
    long n = fetch_extn ( 5 ) ;
2604 
    if ( n < 1 || n > 21 ) {
2605 
	out ( "<error>" ) ;
2606 
	input_error ( "Illegal SORTNAME value, %ld", n ) ;
2607 
	n = -1 ;
2608 
    }
2609 
    return ( n ) ;
2610 
}
2611 
 
2612 
 
2613 
/* DECODE A SOURCEMARK */
2614 
 
2615 
long de_sourcemark
2616 
    PROTO_Z ()
2617 
{
2618 
    long n = fetch_extn ( 1 ) ;
2619 
    switch ( n ) {
2620 
	case 1 : {
2621 
	    format ( HORIZ_BRACKETS, "make_sourcemark", "Qnn" ) ;
2622 
	    break ;
2623 
	}
2624 
	default : {
2625 
	    out ( "<error>" ) ;
2626 
	    input_error ( "Illegal SOURCEMARK value, %ld", n ) ;
2627 
	    n = -1 ;
2628 
	    break ;
2629 
	}
2630 
    }
2631 
    return ( n ) ;
2632 
}
2633 
 
2634 
 
2635 
/* DECODE A STRING */
2636 
 
2637 
long de_string
2638 
    PROTO_Z ()
2639 
{
2640 
    long n = fetch_extn ( 3 ) ;
2641 
    switch ( n ) {
2642 
	case 1 : {
2643 
	    IGNORE de_token_aux ( sort_string, "string" ) ;
2644 
	    break ;
2645 
	}
2646 
	case 2 : {
2647 
	    format ( VERT_BRACKETS, "string_cond", "x@[X]@[X]" ) ;
2648 
	    break ;
2649 
	}
2650 
	case 3 : {
2651 
	    format ( VERT_BRACKETS, "concat_string", "XX" ) ;
2652 
	    break ;
2653 
	}
2654 
	case 4 : {
2655 
	    /* Decode string "$" */
2656 
	    de_make_string ( "make_string" ) ;
2657 
	    break ;
2658 
	}
2659 
	default : {
2660 
	    out ( "<error>" ) ;
2661 
	    input_error ( "Illegal STRING value, %ld", n ) ;
2662 
	    n = -1 ;
2663 
	    break ;
2664 
	}
2665 
    }
2666 
    return ( n ) ;
2667 
}
2668 
 
2669 
 
2670 
/* DECODE A TAG */
2671 
 
2672 
long de_tag
2673 
    PROTO_Z ()
2674 
{
2675 
    long n = fetch_extn ( 1 ) ;
2676 
    switch ( n ) {
2677 
	case 2 : {
2678 
	    IGNORE de_token_aux ( sort_tag, "tag" ) ;
2679 
	    break ;
2680 
	}
2681 
	case 1 : {
2682 
	    long t = tdf_int () ;
2683 
	    out_object ( t, ( object * ) null, var_tag ) ;
2684 
	    break ;
2685 
	}
2686 
	default : {
2687 
	    out ( "<error>" ) ;
2688 
	    input_error ( "Illegal TAG value, %ld", n ) ;
2689 
	    n = -1 ;
2690 
	    break ;
2691 
	}
2692 
    }
2693 
    return ( n ) ;
2694 
}
2695 
 
2696 
 
2697 
/* DECODE A TAGDEC */
2698 
 
2699 
long de_tagdec
2700 
    PROTO_Z ()
2701 
{
2702 
    long n = fetch_extn ( 2 ) ;
2703 
    if ( n < 1 || n > 3 ) {
2704 
	out ( "<error>" ) ;
2705 
	input_error ( "Illegal TAGDEC value, %ld", n ) ;
2706 
	n = -1 ;
2707 
    }
2708 
    return ( n ) ;
2709 
}
2710 
 
2711 
 
2712 
/* DECODE A TAGDEF */
2713 
 
2714 
long de_tagdef
2715 
    PROTO_Z ()
2716 
{
2717 
    long n = fetch_extn ( 2 ) ;
2718 
    if ( n < 1 || n > 3 ) {
2719 
	out ( "<error>" ) ;
2720 
	input_error ( "Illegal TAGDEF value, %ld", n ) ;
2721 
	n = -1 ;
2722 
    }
2723 
    return ( n ) ;
2724 
}
2725 
 
2726 
 
2727 
/* DECODE A TOKDEC */
2728 
 
2729 
long de_tokdec
2730 
    PROTO_Z ()
2731 
{
2732 
    long n = fetch_extn ( 1 ) ;
2733 
    if ( n < 1 || n > 1 ) {
2734 
	out ( "<error>" ) ;
2735 
	input_error ( "Illegal TOKDEC value, %ld", n ) ;
2736 
	n = -1 ;
2737 
    }
2738 
    return ( n ) ;
2739 
}
2740 
 
2741 
 
2742 
/* DECODE A TOKDEF */
2743 
 
2744 
long de_tokdef
2745 
    PROTO_Z ()
2746 
{
2747 
    long n = fetch_extn ( 1 ) ;
2748 
    if ( n < 1 || n > 1 ) {
2749 
	out ( "<error>" ) ;
2750 
	input_error ( "Illegal TOKDEF value, %ld", n ) ;
2751 
	n = -1 ;
2752 
    }
2753 
    return ( n ) ;
2754 
}
2755 
 
2756 
 
2757 
/* DECODE A TOKEN */
2758 
 
2759 
long de_token
2760 
    PROTO_Z ()
2761 
{
2762 
    long n = fetch_extn ( 2 ) ;
2763 
    if ( n < 1 || n > 3 ) {
2764 
	out ( "<error>" ) ;
2765 
	input_error ( "Illegal TOKEN value, %ld", n ) ;
2766 
	n = -1 ;
2767 
    }
2768 
    return ( n ) ;
2769 
}
2770 
 
2771 
 
2772 
/* DECODE A TOKEN_DEFN */
2773 
 
2774 
long de_token_defn
2775 
    PROTO_Z ()
2776 
{
2777 
    long n = fetch_extn ( 1 ) ;
2778 
    if ( n < 1 || n > 1 ) {
2779 
	out ( "<error>" ) ;
2780 
	input_error ( "Illegal TOKEN_DEFN value, %ld", n ) ;
2781 
	n = -1 ;
2782 
    }
2783 
    return ( n ) ;
2784 
}
2785 
 
2786 
 
2787 
/* DECODE A TRANSFER_MODE */
2788 
 
2789 
long de_transfer_mode
2790 
    PROTO_Z ()
2791 
{
2792 
    long n = fetch_extn ( 3 ) ;
2793 
    switch ( n ) {
2794 
	case 1 : {
2795 
	    IGNORE de_token_aux ( sort_transfer_mode, "transfer_mode" ) ;
2796 
	    break ;
2797 
	}
2798 
	case 2 : {
2799 
	    format ( VERT_BRACKETS, "transfer_mode_cond", "x@[m]@[m]" ) ;
2800 
	    break ;
2801 
	}
2802 
	case 3 : {
2803 
	    format ( VERT_BRACKETS, "add_modes", "mm" ) ;
2804 
	    break ;
2805 
	}
2806 
	case 4 : {
2807 
	    out ( "overlap" ) ;
2808 
	    break ;
2809 
	}
2810 
	case 5 : {
2811 
	    out ( "standard_transfer_mode" ) ;
2812 
	    break ;
2813 
	}
2814 
	case 6 : {
2815 
	    out ( "trap_on_nil" ) ;
2816 
	    break ;
2817 
	}
2818 
	case 7 : {
2819 
	    out ( "volatile" ) ;
2820 
	    break ;
2821 
	}
2822 
	case 8 : {
2823 
	    out ( "complete" ) ;
2824 
	    break ;
2825 
	}
2826 
	default : {
2827 
	    out ( "<error>" ) ;
2828 
	    input_error ( "Illegal TRANSFER_MODE value, %ld", n ) ;
2829 
	    n = -1 ;
2830 
	    break ;
2831 
	}
2832 
    }
2833 
    return ( n ) ;
2834 
}
2835 
 
2836 
 
2837 
/* DECODE A VARIETY */
2838 
 
2839 
long de_variety
2840 
    PROTO_Z ()
2841 
{
2842 
    long n = fetch_extn ( 2 ) ;
2843 
    switch ( n ) {
2844 
	case 1 : {
2845 
	    IGNORE de_token_aux ( sort_variety, "variety" ) ;
2846 
	    break ;
2847 
	}
2848 
	case 2 : {
2849 
	    format ( VERT_BRACKETS, "var_cond", "x@[v]@[v]" ) ;
2850 
	    break ;
2851 
	}
2852 
	case 3 : {
2853 
	    format ( HORIZ_BRACKETS, "var_limits", "ss" ) ;
2854 
	    break ;
2855 
	}
2856 
	case 4 : {
2857 
	    format ( HORIZ_BRACKETS, "var_width", "bn" ) ;
2858 
	    break ;
2859 
	}
2860 
	default : {
2861 
	    out ( "<error>" ) ;
2862 
	    input_error ( "Illegal VARIETY value, %ld", n ) ;
2863 
	    n = -1 ;
2864 
	    break ;
2865 
	}
2866 
    }
2867 
    return ( n ) ;
2868 
}
2869 
 
2870 
 
2871 
/* DECODE A VERSION */
2872 
 
2873 
long de_version
2874 
    PROTO_Z ()
2875 
{
2876 
    long n = fetch_extn ( 1 ) ;
2877 
    switch ( n ) {
2878 
	case 1 : {
2879 
	    /* Decode string "ii" */
2880 
	    de_make_version ( "make_version" ) ;
2881 
	    break ;
2882 
	}
2883 
	case 2 : {
2884 
	    format ( VERT_BRACKETS, "user_info", "X" ) ;
2885 
	    break ;
2886 
	}
2887 
	default : {
2888 
	    out ( "<error>" ) ;
2889 
	    input_error ( "Illegal VERSION value, %ld", n ) ;
2890 
	    n = -1 ;
2891 
	    break ;
2892 
	}
2893 
    }
2894 
    return ( n ) ;
2895 
}
2896 
 
2897 
 
2898 
/*
2899 
    SKIP TEXT ENCLOSED IN [...]
2900 
 
2901 
    On input, s, points to the character '['.  The routine returns a
2902 
    pointer to the character following the corresponding ']'.
2903 
*/
2904 
 
2905 
static char *skip_sub
2906 
    PROTO_N ( ( s ) )
2907 
    PROTO_T ( char *s )
2908 
{
2909 
    char c = *( s++ ) ;
2910 
    if ( c == '[' ) {
2911 
	int n = 0 ;
2912 
	while ( c = *( s++ ), c != 0 ) {
2913 
	    if ( c == '[' ) n++ ;
2914 
	    if ( c == ']' ) {
2915 
		if ( n == 0 ) return ( s ) ;
2916 
		n-- ;
2917 
	    }
2918 
	}
2919 
    }
2920 
    input_error ( "Illegal decoding string" ) ;
2921 
    return ( "" ) ;
2922 
}
2923 
 
2924 
 
2925 
/*
2926 
    DECODE A STRING OF DECODE CHARACTERS
2927 
 
2928 
    This routine takes a string of characters, reads it one character
2929 
    at a time, and, according to what it is, calls a particular TDF
2930 
    decoding routine (the character is vaguely mnemonic).  For example,
2931 
    decode ( "Sn*[x]" ) means, decode a SHAPE and a NAT, then read a
2932 
    TDF integer and decode that number of EXPs.
2933 
*/
2934 
 
2935 
void decode
2936 
    PROTO_N ( ( str ) )
2937 
    PROTO_T ( char *str )
2938 
{
2939 
    char c ;
2940 
    while ( c = *( str++ ), c != 0 ) {
2941 
	switch ( c ) {
2942 
	    case '[' :
2943 
	    case '{' :
2944 
	    case '}' :
2945 
	    case '&' : {
2946 
		/* Ignore these cases */
2947 
		break ;
2948 
	    }
2949 
	    case ']' : {
2950 
		/* Marks the end of a group */
2951 
		return ;
2952 
	    }
2953 
	    case 'i' : {
2954 
		/* Decode an integer */
2955 
		long n = tdf_int () ;
2956 
		out_int ( n ) ;
2957 
		break ;
2958 
	    }
2959 
	    case '$' : {
2960 
		/* Decode a string */
2961 
		de_tdfstring_format () ;
2962 
		break ;
2963 
	    }
2964 
	    case 'T' : {
2965 
		/* Decode a token */
2966 
		IGNORE de_token_aux ( sort_unknown, "token" ) ;
2967 
		break ;
2968 
	    }
2969 
	    case 'F' : {
2970 
		/* Decode an unknown foreign sort */
2971 
		input_error ( "Unknown foreign sort" ) ;
2972 
		break ;
2973 
	    }
2974 
	    case '*' : {
2975 
		/* The following text is repeated n times */
2976 
		long i, n ;
2977 
		check_list () ;
2978 
		n = tdf_int () ;
2979 
		if ( n == 0 ) {
2980 
		    out ( "empty" ) ;
2981 
		} else {
2982 
		    for ( i = 0 ; i < n ; i++ ) decode ( str + 1 ) ;
2983 
		}
2984 
		str = skip_sub ( str ) ;
2985 
		break ;
2986 
	    }
2987 
	    case '+' : {
2988 
		/* The following text is repeated n + 1 times */
2989 
		long i, n ;
2990 
		check_list () ;
2991 
		n = tdf_int () ;
2992 
		for ( i = 0 ; i <= n ; i++ ) decode ( str + 1 ) ;
2993 
		str = skip_sub ( str ) ;
2994 
		break ;
2995 
	    }
2996 
	    case '?' : {
2997 
		/* The following text is optional */
2998 
		if ( tdf_bool () ) {
2999 
		    decode ( str + 1 ) ;
3000 
		} else {
3001 
		    out ( "-" ) ;
3002 
		}
3003 
		str = skip_sub ( str ) ;
3004 
		break ;
3005 
	    }
3006 
	    case '@' : {
3007 
		/* The following text is a bitstream */
3008 
		long p = tdf_int () ;
3009 
		p += posn ( here ) ;
3010 
		decode ( str + 1 ) ;
3011 
		if ( p != posn ( here ) ) {
3012 
		    input_error ( "Bitstream length wrong" ) ;
3013 
		}
3014 
		str = skip_sub ( str ) ;
3015 
		break ;
3016 
	    }
3017 
	    case '|' : {
3018 
		/* Align input stream */
3019 
		byte_align () ;
3020 
		break ;
3021 
	    }
3022 
	    case 'u' : IGNORE de_access () ; break ;
3023 
	    case 'A' : IGNORE de_al_tag () ; break ;
3024 
	    case 'a' : IGNORE de_alignment () ; break ;
3025 
	    case 'B' : IGNORE de_bitfield_variety () ; break ;
3026 
	    case 'b' : IGNORE de_bool () ; break ;
3027 
	    case 'q' : IGNORE de_callees () ; break ;
3028 
	    case 'G' : IGNORE de_dg () ; break ;
3029 
	    case 'o' : IGNORE de_dg_accessibility () ; break ;
3030 
	    case 'H' : IGNORE de_dg_append () ; break ;
3031 
	    case 'w' : IGNORE de_dg_bound () ; break ;
3032 
	    case 'y' : IGNORE de_dg_class_base () ; break ;
3033 
	    case 'z' : IGNORE de_dg_classmem () ; break ;
3034 
	    case 'C' : IGNORE de_dg_compilation () ; break ;
3035 
	    case '\011' : IGNORE de_dg_constraint () ; break ;
3036 
	    case '\012' : IGNORE de_dg_default () ; break ;
3037 
	    case 'O' : IGNORE de_dg_dim () ; break ;
3038 
	    case 'K' : IGNORE de_dg_discrim () ; break ;
3039 
	    case 'E' : IGNORE de_dg_enum () ; break ;
3040 
	    case 'U' : IGNORE de_dg_filename () ; break ;
3041 
	    case 'Y' : IGNORE de_dg_idname () ; break ;
3042 
	    case 'Z' : IGNORE de_dg_macro () ; break ;
3043 
	    case 'h' : IGNORE de_dg_name () ; break ;
3044 
	    case 'k' : IGNORE de_dg_namelist () ; break ;
3045 
	    case 'p' : IGNORE de_dg_param () ; break ;
3046 
	    case '\013' : IGNORE de_dg_param_mode () ; break ;
3047 
	    case '\014' : IGNORE de_dg_qualifier () ; break ;
3048 
	    case 'W' : IGNORE de_dg_sourcepos () ; break ;
3049 
	    case 'J' : IGNORE de_dg_tag () ; break ;
3050 
	    case '\015' : IGNORE de_dg_type () ; break ;
3051 
	    case '\016' : IGNORE de_dg_variant () ; break ;
3052 
	    case '\017' : IGNORE de_dg_varpart () ; break ;
3053 
	    case '\020' : IGNORE de_dg_virtuality () ; break ;
3054 
	    case 'D' : IGNORE de_diag_descriptor () ; break ;
3055 
	    case 'I' : IGNORE de_diag_tag () ; break ;
3056 
	    case 'g' : IGNORE de_diag_tq () ; break ;
3057 
	    case 'd' : IGNORE de_diag_type () ; break ;
3058 
	    case 'c' : IGNORE de_error_code () ; break ;
3059 
	    case 'e' : IGNORE de_error_treatment () ; break ;
3060 
	    case 'x' : IGNORE de_exp () ; break ;
3061 
	    case 'Q' : IGNORE de_filename () ; break ;
3062 
	    case 'f' : IGNORE de_floating_variety () ; break ;
3063 
	    case 'l' : IGNORE de_label () ; break ;
3064 
	    case 'L' : IGNORE de_linkinfo () ; break ;
3065 
	    case 'n' : IGNORE de_nat () ; break ;
3066 
	    case 'N' : IGNORE de_ntest () ; break ;
3067 
	    case 'P' : IGNORE de_procprops () ; break ;
3068 
	    case 'r' : IGNORE de_rounding_mode () ; break ;
3069 
	    case 'S' : IGNORE de_shape () ; break ;
3070 
	    case 's' : IGNORE de_signed_nat () ; break ;
3071 
	    case 'M' : IGNORE de_sourcemark () ; break ;
3072 
	    case 'X' : IGNORE de_string () ; break ;
3073 
	    case 't' : IGNORE de_tag () ; break ;
3074 
	    case 'm' : IGNORE de_transfer_mode () ; break ;
3075 
	    case 'v' : IGNORE de_variety () ; break ;
3076 
	    case 'V' : IGNORE de_version () ; break ;
3077 
	    default : {
3078 
		input_error ( "Illegal decode letter, %c", c ) ;
3079 
		break ;
3080 
	    }
3081 
	}
3082 
    }
3083 
    return ;
3084 
}
3085 
 
3086 
 
3087 
/*
3088 
    FIND THE NAME AND DECODE LETTER ASSOCIATED WITH A SORT
3089 
 
3090 
    This routine returns a sortid structure corresponding to the sort
3091 
    number n.
3092 
*/
3093 
 
3094 
sortid find_sort
3095 
    PROTO_N ( ( n ) )
3096 
    PROTO_T ( sortname n )
3097 
{
3098 
    sortid s ;
3099 
    switch ( n ) {
3100 
	case sort_access : {
3101 
	    s.name = "ACCESS" ;
3102 
	    s.decode = 'u' ;
3103 
	    break ;
3104 
	}
3105 
	case sort_al_tag : {
3106 
	    s.name = "AL_TAG" ;
3107 
	    s.decode = 'A' ;
3108 
	    break ;
3109 
	}
3110 
	case sort_alignment : {
3111 
	    s.name = "ALIGNMENT" ;
3112 
	    s.decode = 'a' ;
3113 
	    break ;
3114 
	}
3115 
	case sort_bitfield_variety : {
3116 
	    s.name = "BITFIELD_VARIETY" ;
3117 
	    s.decode = 'B' ;
3118 
	    break ;
3119 
	}
3120 
	case sort_bool : {
3121 
	    s.name = "BOOL" ;
3122 
	    s.decode = 'b' ;
3123 
	    break ;
3124 
	}
3125 
	case sort_error_treatment : {
3126 
	    s.name = "ERROR_TREATMENT" ;
3127 
	    s.decode = 'e' ;
3128 
	    break ;
3129 
	}
3130 
	case sort_exp : {
3131 
	    s.name = "EXP" ;
3132 
	    s.decode = 'x' ;
3133 
	    break ;
3134 
	}
3135 
	case sort_floating_variety : {
3136 
	    s.name = "FLOATING_VARIETY" ;
3137 
	    s.decode = 'f' ;
3138 
	    break ;
3139 
	}
3140 
	case sort_label : {
3141 
	    s.name = "LABEL" ;
3142 
	    s.decode = 'l' ;
3143 
	    break ;
3144 
	}
3145 
	case sort_nat : {
3146 
	    s.name = "NAT" ;
3147 
	    s.decode = 'n' ;
3148 
	    break ;
3149 
	}
3150 
	case sort_ntest : {
3151 
	    s.name = "NTEST" ;
3152 
	    s.decode = 'N' ;
3153 
	    break ;
3154 
	}
3155 
	case sort_procprops : {
3156 
	    s.name = "PROCPROPS" ;
3157 
	    s.decode = 'P' ;
3158 
	    break ;
3159 
	}
3160 
	case sort_rounding_mode : {
3161 
	    s.name = "ROUNDING_MODE" ;
3162 
	    s.decode = 'r' ;
3163 
	    break ;
3164 
	}
3165 
	case sort_shape : {
3166 
	    s.name = "SHAPE" ;
3167 
	    s.decode = 'S' ;
3168 
	    break ;
3169 
	}
3170 
	case sort_signed_nat : {
3171 
	    s.name = "SIGNED_NAT" ;
3172 
	    s.decode = 's' ;
3173 
	    break ;
3174 
	}
3175 
	case sort_string : {
3176 
	    s.name = "STRING" ;
3177 
	    s.decode = 'X' ;
3178 
	    break ;
3179 
	}
3180 
	case sort_tag : {
3181 
	    s.name = "TAG" ;
3182 
	    s.decode = 't' ;
3183 
	    break ;
3184 
	}
3185 
	case sort_transfer_mode : {
3186 
	    s.name = "TRANSFER_MODE" ;
3187 
	    s.decode = 'm' ;
3188 
	    break ;
3189 
	}
3190 
	case sort_variety : {
3191 
	    s.name = "VARIETY" ;
3192 
	    s.decode = 'v' ;
3193 
	    break ;
3194 
	}
3195 
	case sort_token : {
3196 
	    s.name = "TOKEN" ;
3197 
	    s.decode = 'T' ;
3198 
	    break ;
3199 
	}
3200 
	case sort_foreign : {
3201 
	    s.name = "FOREIGN" ;
3202 
	    s.decode = 'F' ;
3203 
	    break ;
3204 
	}
3205 
	default: {
3206 
	    int m = n - extra_sorts ;
3207 
	    if ( m >= 0 && m < no_foreign_sorts ) {
3208 
		s.name = foreign_sorts [m].name ;
3209 
		s.decode = foreign_sorts [m].decode ;
3210 
	    } else {
3211 
		input_error ( "Illegal sort value, %d", n ) ;
3212 
		s.name = "<error in SORT>" ;
3213 
		s.decode = 'F' ;
3214 
	    }
3215 
	    break ;
3216 
	}
3217 
    }
3218 
    s.res = n ;
3219 
    s.args = null ;
3220 
    return ( s ) ;
3221 
}
3222 
 
3223 
 
3224 
/*
3225 
 
3226 
    CONVERT A DECODE LETTER TO A SORT VALUE
3227 
 
3228 
    This routine given a decode letter c returns the corresponding sort
3229 
    number.
3230 
*/
3231 
 
3232 
sortname find_sortname
3233 
    PROTO_N ( ( c ) )
3234 
    PROTO_T ( int c )
3235 
{
3236 
    long i ;
3237 
    switch ( c ) {
3238 
	case 'u' : return ( sort_access ) ;
3239 
	case 'A' : return ( sort_al_tag ) ;
3240 
	case 'a' : return ( sort_alignment ) ;
3241 
	case 'B' : return ( sort_bitfield_variety ) ;
3242 
	case 'b' : return ( sort_bool ) ;
3243 
	case 'e' : return ( sort_error_treatment ) ;
3244 
	case 'x' : return ( sort_exp ) ;
3245 
	case 'f' : return ( sort_floating_variety ) ;
3246 
	case 'l' : return ( sort_label ) ;
3247 
	case 'n' : return ( sort_nat ) ;
3248 
	case 'N' : return ( sort_ntest ) ;
3249 
	case 'P' : return ( sort_procprops ) ;
3250 
	case 'r' : return ( sort_rounding_mode ) ;
3251 
	case 'S' : return ( sort_shape ) ;
3252 
	case 's' : return ( sort_signed_nat ) ;
3253 
	case 'X' : return ( sort_string ) ;
3254 
	case 't' : return ( sort_tag ) ;
3255 
	case 'm' : return ( sort_transfer_mode ) ;
3256 
	case 'v' : return ( sort_variety ) ;
3257 
	case 'T' : return ( sort_token ) ;
3258 
	case 'F' : return ( sort_foreign ) ;
3259 
    }
3260 
    for ( i = 0 ; i < no_foreign_sorts ; i++ ) {
3261 
	if ( c == foreign_sorts [i].decode ) {
3262 
	    return ( ( sortname ) ( extra_sorts + i ) ) ;
3263 
	}
3264 
    }
3265 
    return ( sort_unknown ) ;
3266 
}
3267 
 
3268 
 
3269 
/*
3270 
    INITIALISE FOREIGN SORT NAMES
3271 
 
3272 
    This routine initialises the array of foreign sort names.
3273 
*/
3274 
 
3275 
void init_foreign_sorts
3276 
    PROTO_Z ()
3277 
{
3278 
    add_foreign_sort ( "DG", "DG", 'G' ) ;
3279 
    add_foreign_sort ( "DG_DIM", "DG_DIM", 'O' ) ;
3280 
    add_foreign_sort ( "DG_FILENAME", "DG_FILENAME", 'U' ) ;
3281 
    add_foreign_sort ( "DG_IDNAME", "DG_IDNAME", 'Y' ) ;
3282 
    add_foreign_sort ( "DG_NAME", "DG_NAME", 'h' ) ;
3283 
    add_foreign_sort ( "DG_TYPE", "DG_TYPE", '\015' ) ;
3284 
    add_foreign_sort ( "DIAG_TYPE", "diag_type", 'd' ) ;
3285 
    add_foreign_sort ( "FILENAME", "~diag_file", 'Q' ) ;
3286 
    return ;
3287 
}
3288 
 
3289 
 
3290 
/*
3291 
    LINKAGE VARIABLE NUMBERS
3292 
 
3293 
    Usually "tag" and "token" etc. appear in the var_types array.  These
3294 
    variables indicate where (negative values mean not at all).
3295 
*/
3296 
 
3297 
long var_al_tag = -1 ;
3298 
long var_dg_tag = -2 ;
3299 
long var_diag_tag = -3 ;
3300 
long var_tag = -4 ;
3301 
long var_token = -5 ;
3302 
 
3303 
 
3304 
/*
3305 
    FIND A LINKAGE VARIABLE CODE
3306 
 
3307 
    This routine sets the nth element of the var_types array to the
3308 
    linkage variable indicated by the variable name s.
3309 
*/
3310 
 
3311 
char find_variable
3312 
    PROTO_N ( ( s, n ) )
3313 
    PROTO_T ( string s X long n )
3314 
{
3315 
    if ( streq ( s, "alignment" ) ) {
3316 
	var_al_tag = n ;
3317 
	return ( 'A' ) ;
3318 
    }
3319 
    if ( streq ( s, "dgtag" ) ) {
3320 
	var_dg_tag = n ;
3321 
	return ( 'J' ) ;
3322 
    }
3323 
    if ( streq ( s, "diagtag" ) ) {
3324 
	var_diag_tag = n ;
3325 
	return ( 'I' ) ;
3326 
    }
3327 
    if ( streq ( s, "tag" ) ) {
3328 
	var_tag = n ;
3329 
	return ( 't' ) ;
3330 
    }
3331 
    if ( streq ( s, "token" ) ) {
3332 
	var_token = n ;
3333 
	return ( 'T' ) ;
3334 
    }
3335 
    return ( 'F' ) ;
3336 
}
3337 
 
3338 
 
3339 
/*
3340 
    FIND A EQUATION DECODING FUNCTION
3341 
 
3342 
    This routine returns the unit decoding function used to deal with
3343 
    units with equation name s.  It also assigns a unit description to
3344 
    pt and a usage flag to po.
3345 
*/
3346 
 
3347 
equation_func find_equation
3348 
    PROTO_N ( ( s, pt, po ) )
3349 
    PROTO_T ( string s X string *pt X int *po )
3350 
{
3351 
    if ( streq ( s, "aldef" ) ) {
3352 
	*pt = MSG_al_tagdef_props ;
3353 
	*po = OPT_al_tagdef_props ;
3354 
	return ( de_al_tagdef_props ) ;
3355 
    }
3356 
    if ( streq ( s, "dgcompunit" ) ) {
3357 
	*pt = MSG_dg_comp_props ;
3358 
	*po = OPT_dg_comp_props ;
3359 
	return ( de_dg_comp_props ) ;
3360 
    }
3361 
    if ( streq ( s, "diagtype" ) ) {
3362 
	*pt = MSG_diag_type_unit ;
3363 
	*po = OPT_diag_type_unit ;
3364 
	return ( de_diag_type_unit ) ;
3365 
    }
3366 
    if ( streq ( s, "diagdef" ) ) {
3367 
	*pt = MSG_diag_unit ;
3368 
	*po = OPT_diag_unit ;
3369 
	return ( de_diag_unit ) ;
3370 
    }
3371 
    if ( streq ( s, "linkinfo" ) ) {
3372 
	*pt = MSG_linkinfo_props ;
3373 
	*po = OPT_linkinfo_props ;
3374 
	return ( de_linkinfo_props ) ;
3375 
    }
3376 
    if ( streq ( s, "tagdec" ) ) {
3377 
	*pt = MSG_tagdec_props ;
3378 
	*po = OPT_tagdec_props ;
3379 
	return ( de_tagdec_props ) ;
3380 
    }
3381 
    if ( streq ( s, "tagdef" ) ) {
3382 
	*pt = MSG_tagdef_props ;
3383 
	*po = OPT_tagdef_props ;
3384 
	return ( de_tagdef_props ) ;
3385 
    }
3386 
    if ( streq ( s, "tokdec" ) ) {
3387 
	*pt = MSG_tokdec_props ;
3388 
	*po = OPT_tokdec_props ;
3389 
	return ( de_tokdec_props ) ;
3390 
    }
3391 
    if ( streq ( s, "tokdef" ) ) {
3392 
	*pt = MSG_tokdef_props ;
3393 
	*po = OPT_tokdef_props ;
3394 
	return ( de_tokdef_props ) ;
3395 
    }
3396 
    if ( streq ( s, "versions" ) ) {
3397 
	*pt = MSG_version_props ;
3398 
	*po = OPT_version_props ;
3399 
	return ( de_version_props ) ;
3400 
    }
3401 
    if ( streq ( s, "tld" ) ) {
3402 
	*pt = MSG_tld_unit ;
3403 
	*po = OPT_tld_unit ;
3404 
	return ( de_tld_unit ) ;
3405 
    }
3406 
    if ( streq ( s, "tld2" ) ) {
3407 
	*pt = MSG_tld2_unit ;
3408 
	*po = OPT_tld2_unit ;
3409 
	return ( de_tld2_unit ) ;
3410 
    }
3411 
    return ( NULL ) ;
3412 
}