Subversion Repositories tendra.SVN

Rev

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

Rev Author Line No. Line
2 7u83 1 
/*
2 
    		 Crown Copyright (c) 1997
3 
 
4 
    This TenDRA(r) Computer Program is subject to Copyright
5 
    owned by the United Kingdom Secretary of State for Defence
6 
    acting through the Defence Evaluation and Research Agency
7 
    (DERA).  It is made available to Recipients with a
8 
    royalty-free licence for its use, reproduction, transfer
9 
    to other parties and amendment for any purpose not excluding
10 
    product development provided that any such use et cetera
11 
    shall be deemed to be acceptance of the following conditions:-
12 
 
13 
        (1) Its Recipients shall ensure that this Notice is
14 
        reproduced upon any copies or amended versions of it;
15 
 
16 
        (2) Any amended version of it shall be clearly marked to
17 
        show both the nature of and the organisation responsible
18 
        for the relevant amendment or amendments;
19 
 
20 
        (3) Its onward transfer from a recipient to another
21 
        party shall be deemed to be that party's acceptance of
22 
        these conditions;
23 
 
24 
        (4) DERA gives no warranty or assurance as to its
25 
        quality or suitability for any purpose and DERA accepts
26 
        no liability whatsoever in relation to any use to which
27 
        it may be put.
28 
*/
29 
 
30 
/*
31 
    AUTOMATICALLY GENERATED FROM ALGEBRA tdf (VERSION 1.0)
32 
    BY calculus (VERSION 1.2)
33 
*/
34 
 
35 
#ifndef TDF_H_INCLUDED
36 
#define TDF_H_INCLUDED
37 
 
38 
#ifndef tdf_NAME
39 
#define tdf_NAME			"tdf"
40 
#define tdf_VERSION			"1.0"
41 
#define tdf_SPECIFICATION		0
42 
#define tdf_IMPLEMENTATION		1
43 
#endif
44 
 
45 
 
46 
/* Prototype macros */
47 
 
48 
#ifndef CONST_S
49 
#define CONST_S
50 
#endif
51 
 
52 
 
53 
/* Primitive types */
54 
 
6 7u83 55 
typedef char * string;
2 7u83 56 
 
57 
 
58 
/* Basic types */
59 
 
60 
typedef union tdf_tag {
6 7u83 61 
    unsigned ag_tag;
62 
    union tdf_tag *ag_ptr;
63 
    unsigned ag_enum;
64 
    unsigned long ag_long_enum;
65 
    int ag_prim_int;
66 
    unsigned ag_prim_unsigned;
67 
    string ag_prim_string;
68 
} tdf;
2 7u83 69 
 
6 7u83 70 
typedef tdf *tdf_PTR;
2 7u83 71 
 
72 
#ifndef tdf_DESTR_DEFINED
73 
#define tdf_DESTR_DEFINED
6 7u83 74 
typedef void (*DESTROYER)(tdf *, unsigned);
2 7u83 75 
#endif
76 
 
6 7u83 77 
#define PTR(A)	tdf_PTR
78 
#define LIST(A)	tdf_PTR
79 
#define STACK(A)	tdf_PTR
80 
#define SIZE(A)	int
2 7u83 81 
 
82 
 
83 
/* Assertion macros */
84 
 
85 
#ifdef ASSERTS
6 7u83 86 
extern tdf *check_null_tdf(tdf *, char *, int);
87 
extern tdf *check_tag_tdf(tdf *, unsigned, char *, int);
88 
extern tdf *check_tag_etc_tdf(tdf *, unsigned, unsigned, char *, int);
89 
#define CHECK_NULL(P)\
90 
    (check_null_tdf((P), __FILE__, __LINE__))
91 
#define CHECK_TAG(P, N)\
92 
    (check_tag_tdf((P), (unsigned)(N), __FILE__, __LINE__))
93 
#define CHECK_TAG_ETC(P, L, U)\
94 
    (check_tag_etc_tdf((P), (unsigned)(L), (unsigned)(U), __FILE__, __LINE__))
2 7u83 95 
#else
6 7u83 96 
#define CHECK_NULL(P)			(P)
97 
#define CHECK_TAG(P, N)			(P)
98 
#define CHECK_TAG_ETC(P, L, U)		(P)
2 7u83 99 
#endif
100 
 
101 
 
102 
/* Enumeration definitions */
103 
 
104 
 
105 
 
106 
/* Union type definitions */
107 
 
6 7u83 108 
typedef tdf *PARAMETER;
109 
typedef tdf *CONSTRUCT;
110 
typedef tdf *SORT_INFO;
111 
typedef tdf *SORT;
112 
typedef tdf *LINKAGE;
113 
typedef tdf *SPECIFICATION;
114 
typedef tdf *COMMAND;
2 7u83 115 
 
116 
 
117 
/* Structure declarations */
118 
 
119 
 
120 
 
121 
/* Identity type definitions */
122 
 
123 
 
124 
 
125 
/* Structure definitions */
126 
 
127 
#ifndef tdf_STRUCT_DEFINED
128 
#define tdf_STRUCT_DEFINED
129 
 
130 
#endif /* tdf_STRUCT_DEFINED */
131 
 
132 
 
133 
/* Function declarations */
134 
 
