Subversion Repositories tendra.SVN

Rev

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

Rev Author Line No. Line
6 7u83 1 
/*
2 
 * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
3 
 * All rights reserved.
4 
 *
5 
 * Redistribution and use in source and binary forms, with or without
6 
 * modification, are permitted provided that the following conditions are met:
7 
 *
8 
 * 1. Redistributions of source code must retain the above copyright notice,
9 
 *    this list of conditions and the following disclaimer.
10 
 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 
 *    this list of conditions and the following disclaimer in the documentation
12 
 *    and/or other materials provided with the distribution.
13 
 * 3. Neither the name of The TenDRA Project nor the names of its contributors
14 
 *    may be used to endorse or promote products derived from this software
15 
 *    without specific, prior written permission.
16 
 *
17 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
18 
 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
19 
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20 
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
21 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 
 * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
24 
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
27 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 
 *
29 
 * $Id$
30 
 */
31 
/*
32 
    		 Crown Copyright (c) 1997
33 
 
34 
    This TenDRA(r) Computer Program is subject to Copyright
35 
    owned by the United Kingdom Secretary of State for Defence
36 
    acting through the Defence Evaluation and Research Agency
37 
    (DERA).  It is made available to Recipients with a
38 
    royalty-free licence for its use, reproduction, transfer
39 
    to other parties and amendment for any purpose not excluding
40 
    product development provided that any such use et cetera
41 
    shall be deemed to be acceptance of the following conditions:-
42 
 
43 
        (1) Its Recipients shall ensure that this Notice is
44 
        reproduced upon any copies or amended versions of it;
45 
 
46 
        (2) Any amended version of it shall be clearly marked to
47 
        show both the nature of and the organisation responsible
48 
        for the relevant amendment or amendments;
49 
 
50 
        (3) Its onward transfer from a recipient to another
51 
        party shall be deemed to be that party's acceptance of
52 
        these conditions;
53 
 
54 
        (4) DERA gives no warranty or assurance as to its
55 
        quality or suitability for any purpose and DERA accepts
56 
        no liability whatsoever in relation to any use to which
57 
        it may be put.
58 
*/
59 
 
60 
 
61 
#ifndef ENCODING_INCLUDED
62 
#define ENCODING_INCLUDED
63 
 
64 
 
65 
/* CONSTRUCTS FOR ACCESS */
66 
 
67 
#define o_access_apply_token( p0, p1 )\
68 
    TOK_APP (\
69 
	out_basic_int((unsigned long)e_access_apply_token, (unsigned)4),\
70 
	s_access, p0, p1)
71 
 
72 
#define o_access_cond( p0, p1, p2 )\
73 
    TDF_COND (\
74 
	out_basic_int((unsigned long)e_access_cond, (unsigned)4),\
75 
	s_access, p0, p1, p2)
76 
 
77 
#define o_add_accesses( p0, p1 )\
78 
    {\
79 
	out_basic_int((unsigned long)e_add_accesses, (unsigned)4);\
80 
	p0;\
81 
	ASSERT_SORT(s_access);\
82 
	p1;\
83 
	ASSERT_SORT(s_access);\
84 
	SET_RSORT(s_access);\
85 
    }
86 
 
87 
#define o_constant\
88 
    {\
89 
	out_basic_int((unsigned long)e_constant, (unsigned)4);\
90 
	SET_RSORT(s_access);\
91 
    }
92 
 
93 
#define o_long_jump_access\
94 
    {\
95 
	out_basic_int((unsigned long)e_long_jump_access, (unsigned)4);\
96 
	SET_RSORT(s_access);\
97 
    }
98 
 
99 
#define o_no_other_read\
100 
    {\
101 
	out_basic_int((unsigned long)e_no_other_read, (unsigned)4);\
102 
	SET_RSORT(s_access);\
103 
    }
104 
 
105 
#define o_no_other_write\
106 
    {\
107 
	out_basic_int((unsigned long)e_no_other_write, (unsigned)4);\
108 
	SET_RSORT(s_access);\
109 
    }
110 
 
111 
#define o_out_par\
112 
    {\
113 
	out_basic_int((unsigned long)e_out_par, (unsigned)4);\
114 
	SET_RSORT(s_access);\
115 
    }
116 
 
117 
#define o_preserve\
118 
    {\
119 
	out_basic_int((unsigned long)e_preserve, (unsigned)4);\
120 
	SET_RSORT(s_access);\
121 
    }
122 
 
123 
#define o_register\
124 
    {\
125 
	out_basic_int((unsigned long)e_register, (unsigned)4);\
126 
	SET_RSORT(s_access);\
127 
    }
128 
 
129 
#define o_standard_access\
130 
    {\
131 
	out_basic_int((unsigned long)e_standard_access, (unsigned)4);\
132 
	SET_RSORT(s_access);\
133 
    }
134 
 
135 
#define o_used_as_volatile\
136 
    {\
137 
	out_basic_int((unsigned long)e_used_as_volatile, (unsigned)4);\
138 
	SET_RSORT(s_access);\
139 
    }
140 
 
141 
#define o_visible\
142 
    {\
143 
	out_basic_int((unsigned long)e_visible, (unsigned)4);\
144 
	SET_RSORT(s_access);\
145 
    }
146 
 
147 
 
148 
/* CONSTRUCTS FOR AL_TAG */
149 
 
150 
#define o_al_tag_apply_token( p0, p1 )\
151 
    TOK_APP (\
152 
	out_extendable_int((unsigned long)e_al_tag_apply_token, (unsigned)1),\
153 
	s_al_tag, p0, p1)
154 
 
155 
#define o_make_al_tag( p0 )\
156 
    {\
157 
	out_basic_int((unsigned long)e_make_al_tag, (unsigned)1);\
158 
	p0;\
159 
	ASSERT_SORT(s_tdfint);\
160 
	SET_RSORT(s_al_tag);\
161 
    }
162 
 
163 
 
164 
/* CONSTRUCTS FOR AL_TAGDEF */
165 
 
166 
#define o_make_al_tagdef( p0, p1 )\
167 
    {\
168 
	out_basic_int((unsigned long)e_make_al_tagdef, (unsigned)1);\
169 
	p0;\
170 
	ASSERT_SORT(s_tdfint);\
171 
	p1;\
172 
	ASSERT_SORT(s_alignment);\
173 
	SET_RSORT(s_al_tagdef);\
174 
    }
175 
 
176 
 
177 
/* CONSTRUCTS FOR AL_TAGDEF_PROPS */
178 
 
179 
#define o_make_al_tagdefs( p0, p1 )\
180 
    {\
181 
	p0;\
182 
	ASSERT_SORT(s_tdfint);\
183 
	o_al_tagdef_list(p1);\
184 
	SET_RSORT(s_al_tagdef_props);\
185 
    }
186 
 
187 
 
188 
/* CONSTRUCTS FOR ALIGNMENT */
189 
 
190 
#define o_alignment_apply_token( p0, p1 )\
191 
    TOK_APP (\
192 
	out_basic_int((unsigned long)e_alignment_apply_token, (unsigned)4),\
193 
	s_alignment, p0, p1)
194 
 
195 
#define o_alignment_cond( p0, p1, p2 )\
196 
    TDF_COND (\
197 
	out_basic_int((unsigned long)e_alignment_cond, (unsigned)4),\
198 
	s_alignment, p0, p1, p2)
199 
 
200 
#define o_alignment( p0 )\
201 
    {\
202 
	out_basic_int((unsigned long)e_alignment, (unsigned)4);\
203 
	p0;\
204 
	ASSERT_SORT(s_shape);\
205 
	SET_RSORT(s_alignment);\
206 
    }
207 
 
208 
#define o_alloca_alignment\
209 
    {\
210 
	out_basic_int((unsigned long)e_alloca_alignment, (unsigned)4);\
211 
	SET_RSORT(s_alignment);\
212 
    }
213 
 
214 
#define o_callees_alignment( p0 )\
215 
    {\
216 
	out_basic_int((unsigned long)e_callees_alignment, (unsigned)4);\
217 
	p0;\
218 
	ASSERT_SORT(s_bool);\
219 
	SET_RSORT(s_alignment);\
220 
    }
221 
 
222 
#define o_callers_alignment( p0 )\
223 
    {\
224 
	out_basic_int((unsigned long)e_callers_alignment, (unsigned)4);\
225 
	p0;\
226 
	ASSERT_SORT(s_bool);\
227 
	SET_RSORT(s_alignment);\
228 
    }
229 
 
230 
#define o_code_alignment\
231 
    {\
232 
	out_basic_int((unsigned long)e_code_alignment, (unsigned)4);\
233 
	SET_RSORT(s_alignment);\
234 
    }
235 
 
236 
#define o_locals_alignment\
237 
    {\
238 
	out_basic_int((unsigned long)e_locals_alignment, (unsigned)4);\
239 
	SET_RSORT(s_alignment);\
240 
    }
241 
 
242 
#define o_obtain_al_tag( p0 )\
243 
    {\
244 
	out_basic_int((unsigned long)e_obtain_al_tag, (unsigned)4);\
245 
	p0;\
246 
	ASSERT_SORT(s_al_tag);\
247 
	SET_RSORT(s_alignment);\
248 
    }
249 
 
250 
#define o_parameter_alignment( p0 )\
251 
    {\
252 
	out_basic_int((unsigned long)e_parameter_alignment, (unsigned)4);\
253 
	p0;\
254 
	ASSERT_SORT(s_shape);\
255 
	SET_RSORT(s_alignment);\
256 
    }
257 
 
258 
#define o_unite_alignments( p0, p1 )\
259 
    {\
260 
	out_basic_int((unsigned long)e_unite_alignments, (unsigned)4);\
261 
	p0;\
262 
	ASSERT_SORT(s_alignment);\
263 
	p1;\
264 
	ASSERT_SORT(s_alignment);\
265 
	SET_RSORT(s_alignment);\
266 
    }
267 
 
268 
#define o_var_param_alignment\
269 
    {\
270 
	out_basic_int((unsigned long)e_var_param_alignment, (unsigned)4);\
271 
	SET_RSORT(s_alignment);\
272 
    }
273 
 
274 
 
275 
/* CONSTRUCTS FOR BITFIELD_VARIETY */
276 
 
277 
#define o_bfvar_apply_token( p0, p1 )\
278 
    TOK_APP (\
279 
	out_basic_int((unsigned long)e_bfvar_apply_token, (unsigned)2),\
280 
	s_bitfield_variety, p0, p1)
281 
 
282 
#define o_bfvar_cond( p0, p1, p2 )\
283 
    TDF_COND (\
284 
	out_basic_int((unsigned long)e_bfvar_cond, (unsigned)2),\
285 
	s_bitfield_variety, p0, p1, p2)
286 
 
287 
#define o_bfvar_bits( p0, p1 )\
288 
    {\
289 
	out_basic_int((unsigned long)e_bfvar_bits, (unsigned)2);\
290 
	p0;\
291 
	ASSERT_SORT(s_bool);\
292 
	p1;\
293 
	ASSERT_SORT(s_nat);\
294 
	SET_RSORT(s_bitfield_variety);\
295 
    }
296 
 
297 
 
298 
/* CONSTRUCTS FOR BOOL */
299 
 
300 
#define o_bool_apply_token( p0, p1 )\
301 
    TOK_APP (\
302 
	out_basic_int((unsigned long)e_bool_apply_token, (unsigned)3),\
303 
	s_bool, p0, p1)
304 
 
305 
#define o_bool_cond( p0, p1, p2 )\
306 
    TDF_COND (\
307 
	out_basic_int((unsigned long)e_bool_cond, (unsigned)3),\
308 
	s_bool, p0, p1, p2)
309 
 
310 
#define o_false\
311 
    {\
312 
	out_basic_int((unsigned long)e_false, (unsigned)3);\
313 
	SET_RSORT(s_bool);\
314 
    }
315 
 
316 
#define o_true\
317 
    {\
318 
	out_basic_int((unsigned long)e_true, (unsigned)3);\
319 
	SET_RSORT(s_bool);\
320 
    }
321 
 
322 
 
323 
/* CONSTRUCTS FOR CALLEES */
324 
 
325 
#define o_make_callee_list( p0 )\
326 
    {\
327 
	out_basic_int((unsigned long)e_make_callee_list, (unsigned)2);\
328 
	o_exp_list(p0);\
329 
	SET_RSORT(s_callees);\
330 
    }
331 
 
332 
#define o_make_dynamic_callees( p0, p1 )\
333 
    {\
334 
	out_basic_int((unsigned long)e_make_dynamic_callees, (unsigned)2);\
335 
	p0;\
336 
	ASSERT_SORT(s_exp);\
337 
	p1;\
338 
	ASSERT_SORT(s_exp);\
339 
	SET_RSORT(s_callees);\
340 
    }
341 
 
342 
#define o_same_callees\
343 
    {\
344 
	out_basic_int((unsigned long)e_same_callees, (unsigned)2);\
345 
	SET_RSORT(s_callees);\
346 
    }
347 
 
348 
 
349 
/* CONSTRUCTS FOR CAPSULE */
350 
 
351 
#define o_make_capsule( p0, p1, p2, p3 )\
352 
    {\
353 
	o_tdfident_list(p0);\
354 
	o_capsule_link_list(p1);\
355 
	o_extern_link_list(p2);\
356 
	o_group_list(p3);\
357 
	SET_RSORT(s_capsule);\
358 
    }
359 
 
360 
 
361 
/* CONSTRUCTS FOR CAPSULE_LINK */
362 
 
363 
#define o_make_capsule_link( p0, p1 )\
364 
    {\
365 
	p0;\
366 
	ASSERT_SORT(s_tdfident);\
367 
	p1;\
368 
	ASSERT_SORT(s_tdfint);\
369 
	SET_RSORT(s_capsule_link);\
370 
    }
371 
 
372 
 
373 
/* CONSTRUCTS FOR CASELIM */
374 
 
375 
#define o_make_caselim( p0, p1, p2 )\
376 
    {\
377 
	p0;\
378 
	ASSERT_SORT(s_label);\
379 
	p1;\
380 
	ASSERT_SORT(s_signed_nat);\
381 
	p2;\
382 
	ASSERT_SORT(s_signed_nat);\
383 
	SET_RSORT(s_caselim);\
384 
    }
385 
 
386 
 
387 
/* CONSTRUCTS FOR DIAG_DESCRIPTOR */
388 
 
389 
#define o_diag_desc_id( p0, p1, p2, p3 )\
390 
    {\
391 
	out_basic_int((unsigned long)e_diag_desc_id, (unsigned)2);\
392 
	p0;\
393 
	ASSERT_SORT(s_tdfstring);\
394 
	p1;\
395 
	ASSERT_SORT(s_sourcemark);\
396 
	p2;\
397 
	ASSERT_SORT(s_exp);\
398 
	p3;\
399 
	ASSERT_SORT(s_diag_type);\
400 
	SET_RSORT(s_diag_descriptor);\
401 
    }
402 
 
403 
#define o_diag_desc_struct( p0, p1, p2 )\
404 
    {\
405 
	out_basic_int((unsigned long)e_diag_desc_struct, (unsigned)2);\
406 
	p0;\
407 
	ASSERT_SORT(s_tdfstring);\
408 
	p1;\
409 
	ASSERT_SORT(s_sourcemark);\
410 
	p2;\
411 
	ASSERT_SORT(s_diag_type);\
412 
	SET_RSORT(s_diag_descriptor);\
413 
    }
414 
 
