Subversion Repositories tendra.SVN

Rev

Rev 5 | Details | Compare with Previous | Last modification | View Log | RSS feed

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