6 7u83 135 
extern tdf *gen_tdf(unsigned);
136 
extern void destroy_tdf(tdf *, unsigned);
137 
extern void dummy_destroy_tdf (tdf *, unsigned);
138 
extern void destroy_tdf_list (tdf *, unsigned);
139 
extern tdf *append_tdf_list(tdf *, tdf *);
140 
extern tdf *end_tdf_list(tdf *);
141 
extern unsigned length_tdf_list(tdf *);
142 
extern tdf *reverse_tdf_list(tdf *);
2 7u83 143 
#ifdef tdf_IO_ROUTINES
6 7u83 144 
extern unsigned crt_tdf_alias;
145 
extern void set_tdf_alias(tdf *, unsigned);
146 
extern tdf *find_tdf_alias(unsigned);
147 
extern void clear_tdf_alias(void);
2 7u83 148 
#endif
149 
 
150 
 
151 
/* Run-time type information */
152 
 
153 
#ifndef GEN_tdf
6 7u83 154 
#define GEN_tdf(A, B)			gen_tdf((unsigned)(A))
2 7u83 155 
#endif
6 7u83 156 
#define TYPEID_ptr			((unsigned)0)
157 
#define TYPEID_list			((unsigned)1)
158 
#define TYPEID_stack			((unsigned)2)
159 
#define TYPEID_par			((unsigned)3)
160 
#define TYPEID_cons			((unsigned)4)
161 
#define TYPEID_info			((unsigned)5)
162 
#define TYPEID_sort			((unsigned)6)
163 
#define TYPEID_link			((unsigned)7)
164 
#define TYPEID_spec			((unsigned)8)
165 
#define TYPEID_cmd			((unsigned)9)
2 7u83 166 
 
167 
 
168 
/* Definitions for pointers */
169 
 
6 7u83 170 
#define STEP_ptr(A, B)			(CHECK_NULL(A) + B)
171 
#define SIZE_ptr(A)			1
172 
#define NULL_ptr(A)			((tdf *)0)
173 
#define IS_NULL_ptr(A)			((A) == 0)
174 
#define EQ_ptr(A, B)			((A) == (B))
175 
#define MAKE_ptr(A)			GEN_tdf((A), TYPEID_ptr)
176 
#define DESTROY_ptr(A, B)		destroy_tdf((A), (unsigned)(B))
177 
#define UNIQ_ptr(A)			GEN_tdf(1, TYPEID_ptr)
178 
#define DESTROY_UNIQ_ptr(A)		destroy_tdf((A), (unsigned)1)
2 7u83 179 
#ifdef tdf_IO_ROUTINES
6 7u83 180 
#define VOIDSTAR_ptr(A)			((void *)(A))
2 7u83 181 
#endif
182 
 
6 7u83 183 
#define COPY_ptr(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
184 
#define DEREF_ptr(A)			(CHECK_NULL(A)->ag_ptr)
185 
#define CONS_ptr(A, B, C)\
2 7u83 186 
    {\
6 7u83 187 
	tdf *x0_ = GEN_tdf(2, TYPEID_list);\
188 
	x0_[1].ag_ptr = (A);\
189 
	x0_->ag_ptr = (B);\
190 
	(C) = x0_;\
2 7u83 191 
    }
192 
 
6 7u83 193 
#define UN_CONS_ptr(A, B, C)\
2 7u83 194 
    {\
6 7u83 195 
	tdf *x1_ = CHECK_NULL(C);\
196 
	(A) = x1_[1].ag_ptr;\
197 
	(B) = x1_->ag_ptr;\
2 7u83 198 
    }
199 
 
6 7u83 200 
#define DESTROY_CONS_ptr(D, A, B, C)\
2 7u83 201 
    {\
6 7u83 202 
	tdf *x2_ = CHECK_NULL(C);\
203 
	(A) = x2_[1].ag_ptr;\
204 
	(B) = x2_->ag_ptr;\
205 
	(D)(x2_, (unsigned)2);\
2 7u83 206 
    }
207 
 
6 7u83 208 
#define PUSH_ptr(A, B)\
2 7u83 209 
    {\
6 7u83 210 
	tdf **r3_ = &(B);\
211 
	tdf *x3_ = GEN_tdf(2, TYPEID_stack);\
212 
	x3_[1].ag_ptr = (A);\
213 
	x3_->ag_ptr = *r3_;\
214 
	*r3_ = x3_;\
2 7u83 215 
    }
216 
 
6 7u83 217 
#define POP_ptr(A, B)\
2 7u83 218 
    {\
6 7u83 219 
	tdf **r4_ = &(B);\
220 
	tdf *x4_ = CHECK_NULL(*r4_);\
221 
	(A) = x4_[1].ag_ptr;\
222 
	*r4_ = x4_->ag_ptr;\
223 
	destroy_tdf(x4_, (unsigned)2);\
2 7u83 224 
    }
225 
 
226 
 
227 
/* Definitions for lists */
228 
 
6 7u83 229 
#define HEAD_list(A)			(CHECK_NULL(A) + 1)
230 
#define PTR_TAIL_list(A)		(CHECK_NULL(A))
231 
#define TAIL_list(A)			(CHECK_NULL(A)->ag_ptr)
232 
#define LENGTH_list(A)			length_tdf_list((A))
233 
#define END_list(A)			end_tdf_list((A))
234 
#define REVERSE_list(A)			reverse_tdf_list((A))
235 
#define APPEND_list(A, B)		append_tdf_list((A), (B))
2 7u83 236 
 