415 
#define o_diag_desc_typedef( p0, p1, p2 )\
416 
    {\
417 
	out_basic_int((unsigned long)e_diag_desc_typedef, (unsigned)2);\
418 
	p0;\
419 
	ASSERT_SORT(s_tdfstring);\
420 
	p1;\
421 
	ASSERT_SORT(s_sourcemark);\
422 
	p2;\
423 
	ASSERT_SORT(s_diag_type);\
424 
	SET_RSORT(s_diag_descriptor);\
425 
    }
426 
 
427 
 
428 
/* CONSTRUCTS FOR DIAG_FIELD */
429 
 
430 
#define o_make_diag_field( p0, p1, p2 )\
431 
    {\
432 
	p0;\
433 
	ASSERT_SORT(s_tdfstring);\
434 
	p1;\
435 
	ASSERT_SORT(s_exp);\
436 
	p2;\
437 
	ASSERT_SORT(s_diag_type);\
438 
	SET_RSORT(s_diag_field);\
439 
    }
440 
 
441 
 
442 
/* CONSTRUCTS FOR DIAG_TAG */
443 
 
444 
#define o_make_diag_tag( p0 )\
445 
    {\
446 
	out_basic_int((unsigned long)e_make_diag_tag, (unsigned)1);\
447 
	p0;\
448 
	ASSERT_SORT(s_tdfint);\
449 
	SET_RSORT(s_diag_tag);\
450 
    }
451 
 
452 
 
453 
/* CONSTRUCTS FOR DIAG_TAGDEF */
454 
 
455 
#define o_make_diag_tagdef( p0, p1 )\
456 
    {\
457 
	out_basic_int((unsigned long)e_make_diag_tagdef, (unsigned)1);\
458 
	p0;\
459 
	ASSERT_SORT(s_tdfint);\
460 
	p1;\
461 
	ASSERT_SORT(s_diag_type);\
462 
	SET_RSORT(s_diag_tagdef);\
463 
    }
464 
 
465 
 
466 
/* CONSTRUCTS FOR DIAG_TQ */
467 
 
468 
#define o_add_diag_const( p0 )\
469 
    {\
470 
	out_basic_int((unsigned long)e_add_diag_const, (unsigned)2);\
471 
	p0;\
472 
	ASSERT_SORT(s_diag_tq);\
473 
	SET_RSORT(s_diag_tq);\
474 
    }
475 
 
476 
#define o_add_diag_volatile( p0 )\
477 
    {\
478 
	out_basic_int((unsigned long)e_add_diag_volatile, (unsigned)2);\
479 
	p0;\
480 
	ASSERT_SORT(s_diag_tq);\
481 
	SET_RSORT(s_diag_tq);\
482 
    }
483 
 
484 
#define o_diag_tq_null\
485 
    {\
486 
	out_basic_int((unsigned long)e_diag_tq_null, (unsigned)2);\
487 
	SET_RSORT(s_diag_tq);\
488 
    }
489 
 
490 
 
491 
/* CONSTRUCTS FOR DIAG_TYPE */
492 
 
493 
#define o_diag_type_apply_token( p0, p1 )\
494 
    TOK_APP (\
495 
	out_basic_int((unsigned long)e_diag_type_apply_token, (unsigned)4),\
496 
	s_diag_type, p0, p1)
497 
 
498 
#define o_diag_array( p0, p1, p2, p3, p4 )\
499 
    {\
500 
	out_basic_int((unsigned long)e_diag_array, (unsigned)4);\
501 
	p0;\
502 
	ASSERT_SORT(s_diag_type);\
503 
	p1;\
504 
	ASSERT_SORT(s_exp);\
505 
	p2;\
506 
	ASSERT_SORT(s_exp);\
507 
	p3;\
508 
	ASSERT_SORT(s_exp);\
509 
	p4;\
510 
	ASSERT_SORT(s_diag_type);\
511 
	SET_RSORT(s_diag_type);\
512 
    }
513 
 
514 
#define o_diag_bitfield( p0, p1 )\
515 
    {\
516 
	out_basic_int((unsigned long)e_diag_bitfield, (unsigned)4);\
517 
	p0;\
518 
	ASSERT_SORT(s_diag_type);\
519 
	p1;\
520 
	ASSERT_SORT(s_nat);\
521 
	SET_RSORT(s_diag_type);\
522 
    }
523 
 
524 
#define o_diag_enum( p0, p1, p2 )\
525 
    {\
526 
	out_basic_int((unsigned long)e_diag_enum, (unsigned)4);\
527 
	p0;\
528 
	ASSERT_SORT(s_diag_type);\
529 
	p1;\
530 
	ASSERT_SORT(s_tdfstring);\
531 
	o_enum_values_list(p2);\
532 
	SET_RSORT(s_diag_type);\
533 
    }
534 
 
535 
#define o_diag_floating_variety( p0 )\
536 
    {\
537 
	out_basic_int((unsigned long)e_diag_floating_variety, (unsigned)4);\
538 
	p0;\
539 
	ASSERT_SORT(s_floating_variety);\
540 
	SET_RSORT(s_diag_type);\
541 
    }
542 
 
543 
#define o_diag_loc( p0, p1 )\
544 
    {\
545 
	out_basic_int((unsigned long)e_diag_loc, (unsigned)4);\
546 
	p0;\
547 
	ASSERT_SORT(s_diag_type);\
548 
	p1;\
549 
	ASSERT_SORT(s_diag_tq);\
550 
	SET_RSORT(s_diag_type);\
551 
    }
552 
 
553 
#define o_diag_proc( p0, p1, p2 )\
554 
    {\
555 
	out_basic_int((unsigned long)e_diag_proc, (unsigned)4);\
556 
	o_diag_type_list(p0);\
557 
	p1;\
558 
	ASSERT_SORT(s_bool);\
559 
	p2;\
560 
	ASSERT_SORT(s_diag_type);\
561 
	SET_RSORT(s_diag_type);\
562 
    }
563 
 
564 
#define o_diag_ptr( p0, p1 )\
565 
    {\
566 
	out_basic_int((unsigned long)e_diag_ptr, (unsigned)4);\
567 
	p0;\
568 
	ASSERT_SORT(s_diag_type);\
569 
	p1;\
570 
	ASSERT_SORT(s_diag_tq);\
571 
	SET_RSORT(s_diag_type);\
572 
    }
573 
 
574 
#define o_diag_struct( p0, p1, p2 )\
575 
    {\
576 
	out_basic_int((unsigned long)e_diag_struct, (unsigned)4);\
577 
	p0;\
578 
	ASSERT_SORT(s_shape);\
579 
	p1;\
580 
	ASSERT_SORT(s_tdfstring);\
581 
	o_diag_field_list(p2);\
582 
	SET_RSORT(s_diag_type);\
583 
    }
584 
 
585 
#define o_diag_type_null\
586 
    {\
587 
	out_basic_int((unsigned long)e_diag_type_null, (unsigned)4);\
588 
	SET_RSORT(s_diag_type);\
589 
    }
590 
 
591 
#define o_diag_union( p0, p1, p2 )\
592 
    {\
593 
	out_basic_int((unsigned long)e_diag_union, (unsigned)4);\
594 
	p0;\
595 
	ASSERT_SORT(s_shape);\
596 
	p1;\
597 
	ASSERT_SORT(s_tdfstring);\
598 
	o_diag_field_list(p2);\
599 
	SET_RSORT(s_diag_type);\
600 
    }
601 
 
602 
#define o_diag_variety( p0 )\
603 
    {\
604 
	out_basic_int((unsigned long)e_diag_variety, (unsigned)4);\
605 
	p0;\
606 
	ASSERT_SORT(s_variety);\
607 
	SET_RSORT(s_diag_type);\
608 
    }
609 
 
610 
#define o_use_diag_tag( p0 )\
611 
    {\
612 
	out_basic_int((unsigned long)e_use_diag_tag, (unsigned)4);\
613 
	p0;\
614 
	ASSERT_SORT(s_diag_tag);\
615 
	SET_RSORT(s_diag_type);\
616 
    }
617 
 
618 
 
619 
/* CONSTRUCTS FOR DIAG_TYPE_UNIT */
620 
 
621 
#define o_build_diagtype_unit( p0, p1 )\
622 
    {\
623 
	p0;\
624 
	ASSERT_SORT(s_tdfint);\
625 
	o_diag_tagdef_list(p1);\
626 
	SET_RSORT(s_diag_type_unit);\
627 
    }
628 
 
629 
 
630 
/* CONSTRUCTS FOR DIAG_UNIT */
631 
 
632 
#define o_build_diag_unit( p0, p1 )\
633 
    {\
634 
	p0;\
635 
	ASSERT_SORT(s_tdfint);\
636 
	o_diag_descriptor_list(p1);\
637 
	SET_RSORT(s_diag_unit);\
638 
    }
639 
 
640 
 
641 
/* CONSTRUCTS FOR ENUM_VALUES */
642 
 
643 
#define o_make_enum_values( p0, p1 )\
644 
    {\
645 
	p0;\
646 
	ASSERT_SORT(s_exp);\
647 
	p1;\
648 
	ASSERT_SORT(s_tdfstring);\
649 
	SET_RSORT(s_enum_values);\
650 
    }
651 
 
652 
 
653 
/* CONSTRUCTS FOR ERROR_CODE */
654 
 
655 
#define o_nil_access\
656 
    {\
657 
	out_basic_int((unsigned long)e_nil_access, (unsigned)2);\
658 
	SET_RSORT(s_error_code);\
659 
    }
660 
 
661 
#define o_overflow\
662 
    {\
663 
	out_basic_int((unsigned long)e_overflow, (unsigned)2);\
664 
	SET_RSORT(s_error_code);\
665 
    }
666 
 
667 
#define o_stack_overflow\
668 
    {\
669 
	out_basic_int((unsigned long)e_stack_overflow, (unsigned)2);\
670 
	SET_RSORT(s_error_code);\
671 
    }
672 
 
673 
 
674 
/* CONSTRUCTS FOR ERROR_TREATMENT */
675 
 
676 
#define o_errt_apply_token( p0, p1 )\
677 
    TOK_APP (\
678 
	out_basic_int((unsigned long)e_errt_apply_token, (unsigned)3),\
679 
	s_error_treatment, p0, p1)
680 
 
681 
#define o_errt_cond( p0, p1, p2 )\
682 
    TDF_COND (\
683 
	out_basic_int((unsigned long)e_errt_cond, (unsigned)3),\
684 
	s_error_treatment, p0, p1, p2)
685 
 
686 
#define o_continue\
687 
    {\
688 
	out_basic_int((unsigned long)e_continue, (unsigned)3);\
689 
	SET_RSORT(s_error_treatment);\
690 
    }
691 
 
692 
#define o_error_jump( p0 )\
693 
    {\
694 
	out_basic_int((unsigned long)e_error_jump, (unsigned)3);\
695 
	p0;\
696 
	ASSERT_SORT(s_label);\
697 
	SET_RSORT(s_error_treatment);\
698 
    }
699 
 
700 
#define o_trap( p0 )\
701 
    {\
702 
	out_basic_int((unsigned long)e_trap, (unsigned)3);\
703 
	o_error_code_list(p0);\
704 
	SET_RSORT(s_error_treatment);\
705 
    }
706 
 
707 
#define o_wrap\
708 
    {\
709 
	out_basic_int((unsigned long)e_wrap, (unsigned)3);\
710 
	SET_RSORT(s_error_treatment);\
711 
    }
712 
 
713 
#define o_impossible\
714 
    {\
715 
	out_basic_int((unsigned long)e_impossible, (unsigned)3);\
716 
	SET_RSORT(s_error_treatment);\
717 
    }
718 
 
719 
 
720 
/* CONSTRUCTS FOR EXP */
721 
 
722 
#define o_exp_apply_token( p0, p1 )\
723 
    TOK_APP (\
724 
	out_basic_int((unsigned long)e_exp_apply_token, (unsigned)7),\
725 
	s_exp, p0, p1)
726 
 
727 
#define o_exp_cond( p0, p1, p2 )\
728 
    TDF_COND (\
729 
	out_basic_int((unsigned long)e_exp_cond, (unsigned)7),\
730 
	s_exp, p0, p1, p2)
731 
 
732 
#define o_abs( p0, p1 )\
733 
    {\
734 
	out_basic_int((unsigned long)e_abs, (unsigned)7);\
735 
	p0;\
736 
	ASSERT_SORT(s_error_treatment);\
737 
	p1;\
738 
	ASSERT_SORT(s_exp);\
739 
	SET_RSORT(s_exp);\
740 
    }
741 
 
742 
#define o_add_to_ptr( p0, p1 )\
743 
    {\
744 
	out_basic_int((unsigned long)e_add_to_ptr, (unsigned)7);\
745 
	p0;\
746 
	ASSERT_SORT(s_exp);\
747 
	p1;\
748 
	ASSERT_SORT(s_exp);\
749 
	SET_RSORT(s_exp);\
750 
    }
751 
 
752 
#define o_and( p0, p1 )\
753 
    {\
754 
	out_basic_int((unsigned long)e_and, (unsigned)7);\
755 
	p0;\
756 
	ASSERT_SORT(s_exp);\
757 
	p1;\
758 
	ASSERT_SORT(s_exp);\
759 
	SET_RSORT(s_exp);\
760 
    }
761 
 
762 
#define o_apply_proc( p0, p1, p2, p3 )\
763 
    {\
764 
	out_basic_int((unsigned long)e_apply_proc, (unsigned)7);\
765 
	p0;\
766 
	ASSERT_SORT(s_shape);\
767 
	p1;\
768 
	ASSERT_SORT(s_exp);\
769 
	o_exp_list(p2);\
770 
	o_exp_option(p3);\
771 
	SET_RSORT(s_exp);\
772 
    }
773 
 
774 
#define o_apply_general_proc( p0, p1, p2, p3, p4, p5 )\
775 
    {\
776 
	out_basic_int((unsigned long)e_apply_general_proc, (unsigned)7);\
777 
	p0;\
778 
	ASSERT_SORT(s_shape);\
779 
	o_procprops_option(p1);\
780 
	p2;\
781 
	ASSERT_SORT(s_exp);\
782 
	o_otagexp_list(p3);\
783 
	p4;\
784 
	ASSERT_SORT(s_callees);\
785 
	p5;\
786 
	ASSERT_SORT(s_exp);\
787 
	SET_RSORT(s_exp);\
788 
    }
789 
 
790 
#define o_assign( p0, p1 )\
791 
    {\
792 
	out_basic_int((unsigned long)e_assign, (unsigned)7);\
793 
	p0;\
794 
	ASSERT_SORT(s_exp);\
795 
	p1;\
796 
	ASSERT_SORT(s_exp);\
797 
	SET_RSORT(s_exp);\
798 
    }
799 
 
800 
#define o_assign_with_mode( p0, p1, p2 )\
801 
    {\
802 
	out_basic_int((unsigned long)e_assign_with_mode, (unsigned)7);\
803 
	p0;\
804 
	ASSERT_SORT(s_transfer_mode);\
805 
	p1;\
806 
	ASSERT_SORT(s_exp);\
807 
	p2;\
808 
	ASSERT_SORT(s_exp);\
809 
	SET_RSORT(s_exp);\
810 
    }
811 
 
812 
#define o_bitfield_assign( p0, p1, p2 )\
813 
    {\
814 
	out_basic_int((unsigned long)e_bitfield_assign, (unsigned)7);\
815 
	p0;\
816 
	ASSERT_SORT(s_exp);\
817 
	p1;\
818 
	ASSERT_SORT(s_exp);\
819 
	p2;\
820 
	ASSERT_SORT(s_exp);\
821 
	SET_RSORT(s_exp);\
822 
    }
823 
 
