Subversion Repositories tendra.SVN

Rev

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

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