6 7u83 237 
#define SIZE_list(A)			1
238 
#define NULL_list(A)			((tdf *) 0)
239 
#define IS_NULL_list(A)			((A) == 0)
240 
#define EQ_list(A, B)			((A) == (B))
241 
#define UNIQ_list(A)			GEN_tdf(1, TYPEID_list)
242 
#define DESTROY_UNIQ_list(A)		destroy_tdf((A), (unsigned)1)
2 7u83 243 
#ifdef tdf_IO_ROUTINES
6 7u83 244 
#define VOIDSTAR_list(A)		((void *)(A))
2 7u83 245 
#endif
246 
 
6 7u83 247 
#define DESTROY_list(A, B)\
2 7u83 248 
    {\
6 7u83 249 
	destroy_tdf_list((A), (unsigned)(B));\
2 7u83 250 
    }
251 
 
6 7u83 252 
#define COPY_list(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
253 
#define DEREF_list(A)			(CHECK_NULL(A)->ag_ptr)
254 
#define CONS_list(A, B, C)\
2 7u83 255 
    {\
6 7u83 256 
	tdf *x5_ = GEN_tdf(2, TYPEID_list);\
257 
	x5_[1].ag_ptr = (A);\
258 
	x5_->ag_ptr = (B);\
259 
	(C) = x5_;\
2 7u83 260 
    }
261 
 
6 7u83 262 
#define UN_CONS_list(A, B, C)\
2 7u83 263 
    {\
6 7u83 264 
	tdf *x6_ = CHECK_NULL(C);\
265 
	(A) = x6_[1].ag_ptr;\
266 
	(B) = x6_->ag_ptr;\
2 7u83 267 
    }
268 
 
6 7u83 269 
#define DESTROY_CONS_list(D, A, B, C)\
2 7u83 270 
    {\
6 7u83 271 
	tdf *x7_ = CHECK_NULL(C);\
272 
	(A) = x7_[1].ag_ptr;\
273 
	(B) = x7_->ag_ptr;\
274 
	(D)(x7_, (unsigned)2);\
2 7u83 275 
    }
276 
 
6 7u83 277 
#define PUSH_list(A, B)\
2 7u83 278 
    {\
6 7u83 279 
	tdf **r8_ = &(B);\
280 
	tdf *x8_ = GEN_tdf(2, TYPEID_stack);\
281 
	x8_[1].ag_ptr = (A);\
282 
	x8_->ag_ptr = *r8_;\
283 
	*r8_ = x8_;\
2 7u83 284 
    }
285 
 
6 7u83 286 
#define POP_list(A, B)\
2 7u83 287 
    {\
6 7u83 288 
	tdf **r9_ = &(B);\
289 
	tdf *x9_ = CHECK_NULL(*r9_);\
290 
	(A) = x9_[1].ag_ptr;\
291 
	*r9_ = x9_->ag_ptr;\
292 
	destroy_tdf(x9_, (unsigned)2);\
2 7u83 293 
    }
294 
 
295 
 
296 
/* Definitions for stacks */
297 
 
6 7u83 298 
#define SIZE_stack(A)			1
299 
#define NULL_stack(A)			((tdf *) 0)
300 
#define IS_NULL_stack(A)		((A) == 0)
301 
#define STACK_list(A)			(A)
302 
#define LIST_stack(A)			(A)
2 7u83 303 
 
6 7u83 304 
#define COPY_stack(A, B)		(CHECK_NULL(A)->ag_ptr = (B))
305 
#define DEREF_stack(A)			(CHECK_NULL(A)->ag_ptr)
306 
#define CONS_stack(A, B, C)\
2 7u83 307 
    {\
6 7u83 308 
	tdf *x10_ = GEN_tdf(2, TYPEID_list);\
309 
	x10_[1].ag_ptr = (A);\
310 
	x10_->ag_ptr = (B);\
311 
	(C) = x10_;\
2 7u83 312 
    }
313 
 
6 7u83 314 
#define UN_CONS_stack(A, B, C)\
2 7u83 315 
    {\
6 7u83 316 
	tdf *x11_ = CHECK_NULL(C);\
317 
	(A) = x11_[1].ag_ptr;\
318 
	(B) = x11_->ag_ptr;\
2 7u83 319 
    }
320 
 
6 7u83 321 
#define DESTROY_CONS_stack(D, A, B, C)\
2 7u83 322 
    {\
6 7u83 323 
	tdf *x12_ = CHECK_NULL(C);\
324 
	(A) = x12_[1].ag_ptr;\
325 
	(B) = x12_->ag_ptr;\
326 
	(D)(x12_, (unsigned)2);\
2 7u83 327 
    }
328 
 
6 7u83 329 
#define PUSH_stack(A, B)\
2 7u83 330 
    {\
6 7u83 331 
	tdf **r13_ = &(B);\
332 
	tdf *x13_ = GEN_tdf(2, TYPEID_stack);\
333 
	x13_[1].ag_ptr = (A);\
334 
	x13_->ag_ptr = *r13_;\
335 
	*r13_ = x13_;\
2 7u83 336 
    }