824 
#define o_bitfield_assign_with_mode( p0, p1, p2, p3 )\
825 
    {\
826 
	out_basic_int((unsigned long)e_bitfield_assign_with_mode, (unsigned)7);\
827 
	p0;\
828 
	ASSERT_SORT(s_transfer_mode);\
829 
	p1;\
830 
	ASSERT_SORT(s_exp);\
831 
	p2;\
832 
	ASSERT_SORT(s_exp);\
833 
	p3;\
834 
	ASSERT_SORT(s_exp);\
835 
	SET_RSORT(s_exp);\
836 
    }
837 
 
838 
#define o_bitfield_contents( p0, p1, p2 )\
839 
    {\
840 
	out_basic_int((unsigned long)e_bitfield_contents, (unsigned)7);\
841 
	p0;\
842 
	ASSERT_SORT(s_bitfield_variety);\
843 
	p1;\
844 
	ASSERT_SORT(s_exp);\
845 
	p2;\
846 
	ASSERT_SORT(s_exp);\
847 
	SET_RSORT(s_exp);\
848 
    }
849 
 
850 
#define o_bitfield_contents_with_mode( p0, p1, p2, p3 )\
851 
    {\
852 
	out_basic_int((unsigned long)e_bitfield_contents_with_mode, (unsigned)7);\
853 
	p0;\
854 
	ASSERT_SORT(s_transfer_mode);\
855 
	p1;\
856 
	ASSERT_SORT(s_bitfield_variety);\
857 
	p2;\
858 
	ASSERT_SORT(s_exp);\
859 
	p3;\
860 
	ASSERT_SORT(s_exp);\
861 
	SET_RSORT(s_exp);\
862 
    }
863 
 
864 
#define o_case( p0, p1, p2 )\
865 
    {\
866 
	out_basic_int((unsigned long)e_case, (unsigned)7);\
867 
	p0;\
868 
	ASSERT_SORT(s_bool);\
869 
	p1;\
870 
	ASSERT_SORT(s_exp);\
871 
	o_caselim_list(p2);\
872 
	SET_RSORT(s_exp);\
873 
    }
874 
 
875 
#define o_change_bitfield_to_int( p0, p1 )\
876 
    {\
877 
	out_basic_int((unsigned long)e_change_bitfield_to_int, (unsigned)7);\
878 
	p0;\
879 
	ASSERT_SORT(s_variety);\
880 
	p1;\
881 
	ASSERT_SORT(s_exp);\
882 
	SET_RSORT(s_exp);\
883 
    }
884 
 
885 
#define o_change_floating_variety( p0, p1, p2 )\
886 
    {\
887 
	out_basic_int((unsigned long)e_change_floating_variety, (unsigned)7);\
888 
	p0;\
889 
	ASSERT_SORT(s_error_treatment);\
890 
	p1;\
891 
	ASSERT_SORT(s_floating_variety);\
892 
	p2;\
893 
	ASSERT_SORT(s_exp);\
894 
	SET_RSORT(s_exp);\
895 
    }
896 
 
897 
#define o_change_variety( p0, p1, p2 )\
898 
    {\
899 
	out_basic_int((unsigned long)e_change_variety, (unsigned)7);\
900 
	p0;\
901 
	ASSERT_SORT(s_error_treatment);\
902 
	p1;\
903 
	ASSERT_SORT(s_variety);\
904 
	p2;\
905 
	ASSERT_SORT(s_exp);\
906 
	SET_RSORT(s_exp);\
907 
    }
908 
 
909 
#define o_change_int_to_bitfield( p0, p1 )\
910 
    {\
911 
	out_basic_int((unsigned long)e_change_int_to_bitfield, (unsigned)7);\
912 
	p0;\
913 
	ASSERT_SORT(s_bitfield_variety);\
914 
	p1;\
915 
	ASSERT_SORT(s_exp);\
916 
	SET_RSORT(s_exp);\
917 
    }
918 
 
919 
#define o_complex_conjugate( p0 )\
920 
    {\
921 
	out_basic_int((unsigned long)e_complex_conjugate, (unsigned)7);\
922 
	p0;\
923 
	ASSERT_SORT(s_exp);\
924 
	SET_RSORT(s_exp);\
925 
    }
926 
 
927 
#define o_component( p0, p1, p2 )\
928 
    {\
929 
	out_basic_int((unsigned long)e_component, (unsigned)7);\
930 
	p0;\
931 
	ASSERT_SORT(s_shape);\
932 
	p1;\
933 
	ASSERT_SORT(s_exp);\
934 
	p2;\
935 
	ASSERT_SORT(s_exp);\
936 
	SET_RSORT(s_exp);\
937 
    }
938 
 
939 
#define o_concat_nof( p0, p1 )\
940 
    {\
941 
	out_basic_int((unsigned long)e_concat_nof, (unsigned)7);\
942 
	p0;\
943 
	ASSERT_SORT(s_exp);\
944 
	p1;\
945 
	ASSERT_SORT(s_exp);\
946 
	SET_RSORT(s_exp);\
947 
    }
948 
 
949 
#define o_conditional( p0, p1, p2 )\
950 
    {\
951 
	out_basic_int((unsigned long)e_conditional, (unsigned)7);\
952 
	p0;\
953 
	ASSERT_SORT(s_label);\
954 
	p1;\
955 
	ASSERT_SORT(s_exp);\
956 
	p2;\
957 
	ASSERT_SORT(s_exp);\
958 
	SET_RSORT(s_exp);\
959 
    }
960 
 
961 
#define o_contents( p0, p1 )\
962 
    {\
963 
	out_basic_int((unsigned long)e_contents, (unsigned)7);\
964 
	p0;\
965 
	ASSERT_SORT(s_shape);\
966 
	p1;\
967 
	ASSERT_SORT(s_exp);\
968 
	SET_RSORT(s_exp);\
969 
    }
970 
 
971 
#define o_contents_with_mode( p0, p1, p2 )\
972 
    {\
973 
	out_basic_int((unsigned long)e_contents_with_mode, (unsigned)7);\
974 
	p0;\
975 
	ASSERT_SORT(s_transfer_mode);\
976 
	p1;\
977 
	ASSERT_SORT(s_shape);\
978 
	p2;\
979 
	ASSERT_SORT(s_exp);\
980 
	SET_RSORT(s_exp);\
981 
    }
982 
 
983 
#define o_current_env\
984 
    {\
985 
	out_basic_int((unsigned long)e_current_env, (unsigned)7);\
986 
	SET_RSORT(s_exp);\
987 
    }
988 
 
989 
#define o_div0( p0, p1, p2, p3 )\
990 
    {\
991 
	out_basic_int((unsigned long)e_div0, (unsigned)7);\
992 
	p0;\
993 
	ASSERT_SORT(s_error_treatment);\
994 
	p1;\
995 
	ASSERT_SORT(s_error_treatment);\
996 
	p2;\
997 
	ASSERT_SORT(s_exp);\
998 
	p3;\
999 
	ASSERT_SORT(s_exp);\
1000 
	SET_RSORT(s_exp);\
1001 
    }
1002 
 
1003 
#define o_div1( p0, p1, p2, p3 )\
1004 
    {\
1005 
	out_basic_int((unsigned long)e_div1, (unsigned)7);\
1006 
	p0;\
1007 
	ASSERT_SORT(s_error_treatment);\
1008 
	p1;\
1009 
	ASSERT_SORT(s_error_treatment);\
1010 
	p2;\
1011 
	ASSERT_SORT(s_exp);\
1012 
	p3;\
1013 
	ASSERT_SORT(s_exp);\
1014 
	SET_RSORT(s_exp);\
1015 
    }
1016 
 
1017 
#define o_div2( p0, p1, p2, p3 )\
1018 
    {\
1019 
	out_basic_int((unsigned long)e_div2, (unsigned)7);\
1020 
	p0;\
1021 
	ASSERT_SORT(s_error_treatment);\
1022 
	p1;\
1023 
	ASSERT_SORT(s_error_treatment);\
1024 
	p2;\
1025 
	ASSERT_SORT(s_exp);\
1026 
	p3;\
1027 
	ASSERT_SORT(s_exp);\
1028 
	SET_RSORT(s_exp);\
1029 
    }
1030 
 
1031 
#define o_env_offset( p0, p1, p2 )\
1032 
    {\
1033 
	out_basic_int((unsigned long)e_env_offset, (unsigned)7);\
1034 
	p0;\
1035 
	ASSERT_SORT(s_alignment);\
1036 
	p1;\
1037 
	ASSERT_SORT(s_alignment);\
1038 
	p2;\
1039 
	ASSERT_SORT(s_tag);\
1040 
	SET_RSORT(s_exp);\
1041 
    }
1042 
 
1043 
#define o_env_size( p0 )\
1044 
    {\
1045 
	out_basic_int((unsigned long)e_env_size, (unsigned)7);\
1046 
	p0;\
1047 
	ASSERT_SORT(s_tag);\
1048 
	SET_RSORT(s_exp);\
1049 
    }
1050 
 
1051 
#define o_fail_installer( p0 )\
1052 
    {\
1053 
	out_basic_int((unsigned long)e_fail_installer, (unsigned)7);\
1054 
	p0;\
1055 
	ASSERT_SORT(s_string);\
1056 
	SET_RSORT(s_exp);\
1057 
    }
1058 
 
1059 
#define o_float_int( p0, p1, p2 )\
1060 
    {\
1061 
	out_basic_int((unsigned long)e_float_int, (unsigned)7);\
1062 
	p0;\
1063 
	ASSERT_SORT(s_error_treatment);\
1064 
	p1;\
1065 
	ASSERT_SORT(s_floating_variety);\
1066 
	p2;\
1067 
	ASSERT_SORT(s_exp);\
1068 
	SET_RSORT(s_exp);\
1069 
    }
1070 
 
1071 
#define o_floating_abs( p0, p1 )\
1072 
    {\
1073 
	out_basic_int((unsigned long)e_floating_abs, (unsigned)7);\
1074 
	p0;\
1075 
	ASSERT_SORT(s_error_treatment);\
1076 
	p1;\
1077 
	ASSERT_SORT(s_exp);\
1078 
	SET_RSORT(s_exp);\
1079 
    }
1080 
 
1081 
#define o_floating_div( p0, p1, p2 )\
1082 
    {\
1083 
	out_basic_int((unsigned long)e_floating_div, (unsigned)7);\
1084 
	p0;\
1085 
	ASSERT_SORT(s_error_treatment);\
1086 
	p1;\
1087 
	ASSERT_SORT(s_exp);\
1088 
	p2;\
1089 
	ASSERT_SORT(s_exp);\
1090 
	SET_RSORT(s_exp);\
1091 
    }
1092 
 
1093 
#define o_floating_minus( p0, p1, p2 )\
1094 
    {\
1095 
	out_basic_int((unsigned long)e_floating_minus, (unsigned)7);\
1096 
	p0;\
1097 
	ASSERT_SORT(s_error_treatment);\
1098 
	p1;\
1099 
	ASSERT_SORT(s_exp);\
1100 
	p2;\
1101 
	ASSERT_SORT(s_exp);\
1102 
	SET_RSORT(s_exp);\
1103 
    }
1104 
 
1105 
#define o_floating_maximum( p0, p1, p2 )\
1106 
    {\
1107 
	out_basic_int((unsigned long)e_floating_maximum, (unsigned)7);\
1108 
	p0;\
1109 
	ASSERT_SORT(s_error_treatment);\
1110 
	p1;\
1111 
	ASSERT_SORT(s_exp);\
1112 
	p2;\
1113 
	ASSERT_SORT(s_exp);\
1114 
	SET_RSORT(s_exp);\
1115 
    }
1116 
 
1117 
#define o_floating_minimum( p0, p1, p2 )\
1118 
    {\
1119 
	out_basic_int((unsigned long)e_floating_minimum, (unsigned)7);\
1120 
	p0;\
1121 
	ASSERT_SORT(s_error_treatment);\
1122 
	p1;\
1123 
	ASSERT_SORT(s_exp);\
1124 
	p2;\
1125 
	ASSERT_SORT(s_exp);\
1126 
	SET_RSORT(s_exp);\
1127 
    }
1128 
 
1129 
#define o_floating_mult( p0, p1 )\
1130 
    {\
1131 
	out_basic_int((unsigned long)e_floating_mult, (unsigned)7);\
1132 
	p0;\
1133 
	ASSERT_SORT(s_error_treatment);\
1134 
	o_exp_list(p1);\
1135 
	SET_RSORT(s_exp);\
1136 
    }
1137 
 
1138 
#define o_floating_negate( p0, p1 )\
1139 
    {\
1140 
	out_basic_int((unsigned long)e_floating_negate, (unsigned)7);\
1141 
	p0;\
1142 
	ASSERT_SORT(s_error_treatment);\
1143 
	p1;\
1144 
	ASSERT_SORT(s_exp);\
1145 
	SET_RSORT(s_exp);\
1146 
    }
1147 
 
1148 
#define o_floating_plus( p0, p1 )\
1149 
    {\
1150 
	out_basic_int((unsigned long)e_floating_plus, (unsigned)7);\
1151 
	p0;\
1152 
	ASSERT_SORT(s_error_treatment);\
1153 
	o_exp_list(p1);\
1154 
	SET_RSORT(s_exp);\
1155 
    }
1156 
 
1157 
#define o_floating_power( p0, p1, p2 )\
1158 
    {\
1159 
	out_basic_int((unsigned long)e_floating_power, (unsigned)7);\
1160 
	p0;\
1161 
	ASSERT_SORT(s_error_treatment);\
1162 
	p1;\
1163 
	ASSERT_SORT(s_exp);\
1164 
	p2;\
1165 
	ASSERT_SORT(s_exp);\
1166 
	SET_RSORT(s_exp);\
1167 
    }
1168 
 
1169 
#define o_floating_test( p0, p1, p2, p3, p4, p5 )\
1170 
    {\
1171 
	out_basic_int((unsigned long)e_floating_test, (unsigned)7);\
1172 
	o_nat_option(p0);\
1173 
	p1;\
1174 
	ASSERT_SORT(s_error_treatment);\
1175 
	p2;\
1176 
	ASSERT_SORT(s_ntest);\
1177 
	p3;\
1178 
	ASSERT_SORT(s_label);\
1179 
	p4;\
1180 
	ASSERT_SORT(s_exp);\
1181 
	p5;\
1182 
	ASSERT_SORT(s_exp);\
1183 
	SET_RSORT(s_exp);\
1184 
    }
1185 
 
1186 
#define o_goto( p0 )\
1187 
    {\
1188 
	out_basic_int((unsigned long)e_goto, (unsigned)7);\
1189 
	p0;\
1190 
	ASSERT_SORT(s_label);\
1191 
	SET_RSORT(s_exp);\
1192 
    }
1193 
 
1194 
#define o_goto_local_lv( p0 )\
1195 
    {\
1196 
	out_basic_int((unsigned long)e_goto_local_lv, (unsigned)7);\
1197 
	p0;\
1198 
	ASSERT_SORT(s_exp);\
1199 
	SET_RSORT(s_exp);\
1200 
    }
1201 
 
1202 
#define o_identify( p0, p1, p2, p3 )\
1203 
    {\
1204 
	out_basic_int((unsigned long)e_identify, (unsigned)7);\
1205 
	o_access_option(p0);\
1206 
	p1;\
1207 
	ASSERT_SORT(s_tag);\
1208 
	p2;\
1209 
	ASSERT_SORT(s_exp);\
1210 
	p3;\
1211 
	ASSERT_SORT(s_exp);\
1212 
	SET_RSORT(s_exp);\
1213 
    }
1214 
 
