Subversion Repositories tendra.SVN

Rev

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

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