337 
 
6 7u83 338 
#define POP_stack(A, B)\
2 7u83 339 
    {\
6 7u83 340 
	tdf **r14_ = &(B);\
341 
	tdf *x14_ = CHECK_NULL(*r14_);\
342 
	(A) = x14_[1].ag_ptr;\
343 
	*r14_ = x14_->ag_ptr;\
344 
	destroy_tdf(x14_, (unsigned)2);\
2 7u83 345 
    }
346 
 
347 
 
348 
/* Definitions for sizes */
349 
 
6 7u83 350 
#define SCALE(A, B)			((A)*(int)(B))
2 7u83 351 
 
352 
 
353 
/* Definitions for primitive int */
354 
 
355 
#define SIZE_int			1
356 
 
6 7u83 357 
#define COPY_int(A, B)			(CHECK_NULL(A)->ag_prim_int = (B))
358 
#define DEREF_int(A)			(CHECK_NULL(A)->ag_prim_int)
359 
#define CONS_int(A, B, C)\
2 7u83 360 
    {\
6 7u83 361 
	tdf *x15_ = GEN_tdf(2, TYPEID_list);\
362 
	COPY_int(x15_ + 1, (A));\
363 
	x15_->ag_ptr = (B);\
364 
	(C) = x15_;\
2 7u83 365 
    }
366 
 
6 7u83 367 
#define UN_CONS_int(A, B, C)\
2 7u83 368 
    {\
6 7u83 369 
	tdf *x16_ = CHECK_NULL(C);\
370 
	(A) = DEREF_int(x16_ + 1);\
371 
	(B) = x16_->ag_ptr;\
2 7u83 372 
    }
373 
 
6 7u83 374 
#define DESTROY_CONS_int(D, A, B, C)\
2 7u83 375 
    {\
6 7u83 376 
	tdf *x17_ = CHECK_NULL(C);\
377 
	(A) = DEREF_int(x17_ + 1);\
378 
	(B) = x17_->ag_ptr;\
379 
	(D)(x17_, (unsigned)2);\
2 7u83 380 
    }
381 
 
6 7u83 382 
#define PUSH_int(A, B)\
2 7u83 383 
    {\
6 7u83 384 
	tdf **r18_ = &(B);\
385 
	tdf *x18_ = GEN_tdf(2, TYPEID_stack);\
386 
	COPY_int(x18_ + 1, (A));\
387 
	x18_->ag_ptr = *r18_;\
388 
	*r18_ = x18_;\
2 7u83 389 
    }
390 
 
6 7u83 391 
#define POP_int(A, B)\
2 7u83 392 
    {\
6 7u83 393 
	tdf **r19_ = &(B);\
394 
	tdf *x19_ = CHECK_NULL(*r19_);\
395 
	(A) = DEREF_int(x19_ + 1);\
396 
	*r19_ = x19_->ag_ptr;\
397 
	destroy_tdf(x19_, (unsigned)2);\
2 7u83 398 
    }
399 
 
400 
 
401 
/* Definitions for primitive unsigned */
402 
 
403 
#define SIZE_unsigned			1
404 
 
6 7u83 405 
#define COPY_unsigned(A, B)		(CHECK_NULL(A)->ag_prim_unsigned = (B))
406 
#define DEREF_unsigned(A)		(CHECK_NULL(A)->ag_prim_unsigned)
407 
#define CONS_unsigned(A, B, C)\
2 7u83 408 
    {\
6 7u83 409 
	tdf *x20_ = GEN_tdf(2, TYPEID_list);\
410 
	COPY_unsigned(x20_ + 1, (A));\
411 
	x20_->ag_ptr = (B);\
412 
	(C) = x20_;\
2 7u83 413 
    }
414 
 
6 7u83 415 
#define UN_CONS_unsigned(A, B, C)\
2 7u83 416 
    {\
6 7u83 417 
	tdf *x21_ = CHECK_NULL(C);\
418 
	(A) = DEREF_unsigned(x21_ + 1);\
419 
	(B) = x21_->ag_ptr;\
2 7u83 420 
    }
421 
 
6 7u83 422 
#define DESTROY_CONS_unsigned(D, A, B, C)\
2 7u83 423 
    {\
6 7u83 424 
	tdf *x22_ = CHECK_NULL(C);\
425 
	(A) = DEREF_unsigned(x22_ + 1);\
426 
	(B) = x22_->ag_ptr;\
427 
	(D)(x22_, (unsigned)2);\
2 7u83 428 
    }
429 
 
6 7u83 430 
#define PUSH_unsigned(A, B)\
2 7u83 431 
    {\
6 7u83 432 
	tdf **r23_ = &(B);\
433 
	tdf *x23_ = GEN_tdf(2, TYPEID_stack);\
434 
	COPY_unsigned(x23_ + 1, (A));\
435 
	x23_->ag_ptr = *r23_;\
436 
	*r23_ = x23_;\
2 7u83 437 
    }
438 
 
6 7u83 439 
#define POP_unsigned(A, B)\
2 7u83 440 
    {\
6 7u83 441 
	tdf **r24_ = &(B);\
442 
	tdf *x24_ = CHECK_NULL(*r24_);\
443 
	(A) = DEREF_unsigned(x24_ + 1);\
444 
	*r24_ = x24_->ag_ptr;\
445 
	destroy_tdf(x24_, (unsigned)2);\
2 7u83 446 
    }