1215 
#define o_ignorable( p0 )\
1216 
    {\
1217 
	out_basic_int((unsigned long)e_ignorable, (unsigned)7);\
1218 
	p0;\
1219 
	ASSERT_SORT(s_exp);\
1220 
	SET_RSORT(s_exp);\
1221 
    }
1222 
 
1223 
#define o_imaginary_part( p0 )\
1224 
    {\
1225 
	out_basic_int((unsigned long)e_imaginary_part, (unsigned)7);\
1226 
	p0;\
1227 
	ASSERT_SORT(s_exp);\
1228 
	SET_RSORT(s_exp);\
1229 
    }
1230 
 
1231 
#define o_initial_value( p0 )\
1232 
    {\
1233 
	out_basic_int((unsigned long)e_initial_value, (unsigned)7);\
1234 
	p0;\
1235 
	ASSERT_SORT(s_exp);\
1236 
	SET_RSORT(s_exp);\
1237 
    }
1238 
 
1239 
#define o_integer_test( p0, p1, p2, p3, p4 )\
1240 
    {\
1241 
	out_basic_int((unsigned long)e_integer_test, (unsigned)7);\
1242 
	o_nat_option(p0);\
1243 
	p1;\
1244 
	ASSERT_SORT(s_ntest);\
1245 
	p2;\
1246 
	ASSERT_SORT(s_label);\
1247 
	p3;\
1248 
	ASSERT_SORT(s_exp);\
1249 
	p4;\
1250 
	ASSERT_SORT(s_exp);\
1251 
	SET_RSORT(s_exp);\
1252 
    }
1253 
 
1254 
#define o_labelled( p0, p1, p2 )\
1255 
    {\
1256 
	out_basic_int((unsigned long)e_labelled, (unsigned)7);\
1257 
	o_label_list(p0);\
1258 
	p1;\
1259 
	ASSERT_SORT(s_exp);\
1260 
	o_exp_list(p2);\
1261 
	SET_RSORT(s_exp);\
1262 
    }
1263 
 
1264 
#define o_last_local( p0 )\
1265 
    {\
1266 
	out_basic_int((unsigned long)e_last_local, (unsigned)7);\
1267 
	p0;\
1268 
	ASSERT_SORT(s_exp);\
1269 
	SET_RSORT(s_exp);\
1270 
    }
1271 
 
1272 
#define o_local_alloc( p0 )\
1273 
    {\
1274 
	out_basic_int((unsigned long)e_local_alloc, (unsigned)7);\
1275 
	p0;\
1276 
	ASSERT_SORT(s_exp);\
1277 
	SET_RSORT(s_exp);\
1278 
    }
1279 
 
1280 
#define o_local_alloc_check( p0 )\
1281 
    {\
1282 
	out_basic_int((unsigned long)e_local_alloc_check, (unsigned)7);\
1283 
	p0;\
1284 
	ASSERT_SORT(s_exp);\
1285 
	SET_RSORT(s_exp);\
1286 
    }
1287 
 
1288 
#define o_local_free( p0, p1 )\
1289 
    {\
1290 
	out_basic_int((unsigned long)e_local_free, (unsigned)7);\
1291 
	p0;\
1292 
	ASSERT_SORT(s_exp);\
1293 
	p1;\
1294 
	ASSERT_SORT(s_exp);\
1295 
	SET_RSORT(s_exp);\
1296 
    }
1297 
 
1298 
#define o_local_free_all\
1299 
    {\
1300 
	out_basic_int((unsigned long)e_local_free_all, (unsigned)7);\
1301 
	SET_RSORT(s_exp);\
1302 
    }
1303 
 
1304 
#define o_long_jump( p0, p1 )\
1305 
    {\
1306 
	out_basic_int((unsigned long)e_long_jump, (unsigned)7);\
1307 
	p0;\
1308 
	ASSERT_SORT(s_exp);\
1309 
	p1;\
1310 
	ASSERT_SORT(s_exp);\
1311 
	SET_RSORT(s_exp);\
1312 
    }
1313 
 
1314 
#define o_make_complex( p0, p1, p2 )\
1315 
    {\
1316 
	out_basic_int((unsigned long)e_make_complex, (unsigned)7);\
1317 
	p0;\
1318 
	ASSERT_SORT(s_floating_variety);\
1319 
	p1;\
1320 
	ASSERT_SORT(s_exp);\
1321 
	p2;\
1322 
	ASSERT_SORT(s_exp);\
1323 
	SET_RSORT(s_exp);\
1324 
    }
1325 
 
1326 
#define o_make_compound( p0, p1 )\
1327 
    {\
1328 
	out_basic_int((unsigned long)e_make_compound, (unsigned)7);\
1329 
	p0;\
1330 
	ASSERT_SORT(s_exp);\
1331 
	o_exp_list(p1);\
1332 
	SET_RSORT(s_exp);\
1333 
    }
1334 
 
1335 
#define o_make_floating( p0, p1, p2, p3, p4, p5 )\
1336 
    {\
1337 
	out_basic_int((unsigned long)e_make_floating, (unsigned)7);\
1338 
	p0;\
1339 
	ASSERT_SORT(s_floating_variety);\
1340 
	p1;\
1341 
	ASSERT_SORT(s_rounding_mode);\
1342 
	p2;\
1343 
	ASSERT_SORT(s_bool);\
1344 
	p3;\
1345 
	ASSERT_SORT(s_string);\
1346 
	p4;\
1347 
	ASSERT_SORT(s_nat);\
1348 
	p5;\
1349 
	ASSERT_SORT(s_signed_nat);\
1350 
	SET_RSORT(s_exp);\
1351 
    }
1352 
 
1353 
#define o_make_general_proc( p0, p1, p2, p3, p4 )\
1354 
    {\
1355 
	out_basic_int((unsigned long)e_make_general_proc, (unsigned)7);\
1356 
	p0;\
1357 
	ASSERT_SORT(s_shape);\
1358 
	o_procprops_option(p1);\
1359 
	o_tagshacc_list(p2);\
1360 
	o_tagshacc_list(p3);\
1361 
	p4;\
1362 
	ASSERT_SORT(s_exp);\
1363 
	SET_RSORT(s_exp);\
1364 
    }
1365 
 
1366 
#define o_make_int( p0, p1 )\
1367 
    {\
1368 
	out_basic_int((unsigned long)e_make_int, (unsigned)7);\
1369 
	p0;\
1370 
	ASSERT_SORT(s_variety);\
1371 
	p1;\
1372 
	ASSERT_SORT(s_signed_nat);\
1373 
	SET_RSORT(s_exp);\
1374 
    }
1375 
 
1376 
#define o_make_local_lv( p0 )\
1377 
    {\
1378 
	out_basic_int((unsigned long)e_make_local_lv, (unsigned)7);\
1379 
	p0;\
1380 
	ASSERT_SORT(s_label);\
1381 
	SET_RSORT(s_exp);\
1382 
    }
1383 
 
1384 
#define o_make_nof( p0 )\
1385 
    {\
1386 
	out_basic_int((unsigned long)e_make_nof, (unsigned)7);\
1387 
	o_exp_list(p0);\
1388 
	SET_RSORT(s_exp);\
1389 
    }
1390 
 
1391 
#define o_make_nof_int( p0, p1 )\
1392 
    {\
1393 
	out_basic_int((unsigned long)e_make_nof_int, (unsigned)7);\
1394 
	p0;\
1395 
	ASSERT_SORT(s_variety);\
1396 
	p1;\
1397 
	ASSERT_SORT(s_string);\
1398 
	SET_RSORT(s_exp);\
1399 
    }
1400 
 
1401 
#define o_make_null_local_lv\
1402 
    {\
1403 
	out_basic_int((unsigned long)e_make_null_local_lv, (unsigned)7);\
1404 
	SET_RSORT(s_exp);\
1405 
    }
1406 
 
1407 
#define o_make_null_proc\
1408 
    {\
1409 
	out_basic_int((unsigned long)e_make_null_proc, (unsigned)7);\
1410 
	SET_RSORT(s_exp);\
1411 
    }
1412 
 
1413 
#define o_make_null_ptr( p0 )\
1414 
    {\
1415 
	out_basic_int((unsigned long)e_make_null_ptr, (unsigned)7);\
1416 
	p0;\
1417 
	ASSERT_SORT(s_alignment);\
1418 
	SET_RSORT(s_exp);\
1419 
    }
1420 
 
1421 
#define o_make_proc( p0, p1, p2, p3 )\
1422 
    {\
1423 
	out_basic_int((unsigned long)e_make_proc, (unsigned)7);\
1424 
	p0;\
1425 
	ASSERT_SORT(s_shape);\
1426 
	o_tagshacc_list(p1);\
1427 
	o_tagacc_option(p2);\
1428 
	p3;\
1429 
	ASSERT_SORT(s_exp);\
1430 
	SET_RSORT(s_exp);\
1431 
    }
1432 
 
1433 
#define o_make_stack_limit( p0, p1, p2 )\
1434 
    {\
1435 
	out_basic_int((unsigned long)e_make_stack_limit, (unsigned)7);\
1436 
	p0;\
1437 
	ASSERT_SORT(s_exp);\
1438 
	p1;\
1439 
	ASSERT_SORT(s_exp);\
1440 
	p2;\
1441 
	ASSERT_SORT(s_exp);\
1442 
	SET_RSORT(s_exp);\
1443 
    }
1444 
 
1445 
#define o_make_top\
1446 
    {\
1447 
	out_basic_int((unsigned long)e_make_top, (unsigned)7);\
1448 
	SET_RSORT(s_exp);\
1449 
    }
1450 
 
1451 
#define o_make_value( p0 )\
1452 
    {\
1453 
	out_basic_int((unsigned long)e_make_value, (unsigned)7);\
1454 
	p0;\
1455 
	ASSERT_SORT(s_shape);\
1456 
	SET_RSORT(s_exp);\
1457 
    }
1458 
 
1459 
#define o_maximum( p0, p1 )\
1460 
    {\
1461 
	out_basic_int((unsigned long)e_maximum, (unsigned)7);\
1462 
	p0;\
1463 
	ASSERT_SORT(s_exp);\
1464 
	p1;\
1465 
	ASSERT_SORT(s_exp);\
1466 
	SET_RSORT(s_exp);\
1467 
    }
1468 
 
1469 
#define o_minimum( p0, p1 )\
1470 
    {\
1471 
	out_basic_int((unsigned long)e_minimum, (unsigned)7);\
1472 
	p0;\
1473 
	ASSERT_SORT(s_exp);\
1474 
	p1;\
1475 
	ASSERT_SORT(s_exp);\
1476 
	SET_RSORT(s_exp);\
1477 
    }
1478 
 
1479 
#define o_minus( p0, p1, p2 )\
1480 
    {\
1481 
	out_basic_int((unsigned long)e_minus, (unsigned)7);\
1482 
	p0;\
1483 
	ASSERT_SORT(s_error_treatment);\
1484 
	p1;\
1485 
	ASSERT_SORT(s_exp);\
1486 
	p2;\
1487 
	ASSERT_SORT(s_exp);\
1488 
	SET_RSORT(s_exp);\
1489 
    }
1490 
 
1491 
#define o_move_some( p0, p1, p2, p3 )\
1492 
    {\
1493 
	out_basic_int((unsigned long)e_move_some, (unsigned)7);\
1494 
	p0;\
1495 
	ASSERT_SORT(s_transfer_mode);\
1496 
	p1;\
1497 
	ASSERT_SORT(s_exp);\
1498 
	p2;\
1499 
	ASSERT_SORT(s_exp);\
1500 
	p3;\
1501 
	ASSERT_SORT(s_exp);\
1502 
	SET_RSORT(s_exp);\
1503 
    }
1504 
 
1505 
#define o_mult( p0, p1, p2 )\
1506 
    {\
1507 
	out_basic_int((unsigned long)e_mult, (unsigned)7);\
1508 
	p0;\
1509 
	ASSERT_SORT(s_error_treatment);\
1510 
	p1;\
1511 
	ASSERT_SORT(s_exp);\
1512 
	p2;\
1513 
	ASSERT_SORT(s_exp);\
1514 
	SET_RSORT(s_exp);\
1515 
    }
1516 
 
1517 
#define o_n_copies( p0, p1 )\
1518 
    {\
1519 
	out_basic_int((unsigned long)e_n_copies, (unsigned)7);\
1520 
	p0;\
1521 
	ASSERT_SORT(s_nat);\
1522 
	p1;\
1523 
	ASSERT_SORT(s_exp);\
1524 
	SET_RSORT(s_exp);\
1525 
    }
1526 
 
1527 
#define o_negate( p0, p1 )\
1528 
    {\
1529 
	out_basic_int((unsigned long)e_negate, (unsigned)7);\
1530 
	p0;\
1531 
	ASSERT_SORT(s_error_treatment);\
1532 
	p1;\
1533 
	ASSERT_SORT(s_exp);\
1534 
	SET_RSORT(s_exp);\
1535 
    }
1536 
 
1537 
#define o_not( p0 )\
1538 
    {\
1539 
	out_basic_int((unsigned long)e_not, (unsigned)7);\
1540 
	p0;\
1541 
	ASSERT_SORT(s_exp);\
1542 
	SET_RSORT(s_exp);\
1543 
    }
1544 
 
1545 
#define o_obtain_tag( p0 )\
1546 
    {\
1547 
	out_basic_int((unsigned long)e_obtain_tag, (unsigned)7);\
1548 
	p0;\
1549 
	ASSERT_SORT(s_tag);\
1550 
	SET_RSORT(s_exp);\
1551 
    }
1552 
 
1553 
#define o_offset_add( p0, p1 )\
1554 
    {\
1555 
	out_basic_int((unsigned long)e_offset_add, (unsigned)7);\
1556 
	p0;\
1557 
	ASSERT_SORT(s_exp);\
1558 
	p1;\
1559 
	ASSERT_SORT(s_exp);\
1560 
	SET_RSORT(s_exp);\
1561 
    }
1562 
 
1563 
#define o_offset_div( p0, p1, p2 )\
1564 
    {\
1565 
	out_basic_int((unsigned long)e_offset_div, (unsigned)7);\
1566 
	p0;\
1567 
	ASSERT_SORT(s_variety);\
1568 
	p1;\
1569 
	ASSERT_SORT(s_exp);\
1570 
	p2;\
1571 
	ASSERT_SORT(s_exp);\
1572 
	SET_RSORT(s_exp);\
1573 
    }
1574 
 
1575 
#define o_offset_div_by_int( p0, p1 )\
1576 
    {\
1577 
	out_basic_int((unsigned long)e_offset_div_by_int, (unsigned)7);\
1578 
	p0;\
1579 
	ASSERT_SORT(s_exp);\
1580 
	p1;\
1581 
	ASSERT_SORT(s_exp);\
1582 
	SET_RSORT(s_exp);\
1583 
    }
1584 
 
1585 
#define o_offset_max( p0, p1 )\
1586 
    {\
1587 
	out_basic_int((unsigned long)e_offset_max, (unsigned)7);\
1588 
	p0;\
1589 
	ASSERT_SORT(s_exp);\
1590 
	p1;\
1591 
	ASSERT_SORT(s_exp);\
1592 
	SET_RSORT(s_exp);\
1593 
    }
1594 
 
1595 
#define o_offset_mult( p0, p1 )\
1596 
    {\
1597 
	out_basic_int((unsigned long)e_offset_mult, (unsigned)7);\
1598 
	p0;\
1599 
	ASSERT_SORT(s_exp);\
1600 
	p1;\
1601 
	ASSERT_SORT(s_exp);\
1602 
	SET_RSORT(s_exp);\
1603 
    }
1604 
 
1605 
#define o_offset_negate( p0 )\
1606 
    {\
1607 
	out_basic_int((unsigned long)e_offset_negate, (unsigned)7);\
1608 
	p0;\
1609 
	ASSERT_SORT(s_exp);\
1610 
	SET_RSORT(s_exp);\
1611 
    }
1612 
 
1613 
#define o_offset_pad( p0, p1 )\
1614 
    {\
1615 
	out_basic_int((unsigned long)e_offset_pad, (unsigned)7);\
1616 
	p0;\
1617 
	ASSERT_SORT(s_alignment);\
1618 
	p1;\
1619 
	ASSERT_SORT(s_exp);\
1620 
	SET_RSORT(s_exp);\
1621 
    }
1622 
 
1623 
#define o_offset_subtract( p0, p1 )\
1624 
    {\
1625 
	out_basic_int((unsigned long)e_offset_subtract, (unsigned)7);\
1626 
	p0;\
1627 
	ASSERT_SORT(s_exp);\
1628 
	p1;\
1629 
	ASSERT_SORT(s_exp);\
1630 
	SET_RSORT(s_exp);\
1631 
    }
1632 
 
1633 
#define o_offset_test( p0, p1, p2, p3, p4 )\
1634 
    {\
1635 
	out_basic_int((unsigned long)e_offset_test, (unsigned)7);\
1636 
	o_nat_option(p0);\
1637 
	p1;\
1638 
	ASSERT_SORT(s_ntest);\
1639 
	p2;\
1640 
	ASSERT_SORT(s_label);\
1641 
	p3;\
1642 
	ASSERT_SORT(s_exp);\
1643 
	p4;\
1644 
	ASSERT_SORT(s_exp);\
1645 
	SET_RSORT(s_exp);\
1646 
    }
1647 
 
1648 
#define o_offset_zero( p0 )\
1649 
    {\
1650 
	out_basic_int((unsigned long)e_offset_zero, (unsigned)7);\
1651 
	p0;\
1652 
	ASSERT_SORT(s_alignment);\
1653 
	SET_RSORT(s_exp);\
1654 
    }
1655 
 
1656 
#define o_or( p0, p1 )\
1657 
    {\
1658 
	out_basic_int((unsigned long)e_or, (unsigned)7);\
1659 
	p0;\
1660 
	ASSERT_SORT(s_exp);\
1661 
	p1;\
1662 
	ASSERT_SORT(s_exp);\
1663 
	SET_RSORT(s_exp);\
1664 
    }
1665 
 
1666 
#define o_plus( p0, p1, p2 )\
1667 
    {\
1668 
	out_basic_int((unsigned long)e_plus, (unsigned)7);\
1669 
	p0;\
1670 
	ASSERT_SORT(s_error_treatment);\
1671 
	p1;\
1672 
	ASSERT_SORT(s_exp);\
1673 
	p2;\
1674 
	ASSERT_SORT(s_exp);\
1675 
	SET_RSORT(s_exp);\
1676 
    }
1677 
 
1678 
#define o_pointer_test( p0, p1, p2, p3, p4 )\
1679 
    {\
1680 
	out_basic_int((unsigned long)e_pointer_test, (unsigned)7);\
1681 
	o_nat_option(p0);\
1682 
	p1;\
1683 
	ASSERT_SORT(s_ntest);\
1684 
	p2;\
1685 
	ASSERT_SORT(s_label);\
1686 
	p3;\
1687 
	ASSERT_SORT(s_exp);\
1688 
	p4;\
1689 
	ASSERT_SORT(s_exp);\
1690 
	SET_RSORT(s_exp);\
1691 
    }
1692 
 
1693 
#define o_power( p0, p1, p2 )\
1694 
    {\
1695 
	out_basic_int((unsigned long)e_power, (unsigned)7);\
1696 
	p0;\
1697 
	ASSERT_SORT(s_error_treatment);\
1698 
	p1;\
1699 
	ASSERT_SORT(s_exp);\
1700 
	p2;\
1701 
	ASSERT_SORT(s_exp);\
1702 
	SET_RSORT(s_exp);\
1703 
    }
1704 
 
1705 
#define o_proc_test( p0, p1, p2, p3, p4 )\
1706 
    {\
1707 
	out_basic_int((unsigned long)e_proc_test, (unsigned)7);\
1708 
	o_nat_option(p0);\
1709 
	p1;\
1710 
	ASSERT_SORT(s_ntest);\
1711 
	p2;\
1712 
	ASSERT_SORT(s_label);\
1713 
	p3;\
1714 
	ASSERT_SORT(s_exp);\
1715 
	p4;\
1716 
	ASSERT_SORT(s_exp);\
1717 
	SET_RSORT(s_exp);\
1718 
    }
1719 
 
1720 
#define o_profile( p0 )\
1721 
    {\
1722 
	out_basic_int((unsigned long)e_profile, (unsigned)7);\
1723 
	p0;\
1724 
	ASSERT_SORT(s_nat);\
1725 
	SET_RSORT(s_exp);\
1726 
    }
1727 
 
1728 
#define o_real_part( p0 )\
1729 
    {\
1730 
	out_basic_int((unsigned long)e_real_part, (unsigned)7);\
1731 
	p0;\
1732 
	ASSERT_SORT(s_exp);\
1733 
	SET_RSORT(s_exp);\
1734 
    }
1735 
 
1736 
#define o_rem0( p0, p1, p2, p3 )\
1737 
    {\
1738 
	out_basic_int((unsigned long)e_rem0, (unsigned)7);\
1739 
	p0;\
1740 
	ASSERT_SORT(s_error_treatment);\
1741 
	p1;\
1742 
	ASSERT_SORT(s_error_treatment);\
1743 
	p2;\
1744 
	ASSERT_SORT(s_exp);\
1745 
	p3;\
1746 
	ASSERT_SORT(s_exp);\
1747 
	SET_RSORT(s_exp);\
1748 
    }
1749 
 
1750 
#define o_rem1( p0, p1, p2, p3 )\
1751 
    {\
1752 
	out_basic_int((unsigned long)e_rem1, (unsigned)7);\
1753 
	p0;\
1754 
	ASSERT_SORT(s_error_treatment);\
1755 
	p1;\
1756 
	ASSERT_SORT(s_error_treatment);\
1757 
	p2;\
1758 
	ASSERT_SORT(s_exp);\
1759 
	p3;\
1760 
	ASSERT_SORT(s_exp);\
1761 
	SET_RSORT(s_exp);\
1762 
    }
1763 
 
1764 
#define o_rem2( p0, p1, p2, p3 )\
1765 
    {\
1766 
	out_basic_int((unsigned long)e_rem2, (unsigned)7);\
1767 
	p0;\
1768 
	ASSERT_SORT(s_error_treatment);\
1769 
	p1;\
1770 
	ASSERT_SORT(s_error_treatment);\
1771 
	p2;\
1772 
	ASSERT_SORT(s_exp);\
1773 
	p3;\
1774 
	ASSERT_SORT(s_exp);\
1775 
	SET_RSORT(s_exp);\
1776 
    }
1777 
 
1778 
#define o_repeat( p0, p1, p2 )\
1779 
    {\
1780 
	out_basic_int((unsigned long)e_repeat, (unsigned)7);\
1781 
	p0;\
1782 
	ASSERT_SORT(s_label);\
1783 
	p1;\
1784 
	ASSERT_SORT(s_exp);\
1785 
	p2;\
1786 
	ASSERT_SORT(s_exp);\
1787 
	SET_RSORT(s_exp);\
1788 
    }
1789 
 
1790 
#define o_return( p0 )\
1791 
    {\
1792 
	out_basic_int((unsigned long)e_return, (unsigned)7);\
1793 
	p0;\
1794 
	ASSERT_SORT(s_exp);\
1795 
	SET_RSORT(s_exp);\
1796 
    }
1797 
 
1798 
#define o_return_to_label( p0 )\
1799 
    {\
1800 
	out_basic_int((unsigned long)e_return_to_label, (unsigned)7);\
1801 
	p0;\
1802 
	ASSERT_SORT(s_exp);\
1803 
	SET_RSORT(s_exp);\
1804 
    }
1805 
 
1806 
#define o_round_with_mode( p0, p1, p2, p3 )\
1807 
    {\
1808 
	out_basic_int((unsigned long)e_round_with_mode, (unsigned)7);\
1809 
	p0;\
1810 
	ASSERT_SORT(s_error_treatment);\
1811 
	p1;\
1812 
	ASSERT_SORT(s_rounding_mode);\
1813 
	p2;\
1814 
	ASSERT_SORT(s_variety);\
1815 
	p3;\
1816 
	ASSERT_SORT(s_exp);\
1817 
	SET_RSORT(s_exp);\
1818 
    }
1819 
 
1820 
#define o_rotate_left( p0, p1 )\
1821 
    {\
1822 
	out_basic_int((unsigned long)e_rotate_left, (unsigned)7);\
1823 
	p0;\
1824 
	ASSERT_SORT(s_exp);\
1825 
	p1;\
1826 
	ASSERT_SORT(s_exp);\
1827 
	SET_RSORT(s_exp);\
1828 
    }
1829 
 
1830 
#define o_rotate_right( p0, p1 )\
1831 
    {\
1832 
	out_basic_int((unsigned long)e_rotate_right, (unsigned)7);\
1833 
	p0;\
1834 
	ASSERT_SORT(s_exp);\
1835 
	p1;\
1836 
	ASSERT_SORT(s_exp);\
1837 
	SET_RSORT(s_exp);\
1838 
    }
1839 
 
1840 
#define o_sequence( p0, p1 )\
1841 
    {\
1842 
	out_basic_int((unsigned long)e_sequence, (unsigned)7);\
1843 
	o_exp_list(p0);\
1844 
	p1;\
1845 
	ASSERT_SORT(s_exp);\
1846 
	SET_RSORT(s_exp);\
1847 
    }
1848 
 
1849 
#define o_set_stack_limit( p0 )\
1850 
    {\
1851 
	out_basic_int((unsigned long)e_set_stack_limit, (unsigned)7);\
1852 
	p0;\
1853 
	ASSERT_SORT(s_exp);\
1854 
	SET_RSORT(s_exp);\
1855 
    }
1856 
 
1857 
#define o_shape_offset( p0 )\
1858 
    {\
1859 
	out_basic_int((unsigned long)e_shape_offset, (unsigned)7);\
1860 
	p0;\
1861 
	ASSERT_SORT(s_shape);\
1862 
	SET_RSORT(s_exp);\
1863 
    }
1864 
 
1865 
#define o_shift_left( p0, p1, p2 )\
1866 
    {\
1867 
	out_basic_int((unsigned long)e_shift_left, (unsigned)7);\
1868 
	p0;\
1869 
	ASSERT_SORT(s_error_treatment);\
1870 
	p1;\
1871 
	ASSERT_SORT(s_exp);\
1872 
	p2;\
1873 
	ASSERT_SORT(s_exp);\
1874 
	SET_RSORT(s_exp);\
1875 
    }
1876 
 
1877 
#define o_shift_right( p0, p1 )\
1878 
    {\
1879 
	out_basic_int((unsigned long)e_shift_right, (unsigned)7);\
1880 
	p0;\
1881 
	ASSERT_SORT(s_exp);\
1882 
	p1;\
1883 
	ASSERT_SORT(s_exp);\
1884 
	SET_RSORT(s_exp);\
1885 
    }
1886 
 
1887 
#define o_subtract_ptrs( p0, p1 )\
1888 
    {\
1889 
	out_basic_int((unsigned long)e_subtract_ptrs, (unsigned)7);\
1890 
	p0;\
1891 
	ASSERT_SORT(s_exp);\
1892 
	p1;\
1893 
	ASSERT_SORT(s_exp);\
1894 
	SET_RSORT(s_exp);\
1895 
    }
1896 
 
1897 
#define o_tail_call( p0, p1, p2 )\
1898 
    {\
1899 
	out_basic_int((unsigned long)e_tail_call, (unsigned)7);\
1900 
	o_procprops_option(p0);\
1901 
	p1;\
1902 
	ASSERT_SORT(s_exp);\
1903 
	p2;\
1904 
	ASSERT_SORT(s_callees);\
1905 
	SET_RSORT(s_exp);\
1906 
    }
1907 
 
1908 
#define o_untidy_return( p0 )\
1909 
    {\
1910 
	out_basic_int((unsigned long)e_untidy_return, (unsigned)7);\
1911 
	p0;\
1912 
	ASSERT_SORT(s_exp);\
1913 
	SET_RSORT(s_exp);\
1914 
    }
1915 
 
1916 
#define o_variable( p0, p1, p2, p3 )\
1917 
    {\
1918 
	out_basic_int((unsigned long)e_variable, (unsigned)7);\
1919 
	o_access_option(p0);\
1920 
	p1;\
1921 
	ASSERT_SORT(s_tag);\
1922 
	p2;\
1923 
	ASSERT_SORT(s_exp);\
1924 
	p3;\
1925 
	ASSERT_SORT(s_exp);\
1926 
	SET_RSORT(s_exp);\
1927 
    }
1928 
 
1929 
#define o_xor( p0, p1 )\
1930 
    {\
1931 
	out_basic_int((unsigned long)e_xor, (unsigned)7);\
1932 
	p0;\
1933 
	ASSERT_SORT(s_exp);\
1934 
	p1;\
1935 
	ASSERT_SORT(s_exp);\
1936 
	SET_RSORT(s_exp);\
1937 
    }
1938 
 
1939 
 
1940 
/* CONSTRUCTS FOR EXTERN_LINK */
1941 
 
1942 
#define o_make_extern_link( p0 )\
1943 
    {\
1944 
	o_linkextern_list(p0);\
1945 
	SET_RSORT(s_extern_link);\
1946 
    }
1947 
 
1948 
 
1949 
/* CONSTRUCTS FOR EXTERNAL */
1950 
 
1951 
#define o_string_extern( p0 )\
1952 
    {\
1953 
	out_basic_int((unsigned long)e_string_extern, (unsigned)2);\
1954 
	p0;\
1955 
	ASSERT_SORT(s_tdfident);\
1956 
	SET_RSORT(s_external);\
1957 
    }
1958 
 
1959 
#define o_unique_extern( p0 )\
1960 
    {\
1961 
	out_basic_int((unsigned long)e_unique_extern, (unsigned)2);\
1962 
	p0;\
1963 
	ASSERT_SORT(s_unique);\
1964 
	SET_RSORT(s_external);\
1965 
    }
1966 
 
1967 
#define o_chain_extern( p0, p1 )\
1968 
    {\
1969 
	out_basic_int((unsigned long)e_chain_extern, (unsigned)2);\
1970 
	p0;\
1971 
	ASSERT_SORT(s_tdfident);\
1972 
	p1;\
1973 
	ASSERT_SORT(s_tdfint);\
1974 
	SET_RSORT(s_external);\
1975 
    }
1976 
 
1977 
 
1978 
/* CONSTRUCTS FOR FILENAME */
1979 
 
1980 
#define o_filename_apply_token( p0, p1 )\
1981 
    TOK_APP (\
1982 
	out_basic_int((unsigned long)e_filename_apply_token, (unsigned)2),\
1983 
	s_filename, p0, p1)
1984 
 
1985 
#define o_make_filename( p0, p1, p2 )\
1986 
    {\
1987 
	out_basic_int((unsigned long)e_make_filename, (unsigned)2);\
1988 
	p0;\
1989 
	ASSERT_SORT(s_nat);\
1990 
	p1;\
1991 
	ASSERT_SORT(s_tdfstring);\
1992 
	p2;\
1993 
	ASSERT_SORT(s_tdfstring);\
1994 
	SET_RSORT(s_filename);\
1995 
    }