447 
 
448 
 
449 
/* Definitions for primitive string */
450 
 
451 
#define SIZE_string			1
452 
 
6 7u83 453 
#define COPY_string(A, B)		(CHECK_NULL(A)->ag_prim_string = (B))
454 
#define DEREF_string(A)			(CHECK_NULL(A)->ag_prim_string)
455 
#define CONS_string(A, B, C)\
2 7u83 456 
    {\
6 7u83 457 
	tdf *x25_ = GEN_tdf(2, TYPEID_list);\
458 
	COPY_string(x25_ + 1, (A));\
459 
	x25_->ag_ptr = (B);\
460 
	(C) = x25_;\
2 7u83 461 
    }
462 
 
6 7u83 463 
#define UN_CONS_string(A, B, C)\
2 7u83 464 
    {\
6 7u83 465 
	tdf *x26_ = CHECK_NULL(C);\
466 
	(A) = DEREF_string(x26_ + 1);\
467 
	(B) = x26_->ag_ptr;\
2 7u83 468 
    }
469 
 
6 7u83 470 
#define DESTROY_CONS_string(D, A, B, C)\
2 7u83 471 
    {\
6 7u83 472 
	tdf *x27_ = CHECK_NULL(C);\
473 
	(A) = DEREF_string(x27_ + 1);\
474 
	(B) = x27_->ag_ptr;\
475 
	(D)(x27_, (unsigned)2);\
2 7u83 476 
    }
477 
 
6 7u83 478 
#define PUSH_string(A, B)\
2 7u83 479 
    {\
6 7u83 480 
	tdf **r28_ = &(B);\
481 
	tdf *x28_ = GEN_tdf(2, TYPEID_stack);\
482 
	COPY_string(x28_ + 1, (A));\
483 
	x28_->ag_ptr = *r28_;\
484 
	*r28_ = x28_;\
2 7u83 485 
    }
486 
 
6 7u83 487 
#define POP_string(A, B)\
2 7u83 488 
    {\
6 7u83 489 
	tdf **r29_ = &(B);\
490 
	tdf *x29_ = CHECK_NULL(*r29_);\
491 
	(A) = DEREF_string(x29_ + 1);\
492 
	*r29_ = x29_->ag_ptr;\
493 
	destroy_tdf(x29_, (unsigned)2);\
2 7u83 494 
    }
495 
 
496 
 
497 
/* Definitions for union PARAMETER */
498 
 
6 7u83 499 
#define ORDER_par			((unsigned) 1)
2 7u83 500 
#define SIZE_par			1
6 7u83 501 
#define NULL_par			((PARAMETER) 0)
502 
#define IS_NULL_par(A)			((A) == 0)
503 
#define EQ_par(A, B)			((A) == (B))
2 7u83 504 
 
6 7u83 505 
#define COPY_par(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
506 
#define DEREF_par(A)			(CHECK_NULL(A)->ag_ptr)
2 7u83 507 
 
6 7u83 508 
#define CONS_par(A, B, C)\
2 7u83 509 
    {\
6 7u83 510 
	tdf *x30_ = GEN_tdf(2, TYPEID_list);\
511 
	COPY_par(x30_ + 1, (A));\
512 
	x30_->ag_ptr = (B);\
513 
	(C) = x30_;\
2 7u83 514 
    }
515 
 
6 7u83 516 
#define UN_CONS_par(A, B, C)\
2 7u83 517 
    {\
6 7u83 518 
	tdf *x31_ = CHECK_NULL(C);\
519 
	(A) = DEREF_par(x31_ + 1);\
520 
	(B) = x31_->ag_ptr;\
2 7u83 521 
    }
522 
 
6 7u83 523 
#define DESTROY_CONS_par(D, A, B, C)\
2 7u83 524 
    {\
6 7u83 525 
	tdf *x32_ = CHECK_NULL(C);\
526 
	(A) = DEREF_par(x32_ + 1);\
527 
	(B) = x32_->ag_ptr;\
528 
	(D)(x32_, (unsigned)2);\
2 7u83 529 
    }
530 
 
6 7u83 531 
#define PUSH_par(A, B)\
2 7u83 532 
    {\
6 7u83 533 
	tdf **r33_ = &(B);\
534 
	tdf *x33_ = GEN_tdf(2, TYPEID_stack);\
535 
	COPY_par(x33_ + 1, (A));\
536 
	x33_->ag_ptr = *r33_;\
537 
	*r33_ = x33_;\
2 7u83 538 
    }
539 
 
6 7u83 540 
#define POP_par(A, B)\
2 7u83 541 
    {\
6 7u83 542 
	tdf **r34_ = &(B);\
543 
	tdf *x34_ = CHECK_NULL(*r34_);\
544 
	(A) = DEREF_par(x34_ + 1);\
545 
	*r34_ = x34_->ag_ptr;\
546 
	destroy_tdf(x34_, (unsigned)2);\
2 7u83 547 
    }
548 
 
549 
 
550 
/* Definitions for union CONSTRUCT */
551 
 