1996 
 
1997 
 
1998 
/* CONSTRUCTS FOR FLOATING_VARIETY */
1999 
 
2000 
#define o_flvar_apply_token( p0, p1 )\
2001 
    TOK_APP (\
2002 
	out_basic_int((unsigned long)e_flvar_apply_token, (unsigned)3),\
2003 
	s_floating_variety, p0, p1)
2004 
 
2005 
#define o_flvar_cond( p0, p1, p2 )\
2006 
    TDF_COND (\
2007 
	out_basic_int((unsigned long)e_flvar_cond, (unsigned)3),\
2008 
	s_floating_variety, p0, p1, p2)
2009 
 
2010 
#define o_flvar_parms( p0, p1, p2, p3 )\
2011 
    {\
2012 
	out_basic_int((unsigned long)e_flvar_parms, (unsigned)3);\
2013 
	p0;\
2014 
	ASSERT_SORT(s_nat);\
2015 
	p1;\
2016 
	ASSERT_SORT(s_nat);\
2017 
	p2;\
2018 
	ASSERT_SORT(s_nat);\
2019 
	p3;\
2020 
	ASSERT_SORT(s_nat);\
2021 
	SET_RSORT(s_floating_variety);\
2022 
    }
2023 
 
2024 
#define o_complex_parms( p0, p1, p2, p3 )\
2025 
    {\
2026 
	out_basic_int((unsigned long)e_complex_parms, (unsigned)3);\
2027 
	p0;\
2028 
	ASSERT_SORT(s_nat);\
2029 
	p1;\
2030 
	ASSERT_SORT(s_nat);\
2031 
	p2;\
2032 
	ASSERT_SORT(s_nat);\
2033 
	p3;\
2034 
	ASSERT_SORT(s_nat);\
2035 
	SET_RSORT(s_floating_variety);\
2036 
    }
2037 
 
2038 
#define o_float_of_complex( p0 )\
2039 
    {\
2040 
	out_basic_int((unsigned long)e_float_of_complex, (unsigned)3);\
2041 
	p0;\
2042 
	ASSERT_SORT(s_shape);\
2043 
	SET_RSORT(s_floating_variety);\
2044 
    }
2045 
 
2046 
#define o_complex_of_float( p0 )\
2047 
    {\
2048 
	out_basic_int((unsigned long)e_complex_of_float, (unsigned)3);\
2049 
	p0;\
2050 
	ASSERT_SORT(s_shape);\
2051 
	SET_RSORT(s_floating_variety);\
2052 
    }
2053 
 
2054 
 
2055 
/* CONSTRUCTS FOR GROUP */
2056 
 
2057 
#define o_make_group( p0 )\
2058 
    {\
2059 
	o_unit_list(p0);\
2060 
	SET_RSORT(s_group);\
2061 
    }
2062 
 
2063 
 
2064 
/* CONSTRUCTS FOR LABEL */
2065 
 
2066 
#define o_label_apply_token( p0, p1 )\
2067 
    TOK_APP (\
2068 
	out_extendable_int((unsigned long)e_label_apply_token, (unsigned)1),\
2069 
	s_label, p0, p1)
2070 
 
2071 
#define o_make_label( p0 )\
2072 
    {\
2073 
	out_basic_int((unsigned long)e_make_label, (unsigned)1);\
2074 
	p0;\
2075 
	ASSERT_SORT(s_tdfint);\
2076 
	SET_RSORT(s_label);\
2077 
    }
2078 
 
2079 
 
2080 
/* CONSTRUCTS FOR LINK */
2081 
 
2082 
#define o_make_link( p0, p1 )\
2083 
    {\
2084 
	p0;\
2085 
	ASSERT_SORT(s_tdfint);\
2086 
	p1;\
2087 
	ASSERT_SORT(s_tdfint);\
2088 
	SET_RSORT(s_link);\
2089 
    }
2090 
 
2091 
 
2092 
/* CONSTRUCTS FOR LINKEXTERN */
2093 
 
2094 
#define o_make_linkextern( p0, p1 )\
2095 
    {\
2096 
	p0;\
2097 
	ASSERT_SORT(s_tdfint);\
2098 
	p1;\
2099 
	ASSERT_SORT(s_external);\
2100 
	SET_RSORT(s_linkextern);\
2101 
    }
2102 
 
2103 
 
2104 
/* CONSTRUCTS FOR LINKINFO */
2105 
 
2106 
#define o_static_name_def( p0, p1 )\
2107 
    {\
2108 
	out_basic_int((unsigned long)e_static_name_def, (unsigned)2);\
2109 
	p0;\
2110 
	ASSERT_SORT(s_exp);\
2111 
	p1;\
2112 
	ASSERT_SORT(s_tdfstring);\
2113 
	SET_RSORT(s_linkinfo);\
2114 
    }
2115 
 
2116 
#define o_make_comment( p0 )\
2117 
    {\
2118 
	out_basic_int((unsigned long)e_make_comment, (unsigned)2);\
2119 
	p0;\
2120 
	ASSERT_SORT(s_tdfstring);\
2121 
	SET_RSORT(s_linkinfo);\
2122 
    }
2123 
 
2124 
#define o_make_weak_defn( p0, p1 )\
2125 
    {\
2126 
	out_basic_int((unsigned long)e_make_weak_defn, (unsigned)2);\
2127 
	p0;\
2128 
	ASSERT_SORT(s_exp);\
2129 
	p1;\
2130 
	ASSERT_SORT(s_exp);\
2131 
	SET_RSORT(s_linkinfo);\
2132 
    }
2133 
 
2134 
#define o_make_weak_symbol( p0, p1 )\
2135 
    {\
2136 
	out_extendable_int((unsigned long)e_make_weak_symbol, (unsigned)2);\
2137 
	p0;\
2138 
	ASSERT_SORT(s_tdfstring);\
2139 
	p1;\
2140 
	ASSERT_SORT(s_exp);\
2141 
	SET_RSORT(s_linkinfo);\
2142 
    }
2143 
 
2144 
 
2145 
/* CONSTRUCTS FOR LINKINFO_PROPS */
2146 
 
2147 
#define o_make_linkinfos( p0, p1 )\
2148 
    {\
2149 
	p0;\
2150 
	ASSERT_SORT(s_tdfint);\
2151 
	o_linkinfo_list(p1);\
2152 
	SET_RSORT(s_linkinfo_props);\
2153 
    }
2154 
 
2155 
 
2156 
/* CONSTRUCTS FOR LINKS */
2157 
 
2158 
#define o_make_links( p0 )\
2159 
    {\
2160 
	o_link_list(p0);\
2161 
	SET_RSORT(s_links);\
2162 
    }
2163 
 
2164 
 
2165 
/* CONSTRUCTS FOR NAT */
2166 
 
2167 
#define o_nat_apply_token( p0, p1 )\
2168 
    TOK_APP (\
2169 
	out_basic_int((unsigned long)e_nat_apply_token, (unsigned)3),\
2170 
	s_nat, p0, p1)
2171 
 
2172 
#define o_nat_cond( p0, p1, p2 )\
2173 
    TDF_COND (\
2174 
	out_basic_int((unsigned long)e_nat_cond, (unsigned)3),\
2175 
	s_nat, p0, p1, p2)
2176 
 
2177 
#define o_computed_nat( p0 )\
2178 
    {\
2179 
	out_basic_int((unsigned long)e_computed_nat, (unsigned)3);\
2180 
	p0;\
2181 
	ASSERT_SORT(s_exp);\
2182 
	SET_RSORT(s_nat);\
2183 
    }
2184 
 
2185 
#define o_error_val( p0 )\
2186 
    {\
2187 
	out_basic_int((unsigned long)e_error_val, (unsigned)3);\
2188 
	p0;\
2189 
	ASSERT_SORT(s_error_code);\
2190 
	SET_RSORT(s_nat);\
2191 
    }
2192 
 
2193 
#define o_make_nat( p0 )\
2194 
    {\
2195 
	out_basic_int((unsigned long)e_make_nat, (unsigned)3);\
2196 
	p0;\
2197 
	ASSERT_SORT(s_tdfint);\
2198 
	SET_RSORT(s_nat);\
2199 
    }
2200 
 
2201 
 
2202 
/* CONSTRUCTS FOR NTEST */
2203 
 
2204 
#define o_ntest_apply_token( p0, p1 )\
2205 
    TOK_APP (\
2206 
	out_basic_int((unsigned long)e_ntest_apply_token, (unsigned)4),\
2207 
	s_ntest, p0, p1)
2208 
 
2209 
#define o_ntest_cond( p0, p1, p2 )\
2210 
    TDF_COND (\
2211 
	out_basic_int((unsigned long)e_ntest_cond, (unsigned)4),\
2212 
	s_ntest, p0, p1, p2)
2213 
 
2214 
#define o_equal\
2215 
    {\
2216 
	out_basic_int((unsigned long)e_equal, (unsigned)4);\
2217 
	SET_RSORT(s_ntest);\
2218 
    }
2219 
 
2220 
#define o_greater_than\
2221 
    {\
2222 
	out_basic_int((unsigned long)e_greater_than, (unsigned)4);\
2223 
	SET_RSORT(s_ntest);\
2224 
    }
2225 
 
2226 
#define o_greater_than_or_equal\
2227 
    {\
2228 
	out_basic_int((unsigned long)e_greater_than_or_equal, (unsigned)4);\
2229 
	SET_RSORT(s_ntest);\
2230 
    }
2231 
 
2232 
#define o_less_than\
2233 
    {\
2234 
	out_basic_int((unsigned long)e_less_than, (unsigned)4);\
2235 
	SET_RSORT(s_ntest);\
2236 
    }
2237 
 
2238 
#define o_less_than_or_equal\
2239 
    {\
2240 
	out_basic_int((unsigned long)e_less_than_or_equal, (unsigned)4);\
2241 
	SET_RSORT(s_ntest);\
2242 
    }
2243 
 
2244 
#define o_not_equal\
2245 
    {\
2246 
	out_basic_int((unsigned long)e_not_equal, (unsigned)4);\
2247 
	SET_RSORT(s_ntest);\
2248 
    }
2249 
 
2250 
#define o_not_greater_than\
2251 
    {\
2252 
	out_basic_int((unsigned long)e_not_greater_than, (unsigned)4);\
2253 
	SET_RSORT(s_ntest);\
2254 
    }
2255 
 
2256 
#define o_not_greater_than_or_equal\
2257 
    {\
2258 
	out_basic_int((unsigned long)e_not_greater_than_or_equal, (unsigned)4);\
2259 
	SET_RSORT(s_ntest);\
2260 
    }
2261 
 
2262 
#define o_not_less_than\
2263 
    {\
2264 
	out_basic_int((unsigned long)e_not_less_than, (unsigned)4);\
2265 
	SET_RSORT(s_ntest);\
2266 
    }
2267 
 
2268 
#define o_not_less_than_or_equal\
2269 
    {\
2270 
	out_basic_int((unsigned long)e_not_less_than_or_equal, (unsigned)4);\
2271 
	SET_RSORT(s_ntest);\
2272 
    }
2273 
 
2274 
#define o_less_than_or_greater_than\
2275 
    {\
2276 
	out_basic_int((unsigned long)e_less_than_or_greater_than, (unsigned)4);\
2277 
	SET_RSORT(s_ntest);\
2278 
    }
2279 
 
2280 
#define o_not_less_than_and_not_greater_than\
2281 
    {\
2282 
	out_basic_int((unsigned long)e_not_less_than_and_not_greater_than, (unsigned)4);\
2283 
	SET_RSORT(s_ntest);\
2284 
    }
2285 
 
2286 
#define o_comparable\
2287 
    {\
2288 
	out_basic_int((unsigned long)e_comparable, (unsigned)4);\
2289 
	SET_RSORT(s_ntest);\
2290 
    }
2291 
 
2292 
#define o_not_comparable\
2293 
    {\
2294 
	out_extendable_int((unsigned long)e_not_comparable, (unsigned)4);\
2295 
	SET_RSORT(s_ntest);\
2296 
    }
2297 
 
2298 
 
2299 
/* CONSTRUCTS FOR OTAGEXP */
2300 
 
2301 
#define o_make_otagexp( p0, p1 )\
2302 
    {\
2303 
	o_tag_option(p0);\
2304 
	p1;\
2305 
	ASSERT_SORT(s_exp);\
2306 
	SET_RSORT(s_otagexp);\
2307 
    }
2308 
 
2309 
 
2310 
/* CONSTRUCTS FOR PROCPROPS */
2311 
 
2312 
#define o_procprops_apply_token( p0, p1 )\
2313 
    TOK_APP (\
2314 
	out_basic_int((unsigned long)e_procprops_apply_token, (unsigned)4),\
2315 
	s_procprops, p0, p1)
2316 
 
2317 
#define o_procprops_cond( p0, p1, p2 )\
2318 
    TDF_COND (\
2319 
	out_basic_int((unsigned long)e_procprops_cond, (unsigned)4),\
2320 
	s_procprops, p0, p1, p2)
2321 
 
2322 
#define o_add_procprops( p0, p1 )\
2323 
    {\
2324 
	out_basic_int((unsigned long)e_add_procprops, (unsigned)4);\
2325 
	p0;\
2326 
	ASSERT_SORT(s_procprops);\
2327 
	p1;\
2328 
	ASSERT_SORT(s_procprops);\
2329 
	SET_RSORT(s_procprops);\
2330 
    }
2331 
 
2332 
#define o_check_stack\
2333 
    {\
2334 
	out_basic_int((unsigned long)e_check_stack, (unsigned)4);\
2335 
	SET_RSORT(s_procprops);\
2336 
    }
2337 
 
2338 
#define o_inline\
2339 
    {\
2340 
	out_basic_int((unsigned long)e_inline, (unsigned)4);\
2341 
	SET_RSORT(s_procprops);\
2342 
    }
2343 
 
2344 
#define o_no_long_jump_dest\
2345 
    {\
2346 
	out_basic_int((unsigned long)e_no_long_jump_dest, (unsigned)4);\
2347 
	SET_RSORT(s_procprops);\
2348 
    }
2349 
 
2350 
#define o_untidy\
2351 
    {\
2352 
	out_basic_int((unsigned long)e_untidy, (unsigned)4);\
2353 
	SET_RSORT(s_procprops);\
2354 
    }
2355 
 
2356 
#define o_var_callees\
2357 
    {\
2358 
	out_basic_int((unsigned long)e_var_callees, (unsigned)4);\
2359 
	SET_RSORT(s_procprops);\
2360 
    }
2361 
 
2362 
#define o_var_callers\
2363 
    {\
2364 
	out_basic_int((unsigned long)e_var_callers, (unsigned)4);\
2365 
	SET_RSORT(s_procprops);\
2366 
    }
2367 
 
2368 
 
2369 
/* CONSTRUCTS FOR ROUNDING_MODE */
2370 
 
2371 
#define o_rounding_mode_apply_token( p0, p1 )\
2372 
    TOK_APP (\
2373 
	out_basic_int((unsigned long)e_rounding_mode_apply_token, (unsigned)3),\
2374 
	s_rounding_mode, p0, p1)
2375 
 
2376 
#define o_rounding_mode_cond( p0, p1, p2 )\
2377 
    TDF_COND (\
2378 
	out_basic_int((unsigned long)e_rounding_mode_cond, (unsigned)3),\
2379 
	s_rounding_mode, p0, p1, p2)
2380 
 
2381 
#define o_round_as_state\
2382 
    {\
2383 
	out_basic_int((unsigned long)e_round_as_state, (unsigned)3);\
2384 
	SET_RSORT(s_rounding_mode);\
2385 
    }
2386 
 
2387 
#define o_to_nearest\
2388 
    {\
2389 
	out_basic_int((unsigned long)e_to_nearest, (unsigned)3);\
2390 
	SET_RSORT(s_rounding_mode);\
2391 
    }
2392 
 
2393 
#define o_toward_larger\
2394 
    {\
2395 
	out_basic_int((unsigned long)e_toward_larger, (unsigned)3);\
2396 
	SET_RSORT(s_rounding_mode);\
2397 
    }
2398 
 
2399 
#define o_toward_smaller\
2400 
    {\
2401 
	out_basic_int((unsigned long)e_toward_smaller, (unsigned)3);\
2402 
	SET_RSORT(s_rounding_mode);\
2403 
    }
2404 
 
2405 
#define o_toward_zero\
2406 
    {\
2407 
	out_basic_int((unsigned long)e_toward_zero, (unsigned)3);\
2408 
	SET_RSORT(s_rounding_mode);\
2409 
    }
2410 
 
2411 
 
2412 
/* CONSTRUCTS FOR SHAPE */
2413 
 
2414 
#define o_shape_apply_token( p0, p1 )\
2415 
    TOK_APP (\
2416 
	out_basic_int((unsigned long)e_shape_apply_token, (unsigned)4),\
2417 
	s_shape, p0, p1)
2418 
 
2419 
#define o_shape_cond( p0, p1, p2 )\
2420 
    TDF_COND (\
2421 
	out_basic_int((unsigned long)e_shape_cond, (unsigned)4),\
2422 
	s_shape, p0, p1, p2)
2423 
 
2424 
#define o_bitfield( p0 )\
2425 
    {\
2426 
	out_basic_int((unsigned long)e_bitfield, (unsigned)4);\
2427 
	p0;\
2428 
	ASSERT_SORT(s_bitfield_variety);\
2429 
	SET_RSORT(s_shape);\
2430 
    }
2431 
 
2432 
#define o_bottom\
2433 
    {\
2434 
	out_basic_int((unsigned long)e_bottom, (unsigned)4);\
2435 
	SET_RSORT(s_shape);\
2436 
    }
2437 
 
2438 
#define o_compound( p0 )\
2439 
    {\
2440 
	out_basic_int((unsigned long)e_compound, (unsigned)4);\
2441 
	p0;\
2442 
	ASSERT_SORT(s_exp);\
2443 
	SET_RSORT(s_shape);\
2444 
    }
2445 
 
2446 
#define o_floating( p0 )\
2447 
    {\
2448 
	out_basic_int((unsigned long)e_floating, (unsigned)4);\
2449 
	p0;\
2450 
	ASSERT_SORT(s_floating_variety);\
2451 
	SET_RSORT(s_shape);\
2452 
    }
2453 
 
2454 
#define o_integer( p0 )\
2455 
    {\
2456 
	out_basic_int((unsigned long)e_integer, (unsigned)4);\
2457 
	p0;\
2458 
	ASSERT_SORT(s_variety);\
2459 
	SET_RSORT(s_shape);\
2460 
    }
2461 
 
2462 
#define o_nof( p0, p1 )\
2463 
    {\
2464 
	out_basic_int((unsigned long)e_nof, (unsigned)4);\
2465 
	p0;\
2466 
	ASSERT_SORT(s_nat);\
2467 
	p1;\
2468 
	ASSERT_SORT(s_shape);\
2469 
	SET_RSORT(s_shape);\
2470 
    }
2471 
 
2472 
#define o_offset( p0, p1 )\
2473 
    {\
2474 
	out_basic_int((unsigned long)e_offset, (unsigned)4);\
2475 
	p0;\
2476 
	ASSERT_SORT(s_alignment);\
2477 
	p1;\
2478 
	ASSERT_SORT(s_alignment);\
2479 
	SET_RSORT(s_shape);\
2480 
    }
2481 
 
2482 
#define o_pointer( p0 )\
2483 
    {\
2484 
	out_basic_int((unsigned long)e_pointer, (unsigned)4);\
2485 
	p0;\
2486 
	ASSERT_SORT(s_alignment);\
2487 
	SET_RSORT(s_shape);\
2488 
    }
2489 
 
2490 
#define o_proc\
2491 
    {\
2492 
	out_basic_int((unsigned long)e_proc, (unsigned)4);\
2493 
	SET_RSORT(s_shape);\
2494 
    }
2495 
 
2496 
#define o_top\
2497 
    {\
2498 
	out_basic_int((unsigned long)e_top, (unsigned)4);\
2499 
	SET_RSORT(s_shape);\
2500 
    }
2501 
 
2502 
 
2503 
/* CONSTRUCTS FOR SIGNED_NAT */
2504 
 
2505 
#define o_signed_nat_apply_token( p0, p1 )\
2506 
    TOK_APP (\
2507 
	out_basic_int((unsigned long)e_signed_nat_apply_token, (unsigned)3),\
2508 
	s_signed_nat, p0, p1)
2509 
 
2510 
#define o_signed_nat_cond( p0, p1, p2 )\
2511 
    TDF_COND (\
2512 
	out_basic_int((unsigned long)e_signed_nat_cond, (unsigned)3),\
2513 
	s_signed_nat, p0, p1, p2)
2514 
 
2515 
#define o_computed_signed_nat( p0 )\
2516 
    {\
2517 
	out_basic_int((unsigned long)e_computed_signed_nat, (unsigned)3);\
2518 
	p0;\
2519 
	ASSERT_SORT(s_exp);\
2520 
	SET_RSORT(s_signed_nat);\
2521 
    }
2522 
 
2523 
#define o_make_signed_nat( p0, p1 )\
2524 
    {\
2525 
	out_basic_int((unsigned long)e_make_signed_nat, (unsigned)3);\
2526 
	p0;\
2527 
	ASSERT_SORT(s_tdfbool);\
2528 
	p1;\
2529 
	ASSERT_SORT(s_tdfint);\
2530 
	SET_RSORT(s_signed_nat);\
2531 
    }
2532 
 
2533 
#define o_snat_from_nat( p0, p1 )\
2534 
    {\
2535 
	out_basic_int((unsigned long)e_snat_from_nat, (unsigned)3);\
2536 
	p0;\
2537 
	ASSERT_SORT(s_bool);\
2538 
	p1;\
2539 
	ASSERT_SORT(s_nat);\
2540 
	SET_RSORT(s_signed_nat);\
2541 
    }
2542 
 
2543 
 
2544 
/* CONSTRUCTS FOR SORTNAME */
2545 
 
2546 
#define o_access\
2547 
    {\
2548 
	out_basic_int((unsigned long)e_access, (unsigned)5);\
2549 
	SET_RSORT(s_sortname);\
2550 
    }
2551 
 
2552 
#define o_al_tag\
2553 
    {\
2554 
	out_basic_int((unsigned long)e_al_tag, (unsigned)5);\
2555 
	SET_RSORT(s_sortname);\
2556 
    }
2557 
 
2558 
#define o_alignment_sort\
2559 
    {\
2560 
	out_basic_int((unsigned long)e_alignment_sort, (unsigned)5);\
2561 
	SET_RSORT(s_sortname);\
2562 
    }
2563 
 
2564 
#define o_bitfield_variety\
2565 
    {\
2566 
	out_basic_int((unsigned long)e_bitfield_variety, (unsigned)5);\
2567 
	SET_RSORT(s_sortname);\
2568 
    }
2569 
 
2570 
#define o_bool\
2571 
    {\
2572 
	out_basic_int((unsigned long)e_bool, (unsigned)5);\
2573 
	SET_RSORT(s_sortname);\
2574 
    }
2575 
 
2576 
#define o_error_treatment\
2577 
    {\
2578 
	out_basic_int((unsigned long)e_error_treatment, (unsigned)5);\
2579 
	SET_RSORT(s_sortname);\
2580 
    }
2581 
 
2582 
#define o_exp\
2583 
    {\
2584 
	out_basic_int((unsigned long)e_exp, (unsigned)5);\
2585 
	SET_RSORT(s_sortname);\
2586 
    }
2587 
 
2588 
#define o_floating_variety\
2589 
    {\
2590 
	out_basic_int((unsigned long)e_floating_variety, (unsigned)5);\
2591 
	SET_RSORT(s_sortname);\
2592 
    }
2593 
 
2594 
#define o_foreign_sort( p0 )\
2595 
    {\
2596 
	out_basic_int((unsigned long)e_foreign_sort, (unsigned)5);\
2597 
	p0;\
2598 
	ASSERT_SORT(s_string);\
2599 
	SET_RSORT(s_sortname);\
2600 
    }
2601 
 
2602 
#define o_label\
2603 
    {\
2604 
	out_basic_int((unsigned long)e_label, (unsigned)5);\
2605 
	SET_RSORT(s_sortname);\
2606 
    }
2607 
 
2608 
#define o_nat\
2609 
    {\
2610 
	out_basic_int((unsigned long)e_nat, (unsigned)5);\
2611 
	SET_RSORT(s_sortname);\
2612 
    }
2613 
 
2614 
#define o_ntest\
2615 
    {\
2616 
	out_basic_int((unsigned long)e_ntest, (unsigned)5);\
2617 
	SET_RSORT(s_sortname);\
2618 
    }
2619 
 
2620 
#define o_procprops\
2621 
    {\
2622 
	out_basic_int((unsigned long)e_procprops, (unsigned)5);\
2623 
	SET_RSORT(s_sortname);\
2624 
    }
2625 
 
2626 
#define o_rounding_mode\
2627 
    {\
2628 
	out_basic_int((unsigned long)e_rounding_mode, (unsigned)5);\
2629 
	SET_RSORT(s_sortname);\
2630 
    }
2631 
 
2632 
#define o_shape\
2633 
    {\
2634 
	out_basic_int((unsigned long)e_shape, (unsigned)5);\
2635 
	SET_RSORT(s_sortname);\
2636 
    }
2637 
 
2638 
#define o_signed_nat\
2639 
    {\
2640 
	out_basic_int((unsigned long)e_signed_nat, (unsigned)5);\
2641 
	SET_RSORT(s_sortname);\
2642 
    }
2643 
 
2644 
#define o_string\
2645 
    {\
2646 
	out_basic_int((unsigned long)e_string, (unsigned)5);\
2647 
	SET_RSORT(s_sortname);\
2648 
    }
2649 
 
2650 
#define o_tag\
2651 
    {\
2652 
	out_basic_int((unsigned long)e_tag, (unsigned)5);\
2653 
	SET_RSORT(s_sortname);\
2654 
    }
2655 
 
2656 
#define o_transfer_mode\
2657 
    {\
2658 
	out_basic_int((unsigned long)e_transfer_mode, (unsigned)5);\
2659 
	SET_RSORT(s_sortname);\
2660 
    }
2661 
 
2662 
#define o_token( p0, p1 )\
2663 
    {\
2664 
	out_basic_int((unsigned long)e_token, (unsigned)5);\
2665 
	p0;\
2666 
	ASSERT_SORT(s_sortname);\
2667 
	o_sortname_list(p1);\
2668 
	SET_RSORT(s_sortname);\
2669 
    }
2670 
 
2671 
#define o_variety\
2672 
    {\
2673 
	out_basic_int((unsigned long)e_variety, (unsigned)5);\
2674 
	SET_RSORT(s_sortname);\
2675 
    }
2676 
 
2677 
 
2678 
/* CONSTRUCTS FOR SOURCEMARK */
2679 
 
2680 
#define o_make_sourcemark( p0, p1, p2 )\
2681 
    {\
2682 
	out_basic_int((unsigned long)e_make_sourcemark, (unsigned)1);\
2683 
	p0;\
2684 
	ASSERT_SORT(s_filename);\
2685 
	p1;\
2686 
	ASSERT_SORT(s_nat);\
2687 
	p2;\
2688 
	ASSERT_SORT(s_nat);\
2689 
	SET_RSORT(s_sourcemark);\
2690 
    }
2691 
 
2692 
 
2693 
/* CONSTRUCTS FOR STRING */
2694 
 
2695 
#define o_string_apply_token( p0, p1 )\
2696 
    TOK_APP (\
2697 
	out_basic_int((unsigned long)e_string_apply_token, (unsigned)3),\
2698 
	s_string, p0, p1)
2699 
 
2700 
#define o_string_cond( p0, p1, p2 )\
2701 
    TDF_COND (\
2702 
	out_basic_int((unsigned long)e_string_cond, (unsigned)3),\
2703 
	s_string, p0, p1, p2)
2704 
 
2705 
#define o_concat_string( p0, p1 )\
2706 
    {\
2707 
	out_basic_int((unsigned long)e_concat_string, (unsigned)3);\
2708 
	p0;\
2709 
	ASSERT_SORT(s_string);\
2710 
	p1;\
2711 
	ASSERT_SORT(s_string);\
2712 
	SET_RSORT(s_string);\
2713 
    }
2714 
 
2715 
#define o_make_string( p0 )\
2716 
    {\
2717 
	out_basic_int((unsigned long)e_make_string, (unsigned)3);\
2718 
	p0;\
2719 
	ASSERT_SORT(s_tdfstring);\
2720 
	SET_RSORT(s_string);\
2721 
    }
2722 
 
2723 
 
2724 
/* CONSTRUCTS FOR TAG */
2725 
 
2726 
#define o_tag_apply_token( p0, p1 )\
2727 
    TOK_APP (\
2728 
	out_extendable_int((unsigned long)e_tag_apply_token, (unsigned)1),\
2729 
	s_tag, p0, p1)
2730 
 
2731 
#define o_make_tag( p0 )\
2732 
    {\
2733 
	out_basic_int((unsigned long)e_make_tag, (unsigned)1);\
2734 
	p0;\
2735 
	ASSERT_SORT(s_tdfint);\
2736 
	SET_RSORT(s_tag);\
2737 
    }
2738 
 
2739 
 
2740 
/* CONSTRUCTS FOR TAGACC */
2741 
 
2742 
#define o_make_tagacc( p0, p1 )\
2743 
    {\
2744 
	p0;\
2745 
	ASSERT_SORT(s_tag);\
2746 
	o_access_option(p1);\
2747 
	SET_RSORT(s_tagacc);\
2748 
    }
2749 
 
2750 
 
2751 
/* CONSTRUCTS FOR TAGDEC */
2752 
 
2753 
#define o_make_id_tagdec( p0, p1, p2, p3 )\
2754 
    {\
2755 
	out_basic_int((unsigned long)e_make_id_tagdec, (unsigned)2);\
2756 
	p0;\
2757 
	ASSERT_SORT(s_tdfint);\
2758 
	o_access_option(p1);\
2759 
	o_string_option(p2);\
2760 
	p3;\
2761 
	ASSERT_SORT(s_shape);\
2762 
	SET_RSORT(s_tagdec);\
2763 
    }
2764 
 
2765 
#define o_make_var_tagdec( p0, p1, p2, p3 )\
2766 
    {\
2767 
	out_basic_int((unsigned long)e_make_var_tagdec, (unsigned)2);\
2768 
	p0;\
2769 
	ASSERT_SORT(s_tdfint);\
2770 
	o_access_option(p1);\
2771 
	o_string_option(p2);\
2772 
	p3;\
2773 
	ASSERT_SORT(s_shape);\
2774 
	SET_RSORT(s_tagdec);\
2775 
    }
2776 
 