6 7u83 552 
#define ORDER_cons			((unsigned) 1)
2 7u83 553 
#define SIZE_cons			1
6 7u83 554 
#define NULL_cons			((CONSTRUCT) 0)
555 
#define IS_NULL_cons(A)			((A) == 0)
556 
#define EQ_cons(A, B)			((A) == (B))
2 7u83 557 
 
6 7u83 558 
#define COPY_cons(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
559 
#define DEREF_cons(A)			(CHECK_NULL(A)->ag_ptr)
2 7u83 560 
 
6 7u83 561 
#define CONS_cons(A, B, C)\
2 7u83 562 
    {\
6 7u83 563 
	tdf *x35_ = GEN_tdf(2, TYPEID_list);\
564 
	COPY_cons(x35_ + 1, (A));\
565 
	x35_->ag_ptr = (B);\
566 
	(C) = x35_;\
2 7u83 567 
    }
568 
 
6 7u83 569 
#define UN_CONS_cons(A, B, C)\
2 7u83 570 
    {\
6 7u83 571 
	tdf *x36_ = CHECK_NULL(C);\
572 
	(A) = DEREF_cons(x36_ + 1);\
573 
	(B) = x36_->ag_ptr;\
2 7u83 574 
    }
575 
 
6 7u83 576 
#define DESTROY_CONS_cons(D, A, B, C)\
2 7u83 577 
    {\
6 7u83 578 
	tdf *x37_ = CHECK_NULL(C);\
579 
	(A) = DEREF_cons(x37_ + 1);\
580 
	(B) = x37_->ag_ptr;\
581 
	(D)(x37_, (unsigned)2);\
2 7u83 582 
    }
583 
 
6 7u83 584 
#define PUSH_cons(A, B)\
2 7u83 585 
    {\
6 7u83 586 
	tdf **r38_ = &(B);\
587 
	tdf *x38_ = GEN_tdf(2, TYPEID_stack);\
588 
	COPY_cons(x38_ + 1, (A));\
589 
	x38_->ag_ptr = *r38_;\
590 
	*r38_ = x38_;\
2 7u83 591 
    }
592 
 
6 7u83 593 
#define POP_cons(A, B)\
2 7u83 594 
    {\
6 7u83 595 
	tdf **r39_ = &(B);\
596 
	tdf *x39_ = CHECK_NULL(*r39_);\
597 
	(A) = DEREF_cons(x39_ + 1);\
598 
	*r39_ = x39_->ag_ptr;\
599 
	destroy_tdf(x39_, (unsigned)2);\
2 7u83 600 
    }
601 
 
602 
 
603 
/* Definitions for union SORT_INFO */
604 
 
6 7u83 605 
#define ORDER_info			((unsigned) 6)
2 7u83 606 
#define SIZE_info			1
6 7u83 607 
#define NULL_info			((SORT_INFO) 0)
608 
#define IS_NULL_info(A)			((A) == 0)
609 
#define EQ_info(A, B)			((A) == (B))
2 7u83 610 
 
6 7u83 611 
#define COPY_info(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
612 
#define DEREF_info(A)			(CHECK_NULL(A)->ag_ptr)
2 7u83 613 
 
6 7u83 614 
#define CONS_info(A, B, C)\
2 7u83 615 
    {\
6 7u83 616 
	tdf *x40_ = GEN_tdf(2, TYPEID_list);\
617 
	COPY_info(x40_ + 1, (A));\
618 
	x40_->ag_ptr = (B);\
619 
	(C) = x40_;\
2 7u83 620 
    }
621 
 
6 7u83 622 
#define UN_CONS_info(A, B, C)\
2 7u83 623 
    {\
6 7u83 624 
	tdf *x41_ = CHECK_NULL(C);\
625 
	(A) = DEREF_info(x41_ + 1);\
626 
	(B) = x41_->ag_ptr;\
2 7u83 627 
    }
628 
 
6 7u83 629 
#define DESTROY_CONS_info(D, A, B, C)\
2 7u83 630 
    {\
6 7u83 631 
	tdf *x42_ = CHECK_NULL(C);\
632 
	(A) = DEREF_info(x42_ + 1);\
633 
	(B) = x42_->ag_ptr;\
634 
	(D)(x42_, (unsigned)2);\
2 7u83 635 
    }
636 
 
6 7u83 637 
#define PUSH_info(A, B)\
2 7u83 638 
    {\
6 7u83 639 
	tdf **r43_ = &(B);\
640 
	tdf *x43_ = GEN_tdf(2, TYPEID_stack);\
641 
	COPY_info(x43_ + 1, (A));\
642 
	x43_->ag_ptr = *r43_;\
643 
	*r43_ = x43_;\
2 7u83 644 
    }
645 
 
6 7u83 646 
#define POP_info(A, B)\
2 7u83 647 
    {\
6 7u83 648 
	tdf **r44_ = &(B);\
649 
	tdf *x44_ = CHECK_NULL(*r44_);\
650 
	(A) = DEREF_info(x44_ + 1);\
651 
	*r44_ = x44_->ag_ptr;\
652 
	destroy_tdf(x44_, (unsigned)2);\
2 7u83 653 
    }
654 
 
655 
 
656 
/* Definitions for union SORT */
657 
 
6 7u83 658 
#define ORDER_sort			((unsigned) 1)
2 7u83 659 
#define SIZE_sort			1
6 7u83 660 
#define NULL_sort			((SORT) 0)
661 
#define IS_NULL_sort(A)			((A) == 0)
662 
#define EQ_sort(A, B)			((A) == (B))
2 7u83 663 
 
6 7u83 664 
#define COPY_sort(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
665 
#define DEREF_sort(A)			(CHECK_NULL(A)->ag_ptr)
2 7u83 666 
 
6 7u83 667 
#define CONS_sort(A, B, C)\
2 7u83 668 
    {\
6 7u83 669 
	tdf *x45_ = GEN_tdf(2, TYPEID_list);\
670 
	COPY_sort(x45_ + 1, (A));\
671 
	x45_->ag_ptr = (B);\
672 
	(C) = x45_;\
2 7u83 673 
    }
674 
 
6 7u83 675 
#define UN_CONS_sort(A, B, C)\
2 7u83 676 
    {\
6 7u83 677 
	tdf *x46_ = CHECK_NULL(C);\
678 
	(A) = DEREF_sort(x46_ + 1);\
679 
	(B) = x46_->ag_ptr;\
2 7u83 680 
    }
681 
 
6 7u83 682 
#define DESTROY_CONS_sort(D, A, B, C)\
2 7u83 683 
    {\
6 7u83 684 
	tdf *x47_ = CHECK_NULL(C);\
685 
	(A) = DEREF_sort(x47_ + 1);\
686 
	(B) = x47_->ag_ptr;\
687 
	(D)(x47_, (unsigned)2);\
2 7u83 688 
    }
689 
 
6 7u83 690 
#define PUSH_sort(A, B)\
2 7u83 691 
    {\
6 7u83 692 
	tdf **r48_ = &(B);\
693 
	tdf *x48_ = GEN_tdf(2, TYPEID_stack);\
694 
	COPY_sort(x48_ + 1, (A));\
695 
	x48_->ag_ptr = *r48_;\
696 
	*r48_ = x48_;\
2 7u83 697 
    }
698 
 
6 7u83 699 
#define POP_sort(A, B)\
2 7u83 700 
    {\
6 7u83 701 
	tdf **r49_ = &(B);\
702 
	tdf *x49_ = CHECK_NULL(*r49_);\
703 
	(A) = DEREF_sort(x49_ + 1);\
704 
	*r49_ = x49_->ag_ptr;\
705 
	destroy_tdf(x49_, (unsigned)2);\
2 7u83 706 
    }
707 
 
708 
 
709 
/* Definitions for union LINKAGE */
710 
 
6 7u83 711 
#define ORDER_link			((unsigned) 1)
2 7u83 712 
#define SIZE_link			1
6 7u83 713 
#define NULL_link			((LINKAGE) 0)
714 
#define IS_NULL_link(A)			((A) == 0)
715 
#define EQ_link(A, B)			((A) == (B))
2 7u83 716 
 
6 7u83 717 
#define COPY_link(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
718 
#define DEREF_link(A)			(CHECK_NULL(A)->ag_ptr)
2 7u83 719 
 
6 7u83 720 
#define CONS_link(A, B, C)\
2 7u83 721 
    {\
6 7u83 722 
	tdf *x50_ = GEN_tdf(2, TYPEID_list);\
723 
	COPY_link(x50_ + 1, (A));\
724 
	x50_->ag_ptr = (B);\
725 
	(C) = x50_;\
2 7u83 726 
    }
727 
 
6 7u83 728 
#define UN_CONS_link(A, B, C)\
2 7u83 729 
    {\
6 7u83 730 
	tdf *x51_ = CHECK_NULL(C);\
731 
	(A) = DEREF_link(x51_ + 1);\
732 
	(B) = x51_->ag_ptr;\
2 7u83 733 
    }
734 
 
6 7u83 735 
#define DESTROY_CONS_link(D, A, B, C)\
2 7u83 736 
    {\
6 7u83 737 
	tdf *x52_ = CHECK_NULL(C);\
738 
	(A) = DEREF_link(x52_ + 1);\
739 
	(B) = x52_->ag_ptr;\
740 
	(D)(x52_, (unsigned)2);\
2 7u83 741 
    }
742 
 
6 7u83 743 
#define PUSH_link(A, B)\
2 7u83 744 
    {\
6 7u83 745 
	tdf **r53_ = &(B);\
746 
	tdf *x53_ = GEN_tdf(2, TYPEID_stack);\
747 
	COPY_link(x53_ + 1, (A));\
748 
	x53_->ag_ptr = *r53_;\
749 
	*r53_ = x53_;\
2 7u83 750 
    }
751 
 
6 7u83 752 
#define POP_link(A, B)\
2 7u83 753 
    {\
6 7u83 754 
	tdf **r54_ = &(B);\
755 
	tdf *x54_ = CHECK_NULL(*r54_);\
756 
	(A) = DEREF_link(x54_ + 1);\
757 
	*r54_ = x54_->ag_ptr;\
758 
	destroy_tdf(x54_, (unsigned)2);\
2 7u83 759 
    }
760 
 
761 
 
762 
/* Definitions for union SPECIFICATION */
763 
 