2777 
#define o_common_tagdec( p0, p1, p2, p3 )\
2778 
    {\
2779 
	out_basic_int((unsigned long)e_common_tagdec, (unsigned)2);\
2780 
	p0;\
2781 
	ASSERT_SORT(s_tdfint);\
2782 
	o_access_option(p1);\
2783 
	o_string_option(p2);\
2784 
	p3;\
2785 
	ASSERT_SORT(s_shape);\
2786 
	SET_RSORT(s_tagdec);\
2787 
    }
2788 
 
2789 
 
2790 
/* CONSTRUCTS FOR TAGDEC_PROPS */
2791 
 
2792 
#define o_make_tagdecs( p0, p1 )\
2793 
    {\
2794 
	p0;\
2795 
	ASSERT_SORT(s_tdfint);\
2796 
	o_tagdec_list(p1);\
2797 
	SET_RSORT(s_tagdec_props);\
2798 
    }
2799 
 
2800 
 
2801 
/* CONSTRUCTS FOR TAGDEF */
2802 
 
2803 
#define o_make_id_tagdef( p0, p1, p2 )\
2804 
    {\
2805 
	out_basic_int((unsigned long)e_make_id_tagdef, (unsigned)2);\
2806 
	p0;\
2807 
	ASSERT_SORT(s_tdfint);\
2808 
	o_string_option(p1);\
2809 
	p2;\
2810 
	ASSERT_SORT(s_exp);\
2811 
	SET_RSORT(s_tagdef);\
2812 
    }
2813 
 
2814 
#define o_make_var_tagdef( p0, p1, p2, p3 )\
2815 
    {\
2816 
	out_basic_int((unsigned long)e_make_var_tagdef, (unsigned)2);\
2817 
	p0;\
2818 
	ASSERT_SORT(s_tdfint);\
2819 
	o_access_option(p1);\
2820 
	o_string_option(p2);\
2821 
	p3;\
2822 
	ASSERT_SORT(s_exp);\
2823 
	SET_RSORT(s_tagdef);\
2824 
    }
2825 
 
2826 
#define o_common_tagdef( p0, p1, p2, p3 )\
2827 
    {\
2828 
	out_basic_int((unsigned long)e_common_tagdef, (unsigned)2);\
2829 
	p0;\
2830 
	ASSERT_SORT(s_tdfint);\
2831 
	o_access_option(p1);\
2832 
	o_string_option(p2);\
2833 
	p3;\
2834 
	ASSERT_SORT(s_exp);\
2835 
	SET_RSORT(s_tagdef);\
2836 
    }
2837 
 
2838 
 
2839 
/* CONSTRUCTS FOR TAGDEF_PROPS */
2840 
 
2841 
#define o_make_tagdefs( p0, p1 )\
2842 
    {\
2843 
	p0;\
2844 
	ASSERT_SORT(s_tdfint);\
2845 
	o_tagdef_list(p1);\
2846 
	SET_RSORT(s_tagdef_props);\
2847 
    }
2848 
 
2849 
 
2850 
/* CONSTRUCTS FOR TAGSHACC */
2851 
 
2852 
#define o_make_tagshacc( p0, p1, p2 )\
2853 
    {\
2854 
	p0;\
2855 
	ASSERT_SORT(s_shape);\
2856 
	o_access_option(p1);\
2857 
	p2;\
2858 
	ASSERT_SORT(s_tag);\
2859 
	SET_RSORT(s_tagshacc);\
2860 
    }
2861 
 
2862 
 
2863 
/* CONSTRUCTS FOR TOKDEC */
2864 
 
2865 
#define o_make_tokdec( p0, p1, p2 )\
2866 
    {\
2867 
	out_basic_int((unsigned long)e_make_tokdec, (unsigned)1);\
2868 
	p0;\
2869 
	ASSERT_SORT(s_tdfint);\
2870 
	o_string_option(p1);\
2871 
	p2;\
2872 
	ASSERT_SORT(s_sortname);\
2873 
	SET_RSORT(s_tokdec);\
2874 
    }
2875 
 
2876 
 
2877 
/* CONSTRUCTS FOR TOKDEC_PROPS */
2878 
 
2879 
#define o_make_tokdecs( p0 )\
2880 
    {\
2881 
	o_tokdec_list(p0);\
2882 
	SET_RSORT(s_tokdec_props);\
2883 
    }
2884 
 
2885 
 
2886 
/* CONSTRUCTS FOR TOKDEF */
2887 
 
2888 
#define o_make_tokdef( p0, p1, p2 )\
2889 
    {\
2890 
	out_basic_int((unsigned long)e_make_tokdef, (unsigned)1);\
2891 
	p0;\
2892 
	ASSERT_SORT(s_tdfint);\
2893 
	o_string_option(p1);\
2894 
	p2;\
2895 
	ASSERT_SORT(s_bitstream);\
2896 
	SET_RSORT(s_tokdef);\
2897 
    }
2898 
 
2899 
 
2900 
/* CONSTRUCTS FOR TOKDEF_PROPS */
2901 
 
2902 
#define o_make_tokdefs( p0, p1 )\
2903 
    {\
2904 
	p0;\
2905 
	ASSERT_SORT(s_tdfint);\
2906 
	o_tokdef_list(p1);\
2907 
	SET_RSORT(s_tokdef_props);\
2908 
    }
2909 
 
2910 
 
2911 
/* CONSTRUCTS FOR TOKEN */
2912 
 
2913 
#define o_token_apply_token( p0, p1 )\
2914 
    TOK_APP (\
2915 
	out_basic_int((unsigned long)e_token_apply_token, (unsigned)2),\
2916 
	s_token, p0, p1)
2917 
 
2918 
#define o_make_tok( p0 )\
2919 
    {\
2920 
	out_basic_int((unsigned long)e_make_tok, (unsigned)2);\
2921 
	p0;\
2922 
	ASSERT_SORT(s_tdfint);\
2923 
	SET_RSORT(s_token);\
2924 
    }
2925 
 
2926 
#define o_use_tokdef( p0 )\
2927 
    {\
2928 
	out_basic_int((unsigned long)e_use_tokdef, (unsigned)2);\
2929 
	p0;\
2930 
	ASSERT_SORT(s_bitstream);\
2931 
	SET_RSORT(s_token);\
2932 
    }
2933 
 
2934 
 
2935 
/* CONSTRUCTS FOR TOKEN_DEFN */
2936 
 
2937 
#define o_token_definition( p0, p1 )\
2938 
    {\
2939 
	out_basic_int((unsigned long)e_token_definition, (unsigned)1);\
2940 
	p0;\
2941 
	ASSERT_SORT(s_sortname);\
2942 
	o_tokformals_list(p1);\
2943 
	SET_RSORT(s_token_defn);\
2944 
    }
2945 
 
2946 
 
2947 
/* CONSTRUCTS FOR TOKFORMALS */
2948 
 
2949 
#define o_make_tokformals( p0, p1 )\
2950 
    {\
2951 
	p0;\
2952 
	ASSERT_SORT(s_sortname);\
2953 
	p1;\
2954 
	ASSERT_SORT(s_tdfint);\
2955 
	SET_RSORT(s_tokformals);\
2956 
    }
2957 
 
2958 
 
2959 
/* CONSTRUCTS FOR TRANSFER_MODE */
2960 
 
2961 
#define o_transfer_mode_apply_token( p0, p1 )\
2962 
    TOK_APP (\
2963 
	out_basic_int((unsigned long)e_transfer_mode_apply_token, (unsigned)3),\
2964 
	s_transfer_mode, p0, p1)
2965 
 
2966 
#define o_transfer_mode_cond( p0, p1, p2 )\
2967 
    TDF_COND (\
2968 
	out_basic_int((unsigned long)e_transfer_mode_cond, (unsigned)3),\
2969 
	s_transfer_mode, p0, p1, p2)
2970 
 
2971 
#define o_add_modes( p0, p1 )\
2972 
    {\
2973 
	out_basic_int((unsigned long)e_add_modes, (unsigned)3);\
2974 
	p0;\
2975 
	ASSERT_SORT(s_transfer_mode);\
2976 
	p1;\
2977 
	ASSERT_SORT(s_transfer_mode);\
2978 
	SET_RSORT(s_transfer_mode);\
2979 
    }
2980 
 
2981 
#define o_overlap\
2982 
    {\
2983 
	out_basic_int((unsigned long)e_overlap, (unsigned)3);\
2984 
	SET_RSORT(s_transfer_mode);\
2985 
    }
2986 
 
2987 
#define o_standard_transfer_mode\
2988 
    {\
2989 
	out_basic_int((unsigned long)e_standard_transfer_mode, (unsigned)3);\
2990 
	SET_RSORT(s_transfer_mode);\
2991 
    }
2992 
 
2993 
#define o_trap_on_nil\
2994 
    {\
2995 
	out_basic_int((unsigned long)e_trap_on_nil, (unsigned)3);\
2996 
	SET_RSORT(s_transfer_mode);\
2997 
    }
2998 
 
2999 
#define o_volatile\
3000 
    {\
3001 
	out_basic_int((unsigned long)e_volatile, (unsigned)3);\
3002 
	SET_RSORT(s_transfer_mode);\
3003 
    }
3004 
 
3005 
#define o_complete\
3006 
    {\
3007 
	out_extendable_int((unsigned long)e_complete, (unsigned)3);\
3008 
	SET_RSORT(s_transfer_mode);\
3009 
    }
3010 
 
3011 
 
3012 
/* CONSTRUCTS FOR UNIQUE */
3013 
 
3014 
#define o_make_unique( p0 )\
3015 
    {\
3016 
	o_tdfident_list(p0);\
3017 
	SET_RSORT(s_unique);\
3018 
    }
3019 
 
3020 
 
3021 
/* CONSTRUCTS FOR UNIT */
3022 
 
3023 
#define o_make_unit( p0, p1, p2 )\
3024 
    {\
3025 
	o_tdfint_list(p0);\
3026 
	o_links_list(p1);\
3027 
	p2;\
3028 
	ASSERT_SORT(s_bytestream);\
3029 
	SET_RSORT(s_unit);\
3030 
    }
3031 
 
3032 
 
3033 
/* CONSTRUCTS FOR VARIETY */
3034 
 
3035 
#define o_var_apply_token( p0, p1 )\
3036 
    TOK_APP (\
3037 
	out_basic_int((unsigned long)e_var_apply_token, (unsigned)2),\
3038 
	s_variety, p0, p1)
3039 
 
3040 
#define o_var_cond( p0, p1, p2 )\
3041 
    TDF_COND (\
3042 
	out_basic_int((unsigned long)e_var_cond, (unsigned)2),\
3043 
	s_variety, p0, p1, p2)
3044 
 
3045 
#define o_var_limits( p0, p1 )\
3046 
    {\
3047 
	out_basic_int((unsigned long)e_var_limits, (unsigned)2);\
3048 
	p0;\
3049 
	ASSERT_SORT(s_signed_nat);\
3050 
	p1;\
3051 
	ASSERT_SORT(s_signed_nat);\
3052 
	SET_RSORT(s_variety);\
3053 
    }
3054 
 
3055 
#define o_var_width( p0, p1 )\
3056 
    {\
3057 
	out_extendable_int((unsigned long)e_var_width, (unsigned)2);\
3058 
	p0;\
3059 
	ASSERT_SORT(s_bool);\
3060 
	p1;\
3061 
	ASSERT_SORT(s_nat);\
3062 
	SET_RSORT(s_variety);\
3063 
    }
3064 
 
3065 
 
3066 
/* CONSTRUCTS FOR VERSION */
3067 
 
3068 
#define o_make_version( p0, p1 )\
3069 
    {\
3070 
	out_basic_int((unsigned long)e_make_version, (unsigned)1);\
3071 
	p0;\
3072 
	ASSERT_SORT(s_tdfint);\
3073 
	p1;\
3074 
	ASSERT_SORT(s_tdfint);\
3075 
	SET_RSORT(s_version);\
3076 
    }
3077 
 
3078 
#define o_user_info( p0 )\
3079 
    {\
3080 
	out_extendable_int((unsigned long)e_user_info, (unsigned)1);\
3081 
	p0;\
3082 
	ASSERT_SORT(s_string);\
3083 
	SET_RSORT(s_version);\
3084 
    }
3085 
 
3086 
 
3087 
/* CONSTRUCTS FOR VERSION_PROPS */
3088 
 
3089 
#define o_make_versions( p0 )\
3090 
    {\
3091 
	o_version_list(p0);\
3092 
	SET_RSORT(s_version_props);\
3093 
    }
3094 
 
3095 
 
3096 
/* CONSTRUCTS FOR COMPOUND SORTS */
3097 
 
3098 
#define o_access_option(p)		TDF_OPTION(p, s_access)
3099 
#define o_al_tagdef_list(p)		TDF_SLIST(p, s_al_tagdef)
3100 
#define o_capsule_link_list(p)		TDF_SLIST(p, s_capsule_link)
3101 
#define o_caselim_list(p)		TDF_LIST(p, s_caselim)
3102 
#define o_diag_descriptor_list(p)	TDF_SLIST(p, s_diag_descriptor)
3103 
#define o_diag_field_list(p)		TDF_LIST(p, s_diag_field)
3104 
#define o_diag_tagdef_list(p)		TDF_SLIST(p, s_diag_tagdef)
3105 
#define o_diag_type_list(p)		TDF_LIST(p, s_diag_type)
3106 
#define o_enum_values_list(p)		TDF_LIST(p, s_enum_values)
3107 
#define o_error_code_list(p)		TDF_LIST(p, s_error_code)
3108 
#define o_exp_list(p)			TDF_LIST(p, s_exp)
3109 
#define o_exp_option(p)			TDF_OPTION(p, s_exp)
3110 
#define o_extern_link_list(p)		TDF_SLIST(p, s_extern_link)
3111 
#define o_group_list(p)			TDF_SLIST(p, s_group)
3112 
#define o_label_list(p)			TDF_LIST(p, s_label)
3113 
#define o_link_list(p)			TDF_SLIST(p, s_link)
3114 
#define o_linkextern_list(p)		TDF_SLIST(p, s_linkextern)
3115 
#define o_linkinfo_list(p)		TDF_SLIST(p, s_linkinfo)
3116 
#define o_links_list(p)			TDF_SLIST(p, s_links)
3117 
#define o_nat_option(p)			TDF_OPTION(p, s_nat)
3118 
#define o_otagexp_list(p)		TDF_LIST(p, s_otagexp)
3119 
#define o_procprops_option(p)		TDF_OPTION(p, s_procprops)
3120 
#define o_sortname_list(p)		TDF_LIST(p, s_sortname)
3121 
#define o_string_option(p)		TDF_OPTION(p, s_string)
3122 
#define o_tag_option(p)			TDF_OPTION(p, s_tag)
3123 
#define o_tagacc_option(p)		TDF_OPTION(p, s_tagacc)
3124 
#define o_tagdec_list(p)		TDF_SLIST(p, s_tagdec)
3125 
#define o_tagdef_list(p)		TDF_SLIST(p, s_tagdef)
3126 
#define o_tagshacc_list(p)		TDF_LIST(p, s_tagshacc)
3127 
#define o_tdfident_list(p)		TDF_SLIST(p, s_tdfident)
3128 
#define o_tdfint_list(p)		TDF_SLIST(p, s_tdfint)
3129 
#define o_tokdec_list(p)		TDF_SLIST(p, s_tokdec)
3130 
#define o_tokdef_list(p)		TDF_SLIST(p, s_tokdef)
3131 
#define o_tokformals_list(p)		TDF_LIST(p, s_tokformals)
3132 
#define o_unit_list(p)			TDF_SLIST(p, s_unit)
3133 
#define o_version_list(p)		TDF_SLIST(p, s_version)
3134 
 
3135 
 
3136 
#endif