6 7u83 764 
#define ORDER_spec			((unsigned) 1)
2 7u83 765 
#define SIZE_spec			1
6 7u83 766 
#define NULL_spec			((SPECIFICATION) 0)
767 
#define IS_NULL_spec(A)			((A) == 0)
768 
#define EQ_spec(A, B)			((A) == (B))
2 7u83 769 
 
6 7u83 770 
#define COPY_spec(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
771 
#define DEREF_spec(A)			(CHECK_NULL(A)->ag_ptr)
2 7u83 772 
 
6 7u83 773 
#define CONS_spec(A, B, C)\
2 7u83 774 
    {\
6 7u83 775 
	tdf *x55_ = GEN_tdf(2, TYPEID_list);\
776 
	COPY_spec(x55_ + 1, (A));\
777 
	x55_->ag_ptr = (B);\
778 
	(C) = x55_;\
2 7u83 779 
    }
780 
 
6 7u83 781 
#define UN_CONS_spec(A, B, C)\
2 7u83 782 
    {\
6 7u83 783 
	tdf *x56_ = CHECK_NULL(C);\
784 
	(A) = DEREF_spec(x56_ + 1);\
785 
	(B) = x56_->ag_ptr;\
2 7u83 786 
    }
787 
 
6 7u83 788 
#define DESTROY_CONS_spec(D, A, B, C)\
2 7u83 789 
    {\
6 7u83 790 
	tdf *x57_ = CHECK_NULL(C);\
791 
	(A) = DEREF_spec(x57_ + 1);\
792 
	(B) = x57_->ag_ptr;\
793 
	(D)(x57_, (unsigned)2);\
2 7u83 794 
    }
795 
 
6 7u83 796 
#define PUSH_spec(A, B)\
2 7u83 797 
    {\
6 7u83 798 
	tdf **r58_ = &(B);\
799 
	tdf *x58_ = GEN_tdf(2, TYPEID_stack);\
800 
	COPY_spec(x58_ + 1, (A));\
801 
	x58_->ag_ptr = *r58_;\
802 
	*r58_ = x58_;\
2 7u83 803 
    }
804 
 
6 7u83 805 
#define POP_spec(A, B)\
2 7u83 806 
    {\
6 7u83 807 
	tdf **r59_ = &(B);\
808 
	tdf *x59_ = CHECK_NULL(*r59_);\
809 
	(A) = DEREF_spec(x59_ + 1);\
810 
	*r59_ = x59_->ag_ptr;\
811 
	destroy_tdf(x59_, (unsigned)2);\
2 7u83 812 
    }
813 
 
814 
 
815 
/* Definitions for union COMMAND */
816 
 
6 7u83 817 
#define ORDER_cmd			((unsigned) 6)
2 7u83 818 
#define SIZE_cmd			1
6 7u83 819 
#define NULL_cmd			((COMMAND) 0)
820 
#define IS_NULL_cmd(A)			((A) == 0)
821 
#define EQ_cmd(A, B)			((A) == (B))
2 7u83 822 
 
6 7u83 823 
#define COPY_cmd(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
824 
#define DEREF_cmd(A)			(CHECK_NULL(A)->ag_ptr)
2 7u83 825 
 
6 7u83 826 
#define CONS_cmd(A, B, C)\
2 7u83 827 
    {\
6 7u83 828 
	tdf *x60_ = GEN_tdf(2, TYPEID_list);\
829 
	COPY_cmd(x60_ + 1, (A));\
830 
	x60_->ag_ptr = (B);\
831 
	(C) = x60_;\
2 7u83 832 
    }
833 
 
6 7u83 834 
#define UN_CONS_cmd(A, B, C)\
2 7u83 835 
    {\
6 7u83 836 
	tdf *x61_ = CHECK_NULL(C);\
837 
	(A) = DEREF_cmd(x61_ + 1);\
838 
	(B) = x61_->ag_ptr;\
2 7u83 839 
    }
840 
 
6 7u83 841 
#define DESTROY_CONS_cmd(D, A, B, C)\
2 7u83 842 
    {\
6 7u83 843 
	tdf *x62_ = CHECK_NULL(C);\
844 
	(A) = DEREF_cmd(x62_ + 1);\
845 
	(B) = x62_->ag_ptr;\
846 
	(D)(x62_, (unsigned)2);\
2 7u83 847 
    }
848 
 
6 7u83 849 
#define PUSH_cmd(A, B)\
2 7u83 850 
    {\
6 7u83 851 
	tdf **r63_ = &(B);\
852 
	tdf *x63_ = GEN_tdf(2, TYPEID_stack);\
853 
	COPY_cmd(x63_ + 1, (A));\
854 
	x63_->ag_ptr = *r63_;\
855 
	*r63_ = x63_;\
2 7u83 856 
    }
857 
 
6 7u83 858 
#define POP_cmd(A, B)\
2 7u83 859 
    {\
6 7u83 860 
	tdf **r64_ = &(B);\
861 
	tdf *x64_ = CHECK_NULL(*r64_);\
862 
	(A) = DEREF_cmd(x64_ + 1);\
863 
	*r64_ = x64_->ag_ptr;\
864 
	destroy_tdf(x64_, (unsigned)2);\
2 7u83 865 
    }
866 
 
867 
 
868 
/* Maximum allocation size */
869 
 
870 
#define tdf_GEN_MAX			10
871 
 
872 
#endif