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 calculus_IMPLEMENTATION		1
 42 
#define calculus_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 unsigned long number ;
 55 
typedef unsigned long number;
72 
typedef char * string ;
 56 
typedef char * string;
73 
 
 57 
 
74 
 
 58 
 
75 
/* Basic types */
 59 
/* Basic types */
76 
 
 60 
 
77 
typedef union calculus_tag {
 61 
typedef union calculus_tag {
78 
    unsigned ag_tag ;
 62 
    unsigned ag_tag;
79 
    union calculus_tag *ag_ptr ;
 63 
    union calculus_tag *ag_ptr;
80 
    unsigned ag_enum ;
 64 
    unsigned ag_enum;
81 
    unsigned long ag_long_enum ;
 65 
    unsigned long ag_long_enum;
82 
    int ag_prim_int ;
 66 
    int ag_prim_int;
83 
    number ag_prim_number ;
 67 
    number ag_prim_number;
84 
    string ag_prim_string ;
 68 
    string ag_prim_string;
85 
} calculus ;
 69 
} calculus;
86 
 
 70 
 
87 
typedef calculus *calculus_PTR ;
 71 
typedef calculus *calculus_PTR;
88 
 
 72 
 
89 
#ifndef calculus_DESTR_DEFINED
 73 
#ifndef calculus_DESTR_DEFINED
90 
#define calculus_DESTR_DEFINED
 74 
#define calculus_DESTR_DEFINED
91 
typedef void ( *DESTROYER ) PROTO_S ( ( calculus *, unsigned ) ) ;
 75 
typedef void (*DESTROYER)(calculus *, unsigned);
92 
#endif
 76 
#endif
93 
 
 77 
 
94 
#define PTR( A )	calculus_PTR
 78 
#define PTR(A)	calculus_PTR
95 
#define LIST( A )	calculus_PTR
 79 
#define LIST(A)	calculus_PTR
96 
#define STACK( A )	calculus_PTR
 80 
#define STACK(A)	calculus_PTR
97 
#define SIZE( A )	int
 81 
#define SIZE(A)	int
98 
 
 82 
 
99 
 
 83 
 
100 
/* Assertion macros */
 84 
/* Assertion macros */
101 
 
 85 
 
102 
#ifdef ASSERTS
 86 
#ifdef ASSERTS
103 
extern calculus *check_null_calculus PROTO_S ( ( calculus *, CONST_S char *, int ) ) ;
 87 
extern calculus *check_null_calculus(calculus *, char *, int);
104 
extern calculus *check_tag_calculus PROTO_S ( ( calculus *, unsigned, CONST_S char *, int ) ) ;
 88 
extern calculus *check_tag_calculus(calculus *, unsigned, char *, int);
105 
extern calculus *check_tag_etc_calculus PROTO_S ( ( calculus *, unsigned, unsigned, CONST_S char *, int ) ) ;
 89 
extern calculus *check_tag_etc_calculus(calculus *, unsigned, unsigned, char *, int);
106 
#define CHECK_NULL( P )\
 90 
#define CHECK_NULL(P)\
107 
    ( check_null_calculus ( ( P ), __FILE__, __LINE__ ) )
 91 
    (check_null_calculus((P), __FILE__, __LINE__))
108 
#define CHECK_TAG( P, N )\
 92 
#define CHECK_TAG(P, N)\
109 
    ( check_tag_calculus ( ( P ), ( unsigned ) ( N ), __FILE__, __LINE__ ) )
 93 
    (check_tag_calculus((P), (unsigned)(N), __FILE__, __LINE__))
110 
#define CHECK_TAG_ETC( P, L, U )\
 94 
#define CHECK_TAG_ETC(P, L, U)\
111 
    ( check_tag_etc_calculus ( ( P ), ( unsigned ) ( L ), ( unsigned ) ( U ), __FILE__, __LINE__ ) )
 95 
    (check_tag_etc_calculus((P), (unsigned)(L), (unsigned)(U), __FILE__, __LINE__))
112 
#else
 96 
#else
113 
#define CHECK_NULL( P )			( P )
 97 
#define CHECK_NULL(P)			(P)
114 
#define CHECK_TAG( P, N )		( P )
 98 
#define CHECK_TAG(P, N)			(P)
115 
#define CHECK_TAG_ETC( P, L, U )	( P )
 99 
#define CHECK_TAG_ETC(P, L, U)		(P)
116 
#endif
 100 
#endif
117 
 
 101 
 
118 
 
 102 
 
119 
/* Enumeration definitions */
 103 
/* Enumeration definitions */
120 
 
 104 
 
121 
 
 105 
 
122 
 
 106 
 
123 
/* Union type definitions */
 107 
/* Union type definitions */
124 
 
 108 
 
125 
typedef calculus *TYPE ;
 109 
typedef calculus *TYPE;
126 
typedef calculus *COMMAND ;
 110 
typedef calculus *COMMAND;
127 
 
 111 
 
128 
 
 112 
 
129 
/* Structure declarations */
 113 
/* Structure declarations */
130 
 
 114 
 
131 
typedef struct alg_tag ALGEBRA_DEFN ;
 115 
typedef struct alg_tag ALGEBRA_DEFN;
132 
typedef struct cid_tag CLASS_ID ;
 116 
typedef struct cid_tag CLASS_ID;
133 
typedef struct prim_tag PRIMITIVE ;
 117 
typedef struct prim_tag PRIMITIVE;
134 
typedef struct ec_tag ECONST ;
 118 
typedef struct ec_tag ECONST;
135 
typedef struct en_tag ENUM ;
 119 
typedef struct en_tag ENUM;
136 
typedef struct ident_tag IDENTITY ;
 120 
typedef struct ident_tag IDENTITY;
137 
typedef struct cmp_tag COMPONENT ;
 121 
typedef struct cmp_tag COMPONENT;
138 
typedef struct str_tag STRUCTURE ;
 122 
typedef struct str_tag STRUCTURE;
139 
typedef struct fld_tag FIELD ;
 123 
typedef struct fld_tag FIELD;
140 
typedef struct arg_tag ARGUMENT ;
 124 
typedef struct arg_tag ARGUMENT;
141 
typedef struct map_tag MAP ;
 125 
typedef struct map_tag MAP;
142 
typedef struct un_tag UNION ;
 126 
typedef struct un_tag UNION;
143 
 
 127 
 
144 
 
 128 
 
145 
/* Identity type definitions */
 129 
/* Identity type definitions */
146 
 
 130 
 
147 
typedef string name_string ;
 131 
typedef string name_string;
148 
typedef int zero_int ;
 132 
typedef int zero_int;
149 
typedef PTR ( int ) int_P ;
 133 
typedef PTR(int) int_P;
150 
typedef PTR ( number ) number_P ;
 134 
typedef PTR(number) number_P;
151 
typedef PTR ( string ) string_P ;
 135 
typedef PTR(string) string_P;
152 
typedef PTR ( ARGUMENT ) ARGUMENT_P ;
 136 
typedef PTR(ARGUMENT) ARGUMENT_P;
153 
typedef PTR ( CLASS_ID ) CLASS_ID_P ;
 137 
typedef PTR(CLASS_ID) CLASS_ID_P;
154 
typedef PTR ( CLASS_ID_P ) CLASS_ID_P_P ;
 138 
typedef PTR(CLASS_ID_P) CLASS_ID_P_P;
155 
typedef PTR ( COMPONENT ) COMPONENT_P ;
 139 
typedef PTR(COMPONENT) COMPONENT_P;
156 
typedef PTR ( ECONST ) ECONST_P ;
 140 
typedef PTR(ECONST) ECONST_P;
157 
typedef PTR ( ENUM ) ENUM_P ;
 141 
typedef PTR(ENUM) ENUM_P;
158 
typedef PTR ( FIELD ) FIELD_P ;
 142 
typedef PTR(FIELD) FIELD_P;
159 
typedef PTR ( IDENTITY ) IDENTITY_P ;
 143 
typedef PTR(IDENTITY) IDENTITY_P;
160 
typedef PTR ( MAP ) MAP_P ;
 144 
typedef PTR(MAP) MAP_P;
161 
typedef PTR ( PRIMITIVE ) PRIMITIVE_P ;
 145 
typedef PTR(PRIMITIVE) PRIMITIVE_P;
162 
typedef PTR ( STRUCTURE ) STRUCTURE_P ;
 146 
typedef PTR(STRUCTURE) STRUCTURE_P;
163 
typedef PTR ( TYPE ) TYPE_P ;
 147 
typedef PTR(TYPE) TYPE_P;
164 
typedef PTR ( TYPE_P ) TYPE_P_P ;
 148 
typedef PTR(TYPE_P) TYPE_P_P;
165 
typedef PTR ( UNION ) UNION_P ;
 149 
typedef PTR(UNION) UNION_P;
166 
 
 150 
 
167 
 
 151 
 
168 
/* Structure definitions */
 152 
/* Structure definitions */
169 
 
 153 
 
170 
#ifndef calculus_STRUCT_DEFINED
 154 
#ifndef calculus_STRUCT_DEFINED
171 
#define calculus_STRUCT_DEFINED
 155 
#define calculus_STRUCT_DEFINED
172 
 
 156 
 
173 
struct alg_tag {
 157 
struct alg_tag {
174 
    string name ;
 158 
    string name;
175 
    int major_no ;
 159 
    int major_no;
176 
    int minor_no ;
 160 
    int minor_no;
177 
    LIST ( PRIMITIVE_P ) primitives ;
 161 
    LIST(PRIMITIVE_P) primitives;
178 
    LIST ( IDENTITY_P ) identities ;
 162 
    LIST(IDENTITY_P) identities;
179 
    LIST ( ENUM_P ) enumerations ;
 163 
    LIST(ENUM_P) enumerations;
180 
    LIST ( STRUCTURE_P ) structures ;
 164 
    LIST(STRUCTURE_P) structures;
181 
    LIST ( UNION_P ) unions ;
 165 
    LIST(UNION_P) unions;
182 
    LIST ( TYPE_P ) types ;
 166 
    LIST(TYPE_P) types;
183 
} ;
 167 
};
184 
 
 168 
 
185 
struct cid_tag {
 169 
struct cid_tag {
186 
    string name ;
 170 
    string name;
187 
    string name_aux ;
 171 
    string name_aux;
188 
    int flag ;
 172 
    int flag;
189 
    name_string file ;
 173 
    name_string file;
190 
    int line ;
 174 
    int line;
191 
} ;
 175 
};
192 
 
 176 
 
193 
struct prim_tag {
 177 
struct prim_tag {
194 
    CLASS_ID_P id ;
 178 
    CLASS_ID_P id;
195 
    string defn ;
 179 
    string defn;
196 
} ;
 180 
};
197 
 
 181 
 
198 
struct ec_tag {
 182 
struct ec_tag {
199 
    string name ;
 183 
    string name;
200 
    number value ;
 184 
    number value;
201 
} ;
 185 
};
202 
 
 186 
 
203 
struct en_tag {
 187 
struct en_tag {
204 
    CLASS_ID_P id ;
 188 
    CLASS_ID_P id;
205 
    LIST ( ECONST_P ) consts ;
 189 
    LIST(ECONST_P) consts;
206 
    number order ;
 190 
    number order;
207 
    int lists ;
 191 
    int lists;
208 
} ;
 192 
};
209 
 
 193 
 
210 
struct ident_tag {
 194 
struct ident_tag {
211 
    CLASS_ID_P id ;
 195 
    CLASS_ID_P id;
212 
    TYPE_P defn ;
 196 
    TYPE_P defn;
213 
} ;
 197 
};
214 
 
 198 
 
215 
struct cmp_tag {
 199 
struct cmp_tag {
216 
    string name ;
 200 
    string name;
217 
    TYPE_P type ;
 201 
    TYPE_P type;
218 
    string value ;
 202 
    string value;
219 
} ;
 203 
};
220 
 
 204 
 
221 
struct str_tag {
 205 
struct str_tag {
222 
    CLASS_ID_P id ;
 206 
    CLASS_ID_P id;
223 
    STRUCTURE_P base ;
 207 
    STRUCTURE_P base;
224 
    LIST ( COMPONENT_P ) defn ;
 208 
    LIST(COMPONENT_P) defn;
225 
    zero_int output ;
 209 
    zero_int output;
226 
} ;
 210 
};
227 
 
 211 
 
228 
struct fld_tag {
 212 
struct fld_tag {
229 
    string name ;
 213 
    string name;
230 
    int tag ;
 214 
    int tag;
231 
    int flag ;
 215 
    int flag;
232 
    int set ;
 216 
    int set;
233 
    FIELD_P base ;
 217 
    FIELD_P base;
234 
    LIST ( COMPONENT_P ) defn ;
 218 
    LIST(COMPONENT_P) defn;
235 
} ;
 219 
};
236 
 
 220 
 
237 
struct arg_tag {
 221 
struct arg_tag {
238 
    string name ;
 222 
    string name;
239 
    TYPE_P type ;
 223 
    TYPE_P type;
240 
} ;
 224 
};
241 
 
 225 
 
242 
struct map_tag {
 226 
struct map_tag {
243 
    string name ;
 227 
    string name;
244 
    int flag ;
 228 
    int flag;
245 
    TYPE_P ret_type ;
 229 
    TYPE_P ret_type;
246 
    LIST ( ARGUMENT_P ) args ;
 230 
    LIST(ARGUMENT_P) args;
247 
} ;
 231 
};
248 
 
 232 
 
249 
struct un_tag {
 233 
struct un_tag {
250 
    CLASS_ID_P id ;
 234 
    CLASS_ID_P id;
251 
    UNION_P base ;
 235 
    UNION_P base;
252 
    LIST ( COMPONENT_P ) s_defn ;
 236 
    LIST(COMPONENT_P) s_defn;
253 
    LIST ( FIELD_P ) u_defn ;
 237 
    LIST(FIELD_P) u_defn;
254 
    LIST ( MAP_P ) map ;
 238 
    LIST(MAP_P) map;
255 
    int no_fields ;
 239 
    int no_fields;
256 
} ;
 240 
};
257 
 
 241 
 
258 
#endif /* calculus_STRUCT_DEFINED */
 242 
#endif /* calculus_STRUCT_DEFINED */
259 
 
 243 
 
260 
 
 244 
 
261 
/* Function declarations */
 245 
/* Function declarations */
262 
 
 246 
 
263 
extern calculus *gen_calculus PROTO_S ( ( unsigned ) ) ;
 247 
extern calculus *gen_calculus(unsigned);
264 
extern void destroy_calculus PROTO_S ( ( calculus *, unsigned ) ) ;
 248 
extern void destroy_calculus(calculus *, unsigned);
265 
extern void dummy_destroy_calculus PROTO_S ( ( calculus *, unsigned ) ) ;
 249 
extern void dummy_destroy_calculus (calculus *, unsigned);
266 
extern void destroy_calculus_list PROTO_S ( ( calculus *, unsigned ) ) ;
 250 
extern void destroy_calculus_list (calculus *, unsigned);
267 
extern calculus *append_calculus_list PROTO_S ( ( calculus *, calculus * ) ) ;
 251 
extern calculus *append_calculus_list(calculus *, calculus *);
268 
extern calculus *end_calculus_list PROTO_S ( ( calculus * ) ) ;
 252 
extern calculus *end_calculus_list(calculus *);
269 
extern unsigned length_calculus_list PROTO_S ( ( calculus * ) ) ;
 253 
extern unsigned length_calculus_list(calculus *);
270 
extern calculus *reverse_calculus_list PROTO_S ( ( calculus * ) ) ;
 254 
extern calculus *reverse_calculus_list(calculus *);
271 
#ifdef calculus_IO_ROUTINES
 255 
#ifdef calculus_IO_ROUTINES
272 
extern unsigned crt_calculus_alias ;
 256 
extern unsigned crt_calculus_alias;
273 
extern void set_calculus_alias PROTO_S ( ( calculus *, unsigned ) ) ;
 257 
extern void set_calculus_alias(calculus *, unsigned);
274 
extern calculus *find_calculus_alias PROTO_S ( ( unsigned ) ) ;
 258 
extern calculus *find_calculus_alias(unsigned);
275 
extern void clear_calculus_alias PROTO_S ( ( void ) ) ;
 259 
extern void clear_calculus_alias(void);
276 
#endif
 260 
#endif
277 
 
 261 
 
278 
 
 262 
 
279 
/* Run-time type information */
 263 
/* Run-time type information */
280 
 
 264 
 
281 
#ifndef GEN_calculus
 265 
#ifndef GEN_calculus
282 
#define GEN_calculus( A, B )		gen_calculus ( ( unsigned ) ( A ) )
 266 
#define GEN_calculus(A, B)		gen_calculus((unsigned)(A))
283 
#endif
 267 
#endif
284 
#define TYPEID_ptr			( ( unsigned ) 0 )
 268 
#define TYPEID_ptr			((unsigned)0)
285 
#define TYPEID_list			( ( unsigned ) 1 )
 269 
#define TYPEID_list			((unsigned)1)
286 
#define TYPEID_stack			( ( unsigned ) 2 )
 270 
#define TYPEID_stack			((unsigned)2)
287 
#define TYPEID_type			( ( unsigned ) 3 )
 271 
#define TYPEID_type			((unsigned)3)
288 
#define TYPEID_cmd			( ( unsigned ) 4 )
 272 
#define TYPEID_cmd			((unsigned)4)
289 
 
 273 
 
290 
 
 274 
 
291 
/* Definitions for pointers */
 275 
/* Definitions for pointers */
292 
 
 276 
 
293 
#define STEP_ptr( A, B )		( CHECK_NULL ( A ) + B )
 277 
#define STEP_ptr(A, B)			(CHECK_NULL(A) + B)
294 
#define SIZE_ptr( A )			1
 278 
#define SIZE_ptr(A)			1
295 
#define NULL_ptr( A )			( ( calculus * ) 0 )
 279 
#define NULL_ptr(A)			((calculus *)0)
296 
#define IS_NULL_ptr( A )		( ( A ) == 0 )
 280 
#define IS_NULL_ptr(A)			((A) == 0)
297 
#define EQ_ptr( A, B )			( ( A ) == ( B ) )
 281 
#define EQ_ptr(A, B)			((A) == (B))
298 
#define MAKE_ptr( A )			GEN_calculus ( ( A ), TYPEID_ptr )
 282 
#define MAKE_ptr(A)			GEN_calculus((A), TYPEID_ptr)
299 
#define DESTROY_ptr( A, B )		destroy_calculus ( ( A ), ( unsigned ) ( B ) )
 283 
#define DESTROY_ptr(A, B)		destroy_calculus((A), (unsigned)(B))
300 
#define UNIQ_ptr( A )			GEN_calculus ( 1, TYPEID_ptr )
 284 
#define UNIQ_ptr(A)			GEN_calculus(1, TYPEID_ptr)
301 
#define DESTROY_UNIQ_ptr( A )		destroy_calculus ( ( A ), ( unsigned ) 1 )
 285 
#define DESTROY_UNIQ_ptr(A)		destroy_calculus((A), (unsigned)1)
302 
#ifdef calculus_IO_ROUTINES
 286 
#ifdef calculus_IO_ROUTINES
303 
#define VOIDSTAR_ptr( A )		( ( void * ) ( A ) )
 287 
#define VOIDSTAR_ptr(A)			((void *)(A))
304 
#endif
 288 
#endif
305 
 
 289 
 
306 
#define COPY_ptr( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 290 
#define COPY_ptr(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
307 
#define DEREF_ptr( A )			( CHECK_NULL ( A )->ag_ptr )
 291 
#define DEREF_ptr(A)			(CHECK_NULL(A)->ag_ptr)
308 
#define CONS_ptr( A, B, C )\
 292 
#define CONS_ptr(A, B, C)\
309 
    {\
 293 
    {\
310 
	calculus *x0_ = GEN_calculus ( 2, TYPEID_list ) ;\
 294 
	calculus *x0_ = GEN_calculus(2, TYPEID_list);\
311 
	x0_ [1].ag_ptr = ( A ) ;\
 295 
	x0_[1].ag_ptr = (A);\
312 
	x0_->ag_ptr = ( B ) ;\
 296 
	x0_->ag_ptr = (B);\
313 
	( C ) = x0_ ;\
 297 
	(C) = x0_;\
314 
    }
 298 
    }
315 
 
 299 
 
316 
#define UN_CONS_ptr( A, B, C )\
 300 
#define UN_CONS_ptr(A, B, C)\
317 
    {\
 301 
    {\
318 
	calculus *x1_ = CHECK_NULL ( C ) ;\
 302 
	calculus *x1_ = CHECK_NULL(C);\
319 
	( A ) = x1_ [1].ag_ptr ;\
 303 
	(A) = x1_[1].ag_ptr;\
320 
	( B ) = x1_->ag_ptr ;\
 304 
	(B) = x1_->ag_ptr;\
321 
    }
 305 
    }
322 
 
 306 
 
323 
#define DESTROY_CONS_ptr( D, A, B, C )\
 307 
#define DESTROY_CONS_ptr(D, A, B, C)\
324 
    {\
 308 
    {\
325 
	calculus *x2_ = CHECK_NULL ( C ) ;\
 309 
	calculus *x2_ = CHECK_NULL(C);\
326 
	( A ) = x2_ [1].ag_ptr ;\
 310 
	(A) = x2_[1].ag_ptr;\
327 
	( B ) = x2_->ag_ptr ;\
 311 
	(B) = x2_->ag_ptr;\
328 
	( D ) ( x2_, ( unsigned ) 2 ) ;\
 312 
	(D)(x2_, (unsigned)2);\
329 
    }
 313 
    }
330 
 
 314 
 
331 
#define PUSH_ptr( A, B )\
 315 
#define PUSH_ptr(A, B)\
332 
    {\
 316 
    {\
333 
	calculus **r3_ = &( B ) ;\
 317 
	calculus **r3_ = &(B);\
334 
	calculus *x3_ = GEN_calculus ( 2, TYPEID_stack ) ;\
 318 
	calculus *x3_ = GEN_calculus(2, TYPEID_stack);\
335 
	x3_ [1].ag_ptr = ( A ) ;\
 319 
	x3_[1].ag_ptr = (A);\
336 
	x3_->ag_ptr = *r3_ ;\
 320 
	x3_->ag_ptr = *r3_;\
337 
	*r3_ = x3_ ;\
 321 
	*r3_ = x3_;\
338 
    }
 322 
    }
339 
 
 323 
 
340 
#define POP_ptr( A, B )\
 324 
#define POP_ptr(A, B)\
341 
    {\
 325 
    {\
342 
	calculus **r4_ = &( B ) ;\
 326 
	calculus **r4_ = &(B);\
343 
	calculus *x4_ = CHECK_NULL ( *r4_ ) ;\
 327 
	calculus *x4_ = CHECK_NULL(*r4_);\
344 
	( A ) = x4_ [1].ag_ptr ;\
 328 
	(A) = x4_[1].ag_ptr;\
345 
	*r4_ = x4_->ag_ptr ;\
 329 
	*r4_ = x4_->ag_ptr;\
346 
	destroy_calculus ( x4_, ( unsigned ) 2 ) ;\
 330 
	destroy_calculus(x4_, (unsigned)2);\
347 
    }
 331 
    }
348 
 
 332 
 
349 
 
 333 
 
350 
/* Definitions for lists */
 334 
/* Definitions for lists */
351 
 
 335 
 
352 
#define HEAD_list( A )			( CHECK_NULL ( A ) + 1 )
 336 
#define HEAD_list(A)			(CHECK_NULL(A) + 1)
353 
#define PTR_TAIL_list( A )		( CHECK_NULL ( A ) )
 337 
#define PTR_TAIL_list(A)		(CHECK_NULL(A))
354 
#define TAIL_list( A )			( CHECK_NULL ( A )->ag_ptr )
 338 
#define TAIL_list(A)			(CHECK_NULL(A)->ag_ptr)
355 
#define LENGTH_list( A )		length_calculus_list ( ( A ) )
 339 
#define LENGTH_list(A)			length_calculus_list((A))
356 
#define END_list( A )			end_calculus_list ( ( A ) )
 340 
#define END_list(A)			end_calculus_list((A))
357 
#define REVERSE_list( A )		reverse_calculus_list ( ( A ) )
 341 
#define REVERSE_list(A)			reverse_calculus_list((A))
358 
#define APPEND_list( A, B )		append_calculus_list ( ( A ), ( B ) )
 342 
#define APPEND_list(A, B)		append_calculus_list((A), (B))
359 
 
 343 
 
360 
#define SIZE_list( A )			1
 344 
#define SIZE_list(A)			1
361 
#define NULL_list( A )			( ( calculus * ) 0 )
 345 
#define NULL_list(A)			((calculus *) 0)
362 
#define IS_NULL_list( A )		( ( A ) == 0 )
 346 
#define IS_NULL_list(A)			((A) == 0)
363 
#define EQ_list( A, B )			( ( A ) == ( B ) )
 347 
#define EQ_list(A, B)			((A) == (B))
364 
#define UNIQ_list( A )			GEN_calculus ( 1, TYPEID_list )
 348 
#define UNIQ_list(A)			GEN_calculus(1, TYPEID_list)
365 
#define DESTROY_UNIQ_list( A )		destroy_calculus ( ( A ), ( unsigned ) 1 )
 349 
#define DESTROY_UNIQ_list(A)		destroy_calculus((A), (unsigned)1)
366 
#ifdef calculus_IO_ROUTINES
 350 
#ifdef calculus_IO_ROUTINES
367 
#define VOIDSTAR_list( A )		( ( void * ) ( A ) )
 351 
#define VOIDSTAR_list(A)		((void *)(A))
368 
#endif
 352 
#endif
369 
 
 353 
 
370 
#define DESTROY_list( A, B )\
 354 
#define DESTROY_list(A, B)\
371 
    {\
 355 
    {\
372 
	destroy_calculus_list ( ( A ), ( unsigned ) ( B ) ) ;\
 356 
	destroy_calculus_list((A), (unsigned)(B));\
373 
    }
 357 
    }
374 
 
 358 
 
375 
#define COPY_list( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 359 
#define COPY_list(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
376 
#define DEREF_list( A )			( CHECK_NULL ( A )->ag_ptr )
 360 
#define DEREF_list(A)			(CHECK_NULL(A)->ag_ptr)
377 
#define CONS_list( A, B, C )\
 361 
#define CONS_list(A, B, C)\
378 
    {\
 362 
    {\
379 
	calculus *x5_ = GEN_calculus ( 2, TYPEID_list ) ;\
 363 
	calculus *x5_ = GEN_calculus(2, TYPEID_list);\
380 
	x5_ [1].ag_ptr = ( A ) ;\
 364 
	x5_[1].ag_ptr = (A);\
381 
	x5_->ag_ptr = ( B ) ;\
 365 
	x5_->ag_ptr = (B);\
382 
	( C ) = x5_ ;\
 366 
	(C) = x5_;\
383 
    }
 367 
    }
384 
 
 368 
 
385 
#define UN_CONS_list( A, B, C )\
 369 
#define UN_CONS_list(A, B, C)\
386 
    {\
 370 
    {\
387 
	calculus *x6_ = CHECK_NULL ( C ) ;\
 371 
	calculus *x6_ = CHECK_NULL(C);\
388 
	( A ) = x6_ [1].ag_ptr ;\
 372 
	(A) = x6_[1].ag_ptr;\
389 
	( B ) = x6_->ag_ptr ;\
 373 
	(B) = x6_->ag_ptr;\
390 
    }
 374 
    }
391 
 
 375 
 
392 
#define DESTROY_CONS_list( D, A, B, C )\
 376 
#define DESTROY_CONS_list(D, A, B, C)\
393 
    {\
 377 
    {\
394 
	calculus *x7_ = CHECK_NULL ( C ) ;\
 378 
	calculus *x7_ = CHECK_NULL(C);\
395 
	( A ) = x7_ [1].ag_ptr ;\
 379 
	(A) = x7_[1].ag_ptr;\
396 
	( B ) = x7_->ag_ptr ;\
 380 
	(B) = x7_->ag_ptr;\
397 
	( D ) ( x7_, ( unsigned ) 2 ) ;\
 381 
	(D)(x7_, (unsigned)2);\
398 
    }
 382 
    }
399 
 
 383 
 
400 
#define PUSH_list( A, B )\
 384 
#define PUSH_list(A, B)\
401 
    {\
 385 
    {\
402 
	calculus **r8_ = &( B ) ;\
 386 
	calculus **r8_ = &(B);\
403 
	calculus *x8_ = GEN_calculus ( 2, TYPEID_stack ) ;\
 387 
	calculus *x8_ = GEN_calculus(2, TYPEID_stack);\
404 
	x8_ [1].ag_ptr = ( A ) ;\
 388 
	x8_[1].ag_ptr = (A);\
405 
	x8_->ag_ptr = *r8_ ;\
 389 
	x8_->ag_ptr = *r8_;\
406 
	*r8_ = x8_ ;\
 390 
	*r8_ = x8_;\
407 
    }
 391 
    }
408 
 
 392 
 
409 
#define POP_list( A, B )\
 393 
#define POP_list(A, B)\
410 
    {\
 394 
    {\
411 
	calculus **r9_ = &( B ) ;\
 395 
	calculus **r9_ = &(B);\
412 
	calculus *x9_ = CHECK_NULL ( *r9_ ) ;\
 396 
	calculus *x9_ = CHECK_NULL(*r9_);\
413 
	( A ) = x9_ [1].ag_ptr ;\
 397 
	(A) = x9_[1].ag_ptr;\
414 
	*r9_ = x9_->ag_ptr ;\
 398 
	*r9_ = x9_->ag_ptr;\
415 
	destroy_calculus ( x9_, ( unsigned ) 2 ) ;\
 399 
	destroy_calculus(x9_, (unsigned)2);\
416 
    }
 400 
    }
417 
 
 401 
 
418 
 
 402 
 
419 
/* Definitions for stacks */
 403 
/* Definitions for stacks */
420 
 
 404 
 
421 
#define SIZE_stack( A )			1
 405 
#define SIZE_stack(A)			1
422 
#define NULL_stack( A )			( ( calculus * ) 0 )
 406 
#define NULL_stack(A)			((calculus *) 0)
423 
#define IS_NULL_stack( A )		( ( A ) == 0 )
 407 
#define IS_NULL_stack(A)		((A) == 0)
424 
#define STACK_list( A )			( A )
 408 
#define STACK_list(A)			(A)
425 
#define LIST_stack( A )			( A )
 409 
#define LIST_stack(A)			(A)
426 
 
 410 
 
427 
#define COPY_stack( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 411 
#define COPY_stack(A, B)		(CHECK_NULL(A)->ag_ptr = (B))
428 
#define DEREF_stack( A )		( CHECK_NULL ( A )->ag_ptr )
 412 
#define DEREF_stack(A)			(CHECK_NULL(A)->ag_ptr)
429 
#define CONS_stack( A, B, C )\
 413 
#define CONS_stack(A, B, C)\
430 
    {\
 414 
    {\
431 
	calculus *x10_ = GEN_calculus ( 2, TYPEID_list ) ;\
 415 
	calculus *x10_ = GEN_calculus(2, TYPEID_list);\
432 
	x10_ [1].ag_ptr = ( A ) ;\
 416 
	x10_[1].ag_ptr = (A);\
433 
	x10_->ag_ptr = ( B ) ;\
 417 
	x10_->ag_ptr = (B);\
434 
	( C ) = x10_ ;\
 418 
	(C) = x10_;\
435 
    }
 419 
    }
436 
 
 420 
 
437 
#define UN_CONS_stack( A, B, C )\
 421 
#define UN_CONS_stack(A, B, C)\
438 
    {\
 422 
    {\
439 
	calculus *x11_ = CHECK_NULL ( C ) ;\
 423 
	calculus *x11_ = CHECK_NULL(C);\
440 
	( A ) = x11_ [1].ag_ptr ;\
 424 
	(A) = x11_[1].ag_ptr;\
441 
	( B ) = x11_->ag_ptr ;\
 425 
	(B) = x11_->ag_ptr;\
442 
    }
 426 
    }
443 
 
 427 
 
444 
#define DESTROY_CONS_stack( D, A, B, C )\
 428 
#define DESTROY_CONS_stack(D, A, B, C)\
445 
    {\
 429 
    {\
446 
	calculus *x12_ = CHECK_NULL ( C ) ;\
 430 
	calculus *x12_ = CHECK_NULL(C);\
447 
	( A ) = x12_ [1].ag_ptr ;\
 431 
	(A) = x12_[1].ag_ptr;\
448 
	( B ) = x12_->ag_ptr ;\
 432 
	(B) = x12_->ag_ptr;\
449 
	( D ) ( x12_, ( unsigned ) 2 ) ;\
 433 
	(D)(x12_, (unsigned)2);\
450 
    }
 434 
    }
451 
 
 435 
 
452 
#define PUSH_stack( A, B )\
 436 
#define PUSH_stack(A, B)\
453 
    {\
 437 
    {\
454 
	calculus **r13_ = &( B ) ;\
 438 
	calculus **r13_ = &(B);\
455 
	calculus *x13_ = GEN_calculus ( 2, TYPEID_stack ) ;\
 439 
	calculus *x13_ = GEN_calculus(2, TYPEID_stack);\
456 
	x13_ [1].ag_ptr = ( A ) ;\
 440 
	x13_[1].ag_ptr = (A);\
457 
	x13_->ag_ptr = *r13_ ;\
 441 
	x13_->ag_ptr = *r13_;\
458 
	*r13_ = x13_ ;\
 442 
	*r13_ = x13_;\
459 
    }
 443 
    }
460 
 
 444 
 
461 
#define POP_stack( A, B )\
 445 
#define POP_stack(A, B)\
462 
    {\
 446 
    {\
463 
	calculus **r14_ = &( B ) ;\
 447 
	calculus **r14_ = &(B);\
464 
	calculus *x14_ = CHECK_NULL ( *r14_ ) ;\
 448 
	calculus *x14_ = CHECK_NULL(*r14_);\
465 
	( A ) = x14_ [1].ag_ptr ;\
 449 
	(A) = x14_[1].ag_ptr;\
466 
	*r14_ = x14_->ag_ptr ;\
 450 
	*r14_ = x14_->ag_ptr;\
467 
	destroy_calculus ( x14_, ( unsigned ) 2 ) ;\
 451 
	destroy_calculus(x14_, (unsigned)2);\
468 
    }
 452 
    }
469 
 
 453 
 
470 
 
 454 
 
471 
/* Definitions for sizes */
 455 
/* Definitions for sizes */
472 
 
 456 
 
473 
#define SCALE( A, B )			( ( A ) * ( int ) ( B ) )
 457 
#define SCALE(A, B)			((A)*(int)(B))
474 
 
 458 
 
475 
 
 459 
 
476 
/* Definitions for primitive int */
 460 
/* Definitions for primitive int */
477 
 
 461 
 
478 
#define SIZE_int			1
 462 
#define SIZE_int			1
479 
 
 463 
 
480 
#define COPY_int( A, B )		( CHECK_NULL ( A )->ag_prim_int = ( B ) )
 464 
#define COPY_int(A, B)			(CHECK_NULL(A)->ag_prim_int = (B))
481 
#define DEREF_int( A )			( CHECK_NULL ( A )->ag_prim_int )
 465 
#define DEREF_int(A)			(CHECK_NULL(A)->ag_prim_int)
482 
#define CONS_int( A, B, C )\
 466 
#define CONS_int(A, B, C)\
483 
    {\
 467 
    {\
484 
	calculus *x15_ = GEN_calculus ( 2, TYPEID_list ) ;\
 468 
	calculus *x15_ = GEN_calculus(2, TYPEID_list);\
485 
	COPY_int ( x15_ + 1, ( A ) ) ;\
 469 
	COPY_int(x15_ + 1, (A));\
486 
	x15_->ag_ptr = ( B ) ;\
 470 
	x15_->ag_ptr = (B);\
487 
	( C ) = x15_ ;\
 471 
	(C) = x15_;\
488 
    }
 472 
    }
489 
 
 473 
 
490 
#define UN_CONS_int( A, B, C )\
 474 
#define UN_CONS_int(A, B, C)\
491 
    {\
 475 
    {\
492 
	calculus *x16_ = CHECK_NULL ( C ) ;\
 476 
	calculus *x16_ = CHECK_NULL(C);\
493 
	( A ) = DEREF_int ( x16_ + 1 ) ;\
 477 
	(A) = DEREF_int(x16_ + 1);\
494 
	( B ) = x16_->ag_ptr ;\
 478 
	(B) = x16_->ag_ptr;\
495 
    }
 479 
    }
496 
 
 480 
 
497 
#define DESTROY_CONS_int( D, A, B, C )\
 481 
#define DESTROY_CONS_int(D, A, B, C)\
498 
    {\
 482 
    {\
499 
	calculus *x17_ = CHECK_NULL ( C ) ;\
 483 
	calculus *x17_ = CHECK_NULL(C);\
500 
	( A ) = DEREF_int ( x17_ + 1 ) ;\
 484 
	(A) = DEREF_int(x17_ + 1);\
501 
	( B ) = x17_->ag_ptr ;\
 485 
	(B) = x17_->ag_ptr;\
502 
	( D ) ( x17_, ( unsigned ) 2 ) ;\
 486 
	(D)(x17_, (unsigned)2);\
503 
    }
 487 
    }
504 
 
 488 
 
505 
#define PUSH_int( A, B )\
 489 
#define PUSH_int(A, B)\
506 
    {\
 490 
    {\
507 
	calculus **r18_ = &( B ) ;\
 491 
	calculus **r18_ = &(B);\
508 
	calculus *x18_ = GEN_calculus ( 2, TYPEID_stack ) ;\
 492 
	calculus *x18_ = GEN_calculus(2, TYPEID_stack);\
509 
	COPY_int ( x18_ + 1, ( A ) ) ;\
 493 
	COPY_int(x18_ + 1, (A));\
510 
	x18_->ag_ptr = *r18_ ;\
 494 
	x18_->ag_ptr = *r18_;\
511 
	*r18_ = x18_ ;\
 495 
	*r18_ = x18_;\
512 
    }
 496 
    }
513 
 
 497 
 
514 
#define POP_int( A, B )\
 498 
#define POP_int(A, B)\
515 
    {\
 499 
    {\
516 
	calculus **r19_ = &( B ) ;\
 500 
	calculus **r19_ = &(B);\
517 
	calculus *x19_ = CHECK_NULL ( *r19_ ) ;\
 501 
	calculus *x19_ = CHECK_NULL(*r19_);\
518 
	( A ) = DEREF_int ( x19_ + 1 ) ;\
 502 
	(A) = DEREF_int(x19_ + 1);\
519 
	*r19_ = x19_->ag_ptr ;\
 503 
	*r19_ = x19_->ag_ptr;\
520 
	destroy_calculus ( x19_, ( unsigned ) 2 ) ;\
 504 
	destroy_calculus(x19_, (unsigned)2);\
521 
    }
 505 
    }
522 
 
 506 
 
523 
 
 507 
 
524 
/* Definitions for primitive number */
 508 
/* Definitions for primitive number */
525 
 
 509 
 
526 
#define SIZE_number			1
 510 
#define SIZE_number			1
527 
 
 511 
 
528 
#define COPY_number( A, B )		( CHECK_NULL ( A )->ag_prim_number = ( B ) )
 512 
#define COPY_number(A, B)		(CHECK_NULL(A)->ag_prim_number = (B))
529 
#define DEREF_number( A )		( CHECK_NULL ( A )->ag_prim_number )
 513 
#define DEREF_number(A)			(CHECK_NULL(A)->ag_prim_number)
530 
#define CONS_number( A, B, C )\
 514 
#define CONS_number(A, B, C)\
531 
    {\
 515 
    {\
532 
	calculus *x20_ = GEN_calculus ( 2, TYPEID_list ) ;\
 516 
	calculus *x20_ = GEN_calculus(2, TYPEID_list);\
533 
	COPY_number ( x20_ + 1, ( A ) ) ;\
 517 
	COPY_number(x20_ + 1, (A));\
534 
	x20_->ag_ptr = ( B ) ;\
 518 
	x20_->ag_ptr = (B);\
535 
	( C ) = x20_ ;\
 519 
	(C) = x20_;\
536 
    }
 520 
    }
537 
 
 521 
 
538 
#define UN_CONS_number( A, B, C )\
 522 
#define UN_CONS_number(A, B, C)\
539 
    {\
 523 
    {\
540 
	calculus *x21_ = CHECK_NULL ( C ) ;\
 524 
	calculus *x21_ = CHECK_NULL(C);\
541 
	( A ) = DEREF_number ( x21_ + 1 ) ;\
 525 
	(A) = DEREF_number(x21_ + 1);\
542 
	( B ) = x21_->ag_ptr ;\
 526 
	(B) = x21_->ag_ptr;\
543 
    }
 527 
    }
544 
 
 528 
 
545 
#define DESTROY_CONS_number( D, A, B, C )\
 529 
#define DESTROY_CONS_number(D, A, B, C)\
546 
    {\
 530 
    {\
547 
	calculus *x22_ = CHECK_NULL ( C ) ;\
 531 
	calculus *x22_ = CHECK_NULL(C);\
548 
	( A ) = DEREF_number ( x22_ + 1 ) ;\
 532 
	(A) = DEREF_number(x22_ + 1);\
549 
	( B ) = x22_->ag_ptr ;\
 533 
	(B) = x22_->ag_ptr;\
550 
	( D ) ( x22_, ( unsigned ) 2 ) ;\
 534 
	(D)(x22_, (unsigned)2);\
551 
    }
 535 
    }
552 
 
 536 
 
553 
#define PUSH_number( A, B )\
 537 
#define PUSH_number(A, B)\
554 
    {\
 538 
    {\
555 
	calculus **r23_ = &( B ) ;\
 539 
	calculus **r23_ = &(B);\
556 
	calculus *x23_ = GEN_calculus ( 2, TYPEID_stack ) ;\
 540 
	calculus *x23_ = GEN_calculus(2, TYPEID_stack);\
557 
	COPY_number ( x23_ + 1, ( A ) ) ;\
 541 
	COPY_number(x23_ + 1, (A));\
558 
	x23_->ag_ptr = *r23_ ;\
 542 
	x23_->ag_ptr = *r23_;\
559 
	*r23_ = x23_ ;\
 543 
	*r23_ = x23_;\
560 
    }
 544 
    }
561 
 
 545 
 
562 
#define POP_number( A, B )\
 546 
#define POP_number(A, B)\
563 
    {\
 547 
    {\
564 
	calculus **r24_ = &( B ) ;\
 548 
	calculus **r24_ = &(B);\
565 
	calculus *x24_ = CHECK_NULL ( *r24_ ) ;\
 549 
	calculus *x24_ = CHECK_NULL(*r24_);\
566 
	( A ) = DEREF_number ( x24_ + 1 ) ;\
 550 
	(A) = DEREF_number(x24_ + 1);\
567 
	*r24_ = x24_->ag_ptr ;\
 551 
	*r24_ = x24_->ag_ptr;\
568 
	destroy_calculus ( x24_, ( unsigned ) 2 ) ;\
 552 
	destroy_calculus(x24_, (unsigned)2);\
569 
    }
 553 
    }
570 
 
 554 
 
571 
 
 555 
 
572 
/* Definitions for primitive string */
 556 
/* Definitions for primitive string */
573 
 
 557 
 
574 
#define SIZE_string			1
 558 
#define SIZE_string			1
575 
 
 559 
 
576 
#define COPY_string( A, B )		( CHECK_NULL ( A )->ag_prim_string = ( B ) )
 560 
#define COPY_string(A, B)		(CHECK_NULL(A)->ag_prim_string = (B))
577 
#define DEREF_string( A )		( CHECK_NULL ( A )->ag_prim_string )
 561 
#define DEREF_string(A)			(CHECK_NULL(A)->ag_prim_string)
578 
#define CONS_string( A, B, C )\
 562 
#define CONS_string(A, B, C)\
579 
    {\
 563 
    {\
580 
	calculus *x25_ = GEN_calculus ( 2, TYPEID_list ) ;\
 564 
	calculus *x25_ = GEN_calculus(2, TYPEID_list);\
581 
	COPY_string ( x25_ + 1, ( A ) ) ;\
 565 
	COPY_string(x25_ + 1, (A));\
582 
	x25_->ag_ptr = ( B ) ;\
 566 
	x25_->ag_ptr = (B);\
583 
	( C ) = x25_ ;\
 567 
	(C) = x25_;\
584 
    }
 568 
    }
585 
 
 569 
 
586 
#define UN_CONS_string( A, B, C )\
 570 
#define UN_CONS_string(A, B, C)\
587 
    {\
 571 
    {\
588 
	calculus *x26_ = CHECK_NULL ( C ) ;\
 572 
	calculus *x26_ = CHECK_NULL(C);\
589 
	( A ) = DEREF_string ( x26_ + 1 ) ;\
 573 
	(A) = DEREF_string(x26_ + 1);\
590 
	( B ) = x26_->ag_ptr ;\
 574 
	(B) = x26_->ag_ptr;\
591 
    }
 575 
    }
592 
 
 576 
 
593 
#define DESTROY_CONS_string( D, A, B, C )\
 577 
#define DESTROY_CONS_string(D, A, B, C)\
594 
    {\
 578 
    {\
595 
	calculus *x27_ = CHECK_NULL ( C ) ;\
 579 
	calculus *x27_ = CHECK_NULL(C);\
596 
	( A ) = DEREF_string ( x27_ + 1 ) ;\
 580 
	(A) = DEREF_string(x27_ + 1);\
597 
	( B ) = x27_->ag_ptr ;\
 581 
	(B) = x27_->ag_ptr;\
598 
	( D ) ( x27_, ( unsigned ) 2 ) ;\
 582 
	(D)(x27_, (unsigned)2);\
599 
    }
 583 
    }
600 
 
 584 
 
601 
#define PUSH_string( A, B )\
 585 
#define PUSH_string(A, B)\
602 
    {\
 586 
    {\
603 
	calculus **r28_ = &( B ) ;\
 587 
	calculus **r28_ = &(B);\
604 
	calculus *x28_ = GEN_calculus ( 2, TYPEID_stack ) ;\
 588 
	calculus *x28_ = GEN_calculus(2, TYPEID_stack);\
605 
	COPY_string ( x28_ + 1, ( A ) ) ;\
 589 
	COPY_string(x28_ + 1, (A));\
606 
	x28_->ag_ptr = *r28_ ;\
 590 
	x28_->ag_ptr = *r28_;\
607 
	*r28_ = x28_ ;\
 591 
	*r28_ = x28_;\
608 
    }
 592 
    }
609 
 
 593 
 
610 
#define POP_string( A, B )\
 594 
#define POP_string(A, B)\
611 
    {\
 595 
    {\
612 
	calculus **r29_ = &( B ) ;\
 596 
	calculus **r29_ = &(B);\
613 
	calculus *x29_ = CHECK_NULL ( *r29_ ) ;\
 597 
	calculus *x29_ = CHECK_NULL(*r29_);\
614 
	( A ) = DEREF_string ( x29_ + 1 ) ;\
 598 
	(A) = DEREF_string(x29_ + 1);\
615 
	*r29_ = x29_->ag_ptr ;\
 599 
	*r29_ = x29_->ag_ptr;\
616 
	destroy_calculus ( x29_, ( unsigned ) 2 ) ;\
 600 
	destroy_calculus(x29_, (unsigned)2);\
617 
    }
 601 
    }
618 
 
 602 
 
619 
 
 603 
 
620 
/* Definitions for structure ALGEBRA_DEFN */
 604 
/* Definitions for structure ALGEBRA_DEFN */
621 
 
 605 
 
622 
#define alg_name( P )			( ( P ) + 0 )
 606 
#define alg_name(P)			((P) + 0)
623 
#define alg_major_no( P )		( ( P ) + 1 )
 607 
#define alg_major_no(P)			((P) + 1)
624 
#define alg_minor_no( P )		( ( P ) + 2 )
 608 
#define alg_minor_no(P)			((P) + 2)
625 
#define alg_primitives( P )		( ( P ) + 3 )
 609 
#define alg_primitives(P)		((P) + 3)
626 
#define alg_identities( P )		( ( P ) + 4 )
 610 
#define alg_identities(P)		((P) + 4)
627 
#define alg_enumerations( P )		( ( P ) + 5 )
 611 
#define alg_enumerations(P)		((P) + 5)
628 
#define alg_structures( P )		( ( P ) + 6 )
 612 
#define alg_structures(P)		((P) + 6)
629 
#define alg_unions( P )			( ( P ) + 7 )
 613 
#define alg_unions(P)			((P) + 7)
630 
#define alg_types( P )			( ( P ) + 8 )
 614 
#define alg_types(P)			((P) + 8)
631 
#define SIZE_alg			9
 615 
#define SIZE_alg			9
632 
 
 616 
 
633 
#define COPY_alg( A, B )\
 617 
#define COPY_alg(A, B)\
634 
    {\
 618 
    {\
635 
	calculus *x30_ = CHECK_NULL ( A ) ;\
 619 
	calculus *x30_ = CHECK_NULL(A);\
636 
	ALGEBRA_DEFN y30_ ;\
 620 
	ALGEBRA_DEFN y30_;\
637 
	y30_ = ( B ) ;\
 621 
	y30_ = (B);\
638 
	COPY_string ( x30_ + 0, y30_.name ) ;\
 622 
	COPY_string(x30_ + 0, y30_.name);\
639 
	COPY_int ( x30_ + 1, y30_.major_no ) ;\
 623 
	COPY_int(x30_ + 1, y30_.major_no);\
640 
	COPY_int ( x30_ + 2, y30_.minor_no ) ;\
 624 
	COPY_int(x30_ + 2, y30_.minor_no);\
641 
	COPY_list ( x30_ + 3, y30_.primitives ) ;\
 625 
	COPY_list(x30_ + 3, y30_.primitives);\
642 
	COPY_list ( x30_ + 4, y30_.identities ) ;\
 626 
	COPY_list(x30_ + 4, y30_.identities);\
643 
	COPY_list ( x30_ + 5, y30_.enumerations ) ;\
 627 
	COPY_list(x30_ + 5, y30_.enumerations);\
644 
	COPY_list ( x30_ + 6, y30_.structures ) ;\
 628 
	COPY_list(x30_ + 6, y30_.structures);\
645 
	COPY_list ( x30_ + 7, y30_.unions ) ;\
 629 
	COPY_list(x30_ + 7, y30_.unions);\
646 
	COPY_list ( x30_ + 8, y30_.types ) ;\
 630 
	COPY_list(x30_ + 8, y30_.types);\
647 
    }
 631 
    }
648 
 
 632 
 
649 
#define DEREF_alg( A, B )\
 633 
#define DEREF_alg(A, B)\
650 
    {\
 634 
    {\
651 
	calculus *x31_ = CHECK_NULL ( A ) ;\
 635 
	calculus *x31_ = CHECK_NULL(A);\
652 
	ALGEBRA_DEFN *y31_ = &( B ) ;\
 636 
	ALGEBRA_DEFN *y31_ = &(B);\
653 
	y31_->name = DEREF_string ( x31_ + 0 ) ;\
 637 
	y31_->name = DEREF_string(x31_ + 0);\
654 
	y31_->major_no = DEREF_int ( x31_ + 1 ) ;\
 638 
	y31_->major_no = DEREF_int(x31_ + 1);\
655 
	y31_->minor_no = DEREF_int ( x31_ + 2 ) ;\
 639 
	y31_->minor_no = DEREF_int(x31_ + 2);\
656 
	y31_->primitives = DEREF_list ( x31_ + 3 ) ;\
 640 
	y31_->primitives = DEREF_list(x31_ + 3);\
657 
	y31_->identities = DEREF_list ( x31_ + 4 ) ;\
 641 
	y31_->identities = DEREF_list(x31_ + 4);\
658 
	y31_->enumerations = DEREF_list ( x31_ + 5 ) ;\
 642 
	y31_->enumerations = DEREF_list(x31_ + 5);\
659 
	y31_->structures = DEREF_list ( x31_ + 6 ) ;\
 643 
	y31_->structures = DEREF_list(x31_ + 6);\
660 
	y31_->unions = DEREF_list ( x31_ + 7 ) ;\
 644 
	y31_->unions = DEREF_list(x31_ + 7);\
661 
	y31_->types = DEREF_list ( x31_ + 8 ) ;\
 645 
	y31_->types = DEREF_list(x31_ + 8);\
662 
    }
 646 
    }
663 
 
 647 
 
664 
#define MAKE_alg( name_, major_no_, minor_no_, primitives_, identities_, enumerations_, structures_, unions_, types_, alg_ )\
 648 
#define MAKE_alg(name_, major_no_, minor_no_, primitives_, identities_, enumerations_, structures_, unions_, types_, alg_)\
665 
    {\
 649 
    {\
666 
	calculus *x32_ = CHECK_NULL ( alg_ ) ;\
 650 
	calculus *x32_ = CHECK_NULL(alg_);\
667 
	COPY_string ( x32_ + 0, ( name_ ) ) ;\
 651 
	COPY_string(x32_ + 0, (name_));\
668 
	COPY_int ( x32_ + 1, ( major_no_ ) ) ;\
 652 
	COPY_int(x32_ + 1, (major_no_));\
669 
	COPY_int ( x32_ + 2, ( minor_no_ ) ) ;\
 653 
	COPY_int(x32_ + 2, (minor_no_));\
670 
	COPY_list ( x32_ + 3, ( primitives_ ) ) ;\
 654 
	COPY_list(x32_ + 3, (primitives_));\
671 
	COPY_list ( x32_ + 4, ( identities_ ) ) ;\
 655 
	COPY_list(x32_ + 4, (identities_));\
672 
	COPY_list ( x32_ + 5, ( enumerations_ ) ) ;\
 656 
	COPY_list(x32_ + 5, (enumerations_));\
673 
	COPY_list ( x32_ + 6, ( structures_ ) ) ;\
 657 
	COPY_list(x32_ + 6, (structures_));\
674 
	COPY_list ( x32_ + 7, ( unions_ ) ) ;\
 658 
	COPY_list(x32_ + 7, (unions_));\
675 
	COPY_list ( x32_ + 8, ( types_ ) ) ;\
 659 
	COPY_list(x32_ + 8, (types_));\
676 
    }
 660 
    }
677 
 
 661 
 
678 
#define CONS_alg( A, B, C )\
 662 
#define CONS_alg(A, B, C)\
679 
    {\
 663 
    {\
680 
	calculus *x33_ = GEN_calculus ( 10, TYPEID_list ) ;\
 664 
	calculus *x33_ = GEN_calculus(10, TYPEID_list);\
681 
	COPY_alg ( x33_ + 1, ( A ) ) ;\
 665 
	COPY_alg(x33_ + 1, (A));\
682 
	x33_->ag_ptr = ( B ) ;\
 666 
	x33_->ag_ptr = (B);\
683 
	( C ) = x33_ ;\
 667 
	(C) = x33_;\
684 
    }
 668 
    }
685 
 
 669 
 
686 
#define UN_CONS_alg( A, B, C )\
 670 
#define UN_CONS_alg(A, B, C)\
687 
    {\
 671 
    {\
688 
	calculus *x34_ = CHECK_NULL ( C ) ;\
 672 
	calculus *x34_ = CHECK_NULL(C);\
689 
	DEREF_alg ( x34_ + 1, ( A ) ) ;\
 673 
	DEREF_alg(x34_ + 1, (A));\
690 
	( B ) = x34_->ag_ptr ;\
 674 
	(B) = x34_->ag_ptr;\
691 
    }
 675 
    }
692 
 
 676 
 
693 
#define DESTROY_CONS_alg( D, A, B, C )\
 677 
#define DESTROY_CONS_alg(D, A, B, C)\
694 
    {\
 678 
    {\
695 
	calculus *x35_ = CHECK_NULL ( C ) ;\
 679 
	calculus *x35_ = CHECK_NULL(C);\
696 
	DEREF_alg ( x35_ + 1, ( A ) ) ;\
 680 
	DEREF_alg(x35_ + 1, (A));\
697 
	( B ) = x35_->ag_ptr ;\
 681 
	(B) = x35_->ag_ptr;\
698 
	( D ) ( x35_, ( unsigned ) 10 ) ;\
 682 
	(D)(x35_, (unsigned)10);\
699 
    }
 683 
    }
700 
 
 684 
 
701 
#define PUSH_alg( A, B )\
 685 
#define PUSH_alg(A, B)\
702 
    {\
 686 
    {\
703 
	calculus **r36_ = &( B ) ;\
 687 
	calculus **r36_ = &(B);\
704 
	calculus *x36_ = GEN_calculus ( 10, TYPEID_stack ) ;\
 688 
	calculus *x36_ = GEN_calculus(10, TYPEID_stack);\
705 
	COPY_alg ( x36_ + 1, ( A ) ) ;\
 689 
	COPY_alg(x36_ + 1, (A));\
706 
	x36_->ag_ptr = *r36_ ;\
 690 
	x36_->ag_ptr = *r36_;\
707 
	*r36_ = x36_ ;\
 691 
	*r36_ = x36_;\
708 
    }
 692 
    }
709 
 
 693 
 
710 
#define POP_alg( A, B )\
 694 
#define POP_alg(A, B)\
711 
    {\
 695 
    {\
712 
	calculus **r37_ = &( B ) ;\
 696 
	calculus **r37_ = &(B);\
713 
	calculus *x37_ = CHECK_NULL ( *r37_ ) ;\
 697 
	calculus *x37_ = CHECK_NULL(*r37_);\
714 
	DEREF_alg ( x37_ + 1, ( A ) ) ;\
 698 
	DEREF_alg(x37_ + 1, (A));\
715 
	*r37_ = x37_->ag_ptr ;\
 699 
	*r37_ = x37_->ag_ptr;\
716 
	destroy_calculus ( x37_, ( unsigned ) 10 ) ;\
 700 
	destroy_calculus(x37_, (unsigned)10);\
717 
    }
 701 
    }
718 
 
 702 
 
719 
 
 703 
 
720 
/* Definitions for structure CLASS_ID */
 704 
/* Definitions for structure CLASS_ID */
721 
 
 705 
 
722 
#define cid_name( P )			( ( P ) + 0 )
 706 
#define cid_name(P)			((P) + 0)
723 
#define cid_name_aux( P )		( ( P ) + 1 )
 707 
#define cid_name_aux(P)			((P) + 1)
724 
#define cid_flag( P )			( ( P ) + 2 )
 708 
#define cid_flag(P)			((P) + 2)
725 
#define cid_file( P )			( ( P ) + 3 )
 709 
#define cid_file(P)			((P) + 3)
726 
#define cid_line( P )			( ( P ) + 4 )
 710 
#define cid_line(P)			((P) + 4)
727 
#define SIZE_cid			5
 711 
#define SIZE_cid			5
728 
 
 712 
 
729 
#define COPY_cid( A, B )\
 713 
#define COPY_cid(A, B)\
730 
    {\
 714 
    {\
731 
	calculus *x38_ = CHECK_NULL ( A ) ;\
 715 
	calculus *x38_ = CHECK_NULL(A);\
732 
	CLASS_ID y38_ ;\
 716 
	CLASS_ID y38_;\
733 
	y38_ = ( B ) ;\
 717 
	y38_ = (B);\
734 
	COPY_string ( x38_ + 0, y38_.name ) ;\
 718 
	COPY_string(x38_ + 0, y38_.name);\
735 
	COPY_string ( x38_ + 1, y38_.name_aux ) ;\
 719 
	COPY_string(x38_ + 1, y38_.name_aux);\
736 
	COPY_int ( x38_ + 2, y38_.flag ) ;\
 720 
	COPY_int(x38_ + 2, y38_.flag);\
737 
	COPY_string ( x38_ + 3, y38_.file ) ;\
 721 
	COPY_string(x38_ + 3, y38_.file);\
738 
	COPY_int ( x38_ + 4, y38_.line ) ;\
 722 
	COPY_int(x38_ + 4, y38_.line);\
739 
    }
 723 
    }
740 
 
 724 
 
741 
#define DEREF_cid( A, B )\
 725 
#define DEREF_cid(A, B)\
742 
    {\
 726 
    {\
743 
	calculus *x39_ = CHECK_NULL ( A ) ;\
 727 
	calculus *x39_ = CHECK_NULL(A);\
744 
	CLASS_ID *y39_ = &( B ) ;\
 728 
	CLASS_ID *y39_ = &(B);\
745 
	y39_->name = DEREF_string ( x39_ + 0 ) ;\
 729 
	y39_->name = DEREF_string(x39_ + 0);\
746 
	y39_->name_aux = DEREF_string ( x39_ + 1 ) ;\
 730 
	y39_->name_aux = DEREF_string(x39_ + 1);\
747 
	y39_->flag = DEREF_int ( x39_ + 2 ) ;\
 731 
	y39_->flag = DEREF_int(x39_ + 2);\
748 
	y39_->file = DEREF_string ( x39_ + 3 ) ;\
 732 
	y39_->file = DEREF_string(x39_ + 3);\
749 
	y39_->line = DEREF_int ( x39_ + 4 ) ;\
 733 
	y39_->line = DEREF_int(x39_ + 4);\
750 
    }
 734 
    }
751 
 
 735 
 
752 
#define MAKE_cid( name_, name_aux_, flag_, file_, line_, cid_ )\
 736 
#define MAKE_cid(name_, name_aux_, flag_, file_, line_, cid_)\
753 
    {\
 737 
    {\
754 
	calculus *x40_ = CHECK_NULL ( cid_ ) ;\
 738 
	calculus *x40_ = CHECK_NULL(cid_);\
755 
	COPY_string ( x40_ + 0, ( name_ ) ) ;\
 739 
	COPY_string(x40_ + 0, (name_));\
756 
	COPY_string ( x40_ + 1, ( name_aux_ ) ) ;\
 740 
	COPY_string(x40_ + 1, (name_aux_));\
757 
	COPY_int ( x40_ + 2, ( flag_ ) ) ;\
 741 
	COPY_int(x40_ + 2, (flag_));\
758 
	COPY_string ( x40_ + 3, ( file_ ) ) ;\
 742 
	COPY_string(x40_ + 3, (file_));\
759 
	COPY_int ( x40_ + 4, ( line_ ) ) ;\
 743 
	COPY_int(x40_ + 4, (line_));\
760 
    }
 744 
    }
761 
 
 745 
 
762 
#define CONS_cid( A, B, C )\
 746 
#define CONS_cid(A, B, C)\
763 
    {\
 747 
    {\
764 
	calculus *x41_ = GEN_calculus ( 6, TYPEID_list ) ;\
 748 
	calculus *x41_ = GEN_calculus(6, TYPEID_list);\
765 
	COPY_cid ( x41_ + 1, ( A ) ) ;\
 749 
	COPY_cid(x41_ + 1, (A));\
766 
	x41_->ag_ptr = ( B ) ;\
 750 
	x41_->ag_ptr = (B);\
767 
	( C ) = x41_ ;\
 751 
	(C) = x41_;\
768 
    }
 752 
    }
769 
 
 753 
 
770 
#define UN_CONS_cid( A, B, C )\
 754 
#define UN_CONS_cid(A, B, C)\
771 
    {\
 755 
    {\
772 
	calculus *x42_ = CHECK_NULL ( C ) ;\
 756 
	calculus *x42_ = CHECK_NULL(C);\
773 
	DEREF_cid ( x42_ + 1, ( A ) ) ;\
 757 
	DEREF_cid(x42_ + 1, (A));\
774 
	( B ) = x42_->ag_ptr ;\
 758 
	(B) = x42_->ag_ptr;\
775 
    }
 759 
    }
776 
 
 760 
 
777 
#define DESTROY_CONS_cid( D, A, B, C )\
 761 
#define DESTROY_CONS_cid(D, A, B, C)\
778 
    {\
 762 
    {\
779 
	calculus *x43_ = CHECK_NULL ( C ) ;\
 763 
	calculus *x43_ = CHECK_NULL(C);\
780 
	DEREF_cid ( x43_ + 1, ( A ) ) ;\
 764 
	DEREF_cid(x43_ + 1, (A));\
781 
	( B ) = x43_->ag_ptr ;\
 765 
	(B) = x43_->ag_ptr;\
782 
	( D ) ( x43_, ( unsigned ) 6 ) ;\
 766 
	(D)(x43_, (unsigned)6);\
783 
    }
 767 
    }
784 
 
 768 
 
785 
#define PUSH_cid( A, B )\
 769 
#define PUSH_cid(A, B)\
786 
    {\
 770 
    {\
787 
	calculus **r44_ = &( B ) ;\
 771 
	calculus **r44_ = &(B);\
788 
	calculus *x44_ = GEN_calculus ( 6, TYPEID_stack ) ;\
 772 
	calculus *x44_ = GEN_calculus(6, TYPEID_stack);\
789 
	COPY_cid ( x44_ + 1, ( A ) ) ;\
 773 
	COPY_cid(x44_ + 1, (A));\
790 
	x44_->ag_ptr = *r44_ ;\
 774 
	x44_->ag_ptr = *r44_;\
791 
	*r44_ = x44_ ;\
 775 
	*r44_ = x44_;\
792 
    }
 776 
    }
793 
 
 777 
 
794 
#define POP_cid( A, B )\
 778 
#define POP_cid(A, B)\
795 
    {\
 779 
    {\
796 
	calculus **r45_ = &( B ) ;\
 780 
	calculus **r45_ = &(B);\
797 
	calculus *x45_ = CHECK_NULL ( *r45_ ) ;\
 781 
	calculus *x45_ = CHECK_NULL(*r45_);\
798 
	DEREF_cid ( x45_ + 1, ( A ) ) ;\
 782 
	DEREF_cid(x45_ + 1, (A));\
799 
	*r45_ = x45_->ag_ptr ;\
 783 
	*r45_ = x45_->ag_ptr;\
800 
	destroy_calculus ( x45_, ( unsigned ) 6 ) ;\
 784 
	destroy_calculus(x45_, (unsigned)6);\
801 
    }
 785 
    }
802 
 
 786 
 
803 
 
 787 
 
804 
/* Definitions for structure PRIMITIVE */
 788 
/* Definitions for structure PRIMITIVE */
805 
 
 789 
 
806 
#define prim_id( P )			( ( P ) + 0 )
 790 
#define prim_id(P)			((P) + 0)
807 
#define prim_defn( P )			( ( P ) + 1 )
 791 
#define prim_defn(P)			((P) + 1)
808 
#define SIZE_prim			2
 792 
#define SIZE_prim			2
809 
 
 793 
 
810 
#define COPY_prim( A, B )\
 794 
#define COPY_prim(A, B)\
811 
    {\
 795 
    {\
812 
	calculus *x46_ = CHECK_NULL ( A ) ;\
 796 
	calculus *x46_ = CHECK_NULL(A);\
813 
	PRIMITIVE y46_ ;\
 797 
	PRIMITIVE y46_;\
814 
	y46_ = ( B ) ;\
 798 
	y46_ = (B);\
815 
	COPY_ptr ( x46_ + 0, y46_.id ) ;\
 799 
	COPY_ptr(x46_ + 0, y46_.id);\
816 
	COPY_string ( x46_ + 1, y46_.defn ) ;\
 800 
	COPY_string(x46_ + 1, y46_.defn);\
817 
    }
 801 
    }
818 
 
 802 
 
819 
#define DEREF_prim( A, B )\
 803 
#define DEREF_prim(A, B)\
820 
    {\
 804 
    {\
821 
	calculus *x47_ = CHECK_NULL ( A ) ;\
 805 
	calculus *x47_ = CHECK_NULL(A);\
822 
	PRIMITIVE *y47_ = &( B ) ;\
 806 
	PRIMITIVE *y47_ = &(B);\
823 
	y47_->id = DEREF_ptr ( x47_ + 0 ) ;\
 807 
	y47_->id = DEREF_ptr(x47_ + 0);\
824 
	y47_->defn = DEREF_string ( x47_ + 1 ) ;\
 808 
	y47_->defn = DEREF_string(x47_ + 1);\
825 
    }
 809 
    }
826 
 
 810 
 
827 
#define MAKE_prim( id_, defn_, prim_ )\
 811 
#define MAKE_prim(id_, defn_, prim_)\
828 
    {\
 812 
    {\
829 
	calculus *x48_ = CHECK_NULL ( prim_ ) ;\
 813 
	calculus *x48_ = CHECK_NULL(prim_);\
830 
	COPY_ptr ( x48_ + 0, ( id_ ) ) ;\
 814 
	COPY_ptr(x48_ + 0, (id_));\
831 
	COPY_string ( x48_ + 1, ( defn_ ) ) ;\
 815 
	COPY_string(x48_ + 1, (defn_));\
832 
    }
 816 
    }
833 
 
 817 
 
834 
#define CONS_prim( A, B, C )\
 818 
#define CONS_prim(A, B, C)\
835 
    {\
 819 
    {\
836 
	calculus *x49_ = GEN_calculus ( 3, TYPEID_list ) ;\
 820 
	calculus *x49_ = GEN_calculus(3, TYPEID_list);\
837 
	COPY_prim ( x49_ + 1, ( A ) ) ;\
 821 
	COPY_prim(x49_ + 1, (A));\
838 
	x49_->ag_ptr = ( B ) ;\
 822 
	x49_->ag_ptr = (B);\
839 
	( C ) = x49_ ;\
 823 
	(C) = x49_;\
840 
    }
 824 
    }
841 
 
 825 
 
842 
#define UN_CONS_prim( A, B, C )\
 826 
#define UN_CONS_prim(A, B, C)\
843 
    {\
 827 
    {\
844 
	calculus *x50_ = CHECK_NULL ( C ) ;\
 828 
	calculus *x50_ = CHECK_NULL(C);\
845 
	DEREF_prim ( x50_ + 1, ( A ) ) ;\
 829 
	DEREF_prim(x50_ + 1, (A));\
846 
	( B ) = x50_->ag_ptr ;\
 830 
	(B) = x50_->ag_ptr;\
847 
    }
 831 
    }
848 
 
 832 
 
849 
#define DESTROY_CONS_prim( D, A, B, C )\
 833 
#define DESTROY_CONS_prim(D, A, B, C)\
850 
    {\
 834 
    {\
851 
	calculus *x51_ = CHECK_NULL ( C ) ;\
 835 
	calculus *x51_ = CHECK_NULL(C);\
852 
	DEREF_prim ( x51_ + 1, ( A ) ) ;\
 836 
	DEREF_prim(x51_ + 1, (A));\
853 
	( B ) = x51_->ag_ptr ;\
 837 
	(B) = x51_->ag_ptr;\
854 
	( D ) ( x51_, ( unsigned ) 3 ) ;\
 838 
	(D)(x51_, (unsigned)3);\
855 
    }
 839 
    }
856 
 
 840 
 
857 
#define PUSH_prim( A, B )\
 841 
#define PUSH_prim(A, B)\
858 
    {\
 842 
    {\
859 
	calculus **r52_ = &( B ) ;\
 843 
	calculus **r52_ = &(B);\
860 
	calculus *x52_ = GEN_calculus ( 3, TYPEID_stack ) ;\
 844 
	calculus *x52_ = GEN_calculus(3, TYPEID_stack);\
861 
	COPY_prim ( x52_ + 1, ( A ) ) ;\
 845 
	COPY_prim(x52_ + 1, (A));\
862 
	x52_->ag_ptr = *r52_ ;\
 846 
	x52_->ag_ptr = *r52_;\
863 
	*r52_ = x52_ ;\
 847 
	*r52_ = x52_;\
864 
    }
 848 
    }
865 
 
 849 
 
866 
#define POP_prim( A, B )\
 850 
#define POP_prim(A, B)\
867 
    {\
 851 
    {\
868 
	calculus **r53_ = &( B ) ;\
 852 
	calculus **r53_ = &(B);\
869 
	calculus *x53_ = CHECK_NULL ( *r53_ ) ;\
 853 
	calculus *x53_ = CHECK_NULL(*r53_);\
870 
	DEREF_prim ( x53_ + 1, ( A ) ) ;\
 854 
	DEREF_prim(x53_ + 1, (A));\
871 
	*r53_ = x53_->ag_ptr ;\
 855 
	*r53_ = x53_->ag_ptr;\
872 
	destroy_calculus ( x53_, ( unsigned ) 3 ) ;\
 856 
	destroy_calculus(x53_, (unsigned)3);\
873 
    }
 857 
    }
874 
 
 858 
 
875 
 
 859 
 
876 
/* Definitions for structure ECONST */
 860 
/* Definitions for structure ECONST */
877 
 
 861 
 
878 
#define ec_name( P )			( ( P ) + 0 )
 862 
#define ec_name(P)			((P) + 0)
879 
#define ec_value( P )			( ( P ) + 1 )
 863 
#define ec_value(P)			((P) + 1)
880 
#define SIZE_ec				2
 864 
#define SIZE_ec				2
881 
 
 865 
 
882 
#define COPY_ec( A, B )\
 866 
#define COPY_ec(A, B)\
883 
    {\
 867 
    {\
884 
	calculus *x54_ = CHECK_NULL ( A ) ;\
 868 
	calculus *x54_ = CHECK_NULL(A);\
885 
	ECONST y54_ ;\
 869 
	ECONST y54_;\
886 
	y54_ = ( B ) ;\
 870 
	y54_ = (B);\
887 
	COPY_string ( x54_ + 0, y54_.name ) ;\
 871 
	COPY_string(x54_ + 0, y54_.name);\
888 
	COPY_number ( x54_ + 1, y54_.value ) ;\
 872 
	COPY_number(x54_ + 1, y54_.value);\
889 
    }
 873 
    }
890 
 
 874 
 
891 
#define DEREF_ec( A, B )\
 875 
#define DEREF_ec(A, B)\
892 
    {\
 876 
    {\
893 
	calculus *x55_ = CHECK_NULL ( A ) ;\
 877 
	calculus *x55_ = CHECK_NULL(A);\
894 
	ECONST *y55_ = &( B ) ;\
 878 
	ECONST *y55_ = &(B);\
895 
	y55_->name = DEREF_string ( x55_ + 0 ) ;\
 879 
	y55_->name = DEREF_string(x55_ + 0);\
896 
	y55_->value = DEREF_number ( x55_ + 1 ) ;\
 880 
	y55_->value = DEREF_number(x55_ + 1);\
897 
    }
 881 
    }
898 
 
 882 
 
899 
#define MAKE_ec( name_, value_, ec_ )\
 883 
#define MAKE_ec(name_, value_, ec_)\
900 
    {\
 884 
    {\
901 
	calculus *x56_ = CHECK_NULL ( ec_ ) ;\
 885 
	calculus *x56_ = CHECK_NULL(ec_);\
902 
	COPY_string ( x56_ + 0, ( name_ ) ) ;\
 886 
	COPY_string(x56_ + 0, (name_));\
903 
	COPY_number ( x56_ + 1, ( value_ ) ) ;\
 887 
	COPY_number(x56_ + 1, (value_));\
904 
    }
 888 
    }
905 
 
 889 
 
906 
#define CONS_ec( A, B, C )\
 890 
#define CONS_ec(A, B, C)\
907 
    {\
 891 
    {\
908 
	calculus *x57_ = GEN_calculus ( 3, TYPEID_list ) ;\
 892 
	calculus *x57_ = GEN_calculus(3, TYPEID_list);\
909 
	COPY_ec ( x57_ + 1, ( A ) ) ;\
 893 
	COPY_ec(x57_ + 1, (A));\
910 
	x57_->ag_ptr = ( B ) ;\
 894 
	x57_->ag_ptr = (B);\
911 
	( C ) = x57_ ;\
 895 
	(C) = x57_;\
912 
    }
 896 
    }
913 
 
 897 
 
914 
#define UN_CONS_ec( A, B, C )\
 898 
#define UN_CONS_ec(A, B, C)\
915 
    {\
 899 
    {\
916 
	calculus *x58_ = CHECK_NULL ( C ) ;\
 900 
	calculus *x58_ = CHECK_NULL(C);\
917 
	DEREF_ec ( x58_ + 1, ( A ) ) ;\
 901 
	DEREF_ec(x58_ + 1, (A));\
918 
	( B ) = x58_->ag_ptr ;\
 902 
	(B) = x58_->ag_ptr;\
919 
    }
 903 
    }
920 
 
 904 
 
921 
#define DESTROY_CONS_ec( D, A, B, C )\
 905 
#define DESTROY_CONS_ec(D, A, B, C)\
922 
    {\
 906 
    {\
923 
	calculus *x59_ = CHECK_NULL ( C ) ;\
 907 
	calculus *x59_ = CHECK_NULL(C);\
924 
	DEREF_ec ( x59_ + 1, ( A ) ) ;\
 908 
	DEREF_ec(x59_ + 1, (A));\
925 
	( B ) = x59_->ag_ptr ;\
 909 
	(B) = x59_->ag_ptr;\
926 
	( D ) ( x59_, ( unsigned ) 3 ) ;\
 910 
	(D)(x59_, (unsigned)3);\
927 
    }
 911 
    }
928 
 
 912 
 
929 
#define PUSH_ec( A, B )\
 913 
#define PUSH_ec(A, B)\
930 
    {\
 914 
    {\
931 
	calculus **r60_ = &( B ) ;\
 915 
	calculus **r60_ = &(B);\
932 
	calculus *x60_ = GEN_calculus ( 3, TYPEID_stack ) ;\
 916 
	calculus *x60_ = GEN_calculus(3, TYPEID_stack);\
933 
	COPY_ec ( x60_ + 1, ( A ) ) ;\
 917 
	COPY_ec(x60_ + 1, (A));\
934 
	x60_->ag_ptr = *r60_ ;\
 918 
	x60_->ag_ptr = *r60_;\
935 
	*r60_ = x60_ ;\
 919 
	*r60_ = x60_;\
936 
    }
 920 
    }
937 
 
 921 
 
938 
#define POP_ec( A, B )\
 922 
#define POP_ec(A, B)\
939 
    {\
 923 
    {\
940 
	calculus **r61_ = &( B ) ;\
 924 
	calculus **r61_ = &(B);\
941 
	calculus *x61_ = CHECK_NULL ( *r61_ ) ;\
 925 
	calculus *x61_ = CHECK_NULL(*r61_);\
942 
	DEREF_ec ( x61_ + 1, ( A ) ) ;\
 926 
	DEREF_ec(x61_ + 1, (A));\
943 
	*r61_ = x61_->ag_ptr ;\
 927 
	*r61_ = x61_->ag_ptr;\
944 
	destroy_calculus ( x61_, ( unsigned ) 3 ) ;\
 928 
	destroy_calculus(x61_, (unsigned)3);\
945 
    }
 929 
    }
946 
 
 930 
 
947 
 
 931 
 
948 
/* Definitions for structure ENUM */
 932 
/* Definitions for structure ENUM */
949 
 
 933 
 
950 
#define en_id( P )			( ( P ) + 0 )
 934 
#define en_id(P)			((P) + 0)
951 
#define en_consts( P )			( ( P ) + 1 )
 935 
#define en_consts(P)			((P) + 1)
952 
#define en_order( P )			( ( P ) + 2 )
 936 
#define en_order(P)			((P) + 2)
953 
#define en_lists( P )			( ( P ) + 3 )
 937 
#define en_lists(P)			((P) + 3)
954 
#define SIZE_en				4
 938 
#define SIZE_en				4
955 
 
 939 
 
956 
#define COPY_en( A, B )\
 940 
#define COPY_en(A, B)\
957 
    {\
 941 
    {\
958 
	calculus *x62_ = CHECK_NULL ( A ) ;\
 942 
	calculus *x62_ = CHECK_NULL(A);\
959 
	ENUM y62_ ;\
 943 
	ENUM y62_;\
960 
	y62_ = ( B ) ;\
 944 
	y62_ = (B);\
961 
	COPY_ptr ( x62_ + 0, y62_.id ) ;\
 945 
	COPY_ptr(x62_ + 0, y62_.id);\
962 
	COPY_list ( x62_ + 1, y62_.consts ) ;\
 946 
	COPY_list(x62_ + 1, y62_.consts);\
963 
	COPY_number ( x62_ + 2, y62_.order ) ;\
 947 
	COPY_number(x62_ + 2, y62_.order);\
964 
	COPY_int ( x62_ + 3, y62_.lists ) ;\
 948 
	COPY_int(x62_ + 3, y62_.lists);\
965 
    }
 949 
    }
966 
 
 950 
 
967 
#define DEREF_en( A, B )\
 951 
#define DEREF_en(A, B)\
968 
    {\
 952 
    {\
969 
	calculus *x63_ = CHECK_NULL ( A ) ;\
 953 
	calculus *x63_ = CHECK_NULL(A);\
970 
	ENUM *y63_ = &( B ) ;\
 954 
	ENUM *y63_ = &(B);\
971 
	y63_->id = DEREF_ptr ( x63_ + 0 ) ;\
 955 
	y63_->id = DEREF_ptr(x63_ + 0);\
972 
	y63_->consts = DEREF_list ( x63_ + 1 ) ;\
 956 
	y63_->consts = DEREF_list(x63_ + 1);\
973 
	y63_->order = DEREF_number ( x63_ + 2 ) ;\
 957 
	y63_->order = DEREF_number(x63_ + 2);\
974 
	y63_->lists = DEREF_int ( x63_ + 3 ) ;\
 958 
	y63_->lists = DEREF_int(x63_ + 3);\
975 
    }
 959 
    }
976 
 
 960 
 
977 
#define MAKE_en( id_, consts_, order_, lists_, en_ )\
 961 
#define MAKE_en(id_, consts_, order_, lists_, en_)\
978 
    {\
 962 
    {\
979 
	calculus *x64_ = CHECK_NULL ( en_ ) ;\
 963 
	calculus *x64_ = CHECK_NULL(en_);\
980 
	COPY_ptr ( x64_ + 0, ( id_ ) ) ;\
 964 
	COPY_ptr(x64_ + 0, (id_));\
981 
	COPY_list ( x64_ + 1, ( consts_ ) ) ;\
 965 
	COPY_list(x64_ + 1, (consts_));\
982 
	COPY_number ( x64_ + 2, ( order_ ) ) ;\
 966 
	COPY_number(x64_ + 2, (order_));\
983 
	COPY_int ( x64_ + 3, ( lists_ ) ) ;\
 967 
	COPY_int(x64_ + 3, (lists_));\
984 
    }
 968 
    }
985 
 
 969 
 
986 
#define CONS_en( A, B, C )\
 970 
#define CONS_en(A, B, C)\
987 
    {\
 971 
    {\
988 
	calculus *x65_ = GEN_calculus ( 5, TYPEID_list ) ;\
 972 
	calculus *x65_ = GEN_calculus(5, TYPEID_list);\
989 
	COPY_en ( x65_ + 1, ( A ) ) ;\
 973 
	COPY_en(x65_ + 1, (A));\
990 
	x65_->ag_ptr = ( B ) ;\
 974 
	x65_->ag_ptr = (B);\
991 
	( C ) = x65_ ;\
 975 
	(C) = x65_;\
992 
    }
 976 
    }
993 
 
 977 
 
994 
#define UN_CONS_en( A, B, C )\
 978 
#define UN_CONS_en(A, B, C)\
995 
    {\
 979 
    {\
996 
	calculus *x66_ = CHECK_NULL ( C ) ;\
 980 
	calculus *x66_ = CHECK_NULL(C);\
997 
	DEREF_en ( x66_ + 1, ( A ) ) ;\
 981 
	DEREF_en(x66_ + 1, (A));\
998 
	( B ) = x66_->ag_ptr ;\
 982 
	(B) = x66_->ag_ptr;\
999 
    }
 983 
    }
1000 
 
 984 
 
1001 
#define DESTROY_CONS_en( D, A, B, C )\
 985 
#define DESTROY_CONS_en(D, A, B, C)\
1002 
    {\
 986 
    {\
1003 
	calculus *x67_ = CHECK_NULL ( C ) ;\
 987 
	calculus *x67_ = CHECK_NULL(C);\
1004 
	DEREF_en ( x67_ + 1, ( A ) ) ;\
 988 
	DEREF_en(x67_ + 1, (A));\
1005 
	( B ) = x67_->ag_ptr ;\
 989 
	(B) = x67_->ag_ptr;\
1006 
	( D ) ( x67_, ( unsigned ) 5 ) ;\
 990 
	(D)(x67_, (unsigned)5);\
1007 
    }
 991 
    }
1008 
 
 992 
 
1009 
#define PUSH_en( A, B )\
 993 
#define PUSH_en(A, B)\
1010 
    {\
 994 
    {\
1011 
	calculus **r68_ = &( B ) ;\
 995 
	calculus **r68_ = &(B);\
1012 
	calculus *x68_ = GEN_calculus ( 5, TYPEID_stack ) ;\
 996 
	calculus *x68_ = GEN_calculus(5, TYPEID_stack);\
1013 
	COPY_en ( x68_ + 1, ( A ) ) ;\
 997 
	COPY_en(x68_ + 1, (A));\
1014 
	x68_->ag_ptr = *r68_ ;\
 998 
	x68_->ag_ptr = *r68_;\
1015 
	*r68_ = x68_ ;\
 999 
	*r68_ = x68_;\
1016 
    }
 1000 
    }
1017 
 
 1001 
 
1018 
#define POP_en( A, B )\
 1002 
#define POP_en(A, B)\
1019 
    {\
 1003 
    {\
1020 
	calculus **r69_ = &( B ) ;\
 1004 
	calculus **r69_ = &(B);\
1021 
	calculus *x69_ = CHECK_NULL ( *r69_ ) ;\
 1005 
	calculus *x69_ = CHECK_NULL(*r69_);\
1022 
	DEREF_en ( x69_ + 1, ( A ) ) ;\
 1006 
	DEREF_en(x69_ + 1, (A));\
1023 
	*r69_ = x69_->ag_ptr ;\
 1007 
	*r69_ = x69_->ag_ptr;\
1024 
	destroy_calculus ( x69_, ( unsigned ) 5 ) ;\
 1008 
	destroy_calculus(x69_, (unsigned)5);\
1025 
    }
 1009 
    }
1026 
 
 1010 
 
1027 
 
 1011 
 
1028 
/* Definitions for structure IDENTITY */
 1012 
/* Definitions for structure IDENTITY */
1029 
 
 1013 
 
1030 
#define ident_id( P )			( ( P ) + 0 )
 1014 
#define ident_id(P)			((P) + 0)
1031 
#define ident_defn( P )			( ( P ) + 1 )
 1015 
#define ident_defn(P)			((P) + 1)
1032 
#define SIZE_ident			2
 1016 
#define SIZE_ident			2
1033 
 
 1017 
 
1034 
#define COPY_ident( A, B )\
 1018 
#define COPY_ident(A, B)\
1035 
    {\
 1019 
    {\
1036 
	calculus *x70_ = CHECK_NULL ( A ) ;\
 1020 
	calculus *x70_ = CHECK_NULL(A);\
1037 
	IDENTITY y70_ ;\
 1021 
	IDENTITY y70_;\
1038 
	y70_ = ( B ) ;\
 1022 
	y70_ = (B);\
1039 
	COPY_ptr ( x70_ + 0, y70_.id ) ;\
 1023 
	COPY_ptr(x70_ + 0, y70_.id);\
1040 
	COPY_ptr ( x70_ + 1, y70_.defn ) ;\
 1024 
	COPY_ptr(x70_ + 1, y70_.defn);\
1041 
    }
 1025 
    }
1042 
 
 1026 
 
1043 
#define DEREF_ident( A, B )\
 1027 
#define DEREF_ident(A, B)\
1044 
    {\
 1028 
    {\
1045 
	calculus *x71_ = CHECK_NULL ( A ) ;\
 1029 
	calculus *x71_ = CHECK_NULL(A);\
1046 
	IDENTITY *y71_ = &( B ) ;\
 1030 
	IDENTITY *y71_ = &(B);\
1047 
	y71_->id = DEREF_ptr ( x71_ + 0 ) ;\
 1031 
	y71_->id = DEREF_ptr(x71_ + 0);\
1048 
	y71_->defn = DEREF_ptr ( x71_ + 1 ) ;\
 1032 
	y71_->defn = DEREF_ptr(x71_ + 1);\
1049 
    }
 1033 
    }
1050 
 
 1034 
 
1051 
#define MAKE_ident( id_, defn_, ident_ )\
 1035 
#define MAKE_ident(id_, defn_, ident_)\
1052 
    {\
 1036 
    {\
1053 
	calculus *x72_ = CHECK_NULL ( ident_ ) ;\
 1037 
	calculus *x72_ = CHECK_NULL(ident_);\
1054 
	COPY_ptr ( x72_ + 0, ( id_ ) ) ;\
 1038 
	COPY_ptr(x72_ + 0, (id_));\
1055 
	COPY_ptr ( x72_ + 1, ( defn_ ) ) ;\
 1039 
	COPY_ptr(x72_ + 1, (defn_));\
1056 
    }
 1040 
    }
1057 
 
 1041 
 
1058 
#define CONS_ident( A, B, C )\
 1042 
#define CONS_ident(A, B, C)\
1059 
    {\
 1043 
    {\
1060 
	calculus *x73_ = GEN_calculus ( 3, TYPEID_list ) ;\
 1044 
	calculus *x73_ = GEN_calculus(3, TYPEID_list);\
1061 
	COPY_ident ( x73_ + 1, ( A ) ) ;\
 1045 
	COPY_ident(x73_ + 1, (A));\
1062 
	x73_->ag_ptr = ( B ) ;\
 1046 
	x73_->ag_ptr = (B);\
1063 
	( C ) = x73_ ;\
 1047 
	(C) = x73_;\
1064 
    }
 1048 
    }
1065 
 
 1049 
 
1066 
#define UN_CONS_ident( A, B, C )\
 1050 
#define UN_CONS_ident(A, B, C)\
1067 
    {\
 1051 
    {\
1068 
	calculus *x74_ = CHECK_NULL ( C ) ;\
 1052 
	calculus *x74_ = CHECK_NULL(C);\
1069 
	DEREF_ident ( x74_ + 1, ( A ) ) ;\
 1053 
	DEREF_ident(x74_ + 1, (A));\
1070 
	( B ) = x74_->ag_ptr ;\
 1054 
	(B) = x74_->ag_ptr;\
1071 
    }
 1055 
    }
1072 
 
 1056 
 
1073 
#define DESTROY_CONS_ident( D, A, B, C )\
 1057 
#define DESTROY_CONS_ident(D, A, B, C)\
1074 
    {\
 1058 
    {\
1075 
	calculus *x75_ = CHECK_NULL ( C ) ;\
 1059 
	calculus *x75_ = CHECK_NULL(C);\
1076 
	DEREF_ident ( x75_ + 1, ( A ) ) ;\
 1060 
	DEREF_ident(x75_ + 1, (A));\
1077 
	( B ) = x75_->ag_ptr ;\
 1061 
	(B) = x75_->ag_ptr;\
1078 
	( D ) ( x75_, ( unsigned ) 3 ) ;\
 1062 
	(D)(x75_, (unsigned)3);\
1079 
    }
 1063 
    }
1080 
 
 1064 
 
1081 
#define PUSH_ident( A, B )\
 1065 
#define PUSH_ident(A, B)\
1082 
    {\
 1066 
    {\
1083 
	calculus **r76_ = &( B ) ;\
 1067 
	calculus **r76_ = &(B);\
1084 
	calculus *x76_ = GEN_calculus ( 3, TYPEID_stack ) ;\
 1068 
	calculus *x76_ = GEN_calculus(3, TYPEID_stack);\
1085 
	COPY_ident ( x76_ + 1, ( A ) ) ;\
 1069 
	COPY_ident(x76_ + 1, (A));\
1086 
	x76_->ag_ptr = *r76_ ;\
 1070 
	x76_->ag_ptr = *r76_;\
1087 
	*r76_ = x76_ ;\
 1071 
	*r76_ = x76_;\
1088 
    }
 1072 
    }
1089 
 
 1073 
 
1090 
#define POP_ident( A, B )\
 1074 
#define POP_ident(A, B)\
1091 
    {\
 1075 
    {\
1092 
	calculus **r77_ = &( B ) ;\
 1076 
	calculus **r77_ = &(B);\
1093 
	calculus *x77_ = CHECK_NULL ( *r77_ ) ;\
 1077 
	calculus *x77_ = CHECK_NULL(*r77_);\
1094 
	DEREF_ident ( x77_ + 1, ( A ) ) ;\
 1078 
	DEREF_ident(x77_ + 1, (A));\
1095 
	*r77_ = x77_->ag_ptr ;\
 1079 
	*r77_ = x77_->ag_ptr;\
1096 
	destroy_calculus ( x77_, ( unsigned ) 3 ) ;\
 1080 
	destroy_calculus(x77_, (unsigned)3);\
1097 
    }
 1081 
    }
1098 
 
 1082 
 
1099 
 
 1083 
 
1100 
/* Definitions for structure COMPONENT */
 1084 
/* Definitions for structure COMPONENT */
1101 
 
 1085 
 
1102 
#define cmp_name( P )			( ( P ) + 0 )
 1086 
#define cmp_name(P)			((P) + 0)
1103 
#define cmp_type( P )			( ( P ) + 1 )
 1087 
#define cmp_type(P)			((P) + 1)
1104 
#define cmp_value( P )			( ( P ) + 2 )
 1088 
#define cmp_value(P)			((P) + 2)
1105 
#define SIZE_cmp			3
 1089 
#define SIZE_cmp			3
1106 
 
 1090 
 
1107 
#define COPY_cmp( A, B )\
 1091 
#define COPY_cmp(A, B)\
1108 
    {\
 1092 
    {\
1109 
	calculus *x78_ = CHECK_NULL ( A ) ;\
 1093 
	calculus *x78_ = CHECK_NULL(A);\
1110 
	COMPONENT y78_ ;\
 1094 
	COMPONENT y78_;\
1111 
	y78_ = ( B ) ;\
 1095 
	y78_ = (B);\
1112 
	COPY_string ( x78_ + 0, y78_.name ) ;\
 1096 
	COPY_string(x78_ + 0, y78_.name);\
1113 
	COPY_ptr ( x78_ + 1, y78_.type ) ;\
 1097 
	COPY_ptr(x78_ + 1, y78_.type);\
1114 
	COPY_string ( x78_ + 2, y78_.value ) ;\
 1098 
	COPY_string(x78_ + 2, y78_.value);\
1115 
    }
 1099 
    }
1116 
 
 1100 
 
1117 
#define DEREF_cmp( A, B )\
 1101 
#define DEREF_cmp(A, B)\
1118 
    {\
 1102 
    {\
1119 
	calculus *x79_ = CHECK_NULL ( A ) ;\
 1103 
	calculus *x79_ = CHECK_NULL(A);\
1120 
	COMPONENT *y79_ = &( B ) ;\
 1104 
	COMPONENT *y79_ = &(B);\
1121 
	y79_->name = DEREF_string ( x79_ + 0 ) ;\
 1105 
	y79_->name = DEREF_string(x79_ + 0);\
1122 
	y79_->type = DEREF_ptr ( x79_ + 1 ) ;\
 1106 
	y79_->type = DEREF_ptr(x79_ + 1);\
1123 
	y79_->value = DEREF_string ( x79_ + 2 ) ;\
 1107 
	y79_->value = DEREF_string(x79_ + 2);\
1124 
    }
 1108 
    }
1125 
 
 1109 
 
1126 
#define MAKE_cmp( name_, type_, value_, cmp_ )\
 1110 
#define MAKE_cmp(name_, type_, value_, cmp_)\
1127 
    {\
 1111 
    {\
1128 
	calculus *x80_ = CHECK_NULL ( cmp_ ) ;\
 1112 
	calculus *x80_ = CHECK_NULL(cmp_);\
1129 
	COPY_string ( x80_ + 0, ( name_ ) ) ;\
 1113 
	COPY_string(x80_ + 0, (name_));\
1130 
	COPY_ptr ( x80_ + 1, ( type_ ) ) ;\
 1114 
	COPY_ptr(x80_ + 1, (type_));\
1131 
	COPY_string ( x80_ + 2, ( value_ ) ) ;\
 1115 
	COPY_string(x80_ + 2, (value_));\
1132 
    }
 1116 
    }
1133 
 
 1117 
 
1134 
#define CONS_cmp( A, B, C )\
 1118 
#define CONS_cmp(A, B, C)\
1135 
    {\
 1119 
    {\
1136 
	calculus *x81_ = GEN_calculus ( 4, TYPEID_list ) ;\
 1120 
	calculus *x81_ = GEN_calculus(4, TYPEID_list);\
1137 
	COPY_cmp ( x81_ + 1, ( A ) ) ;\
 1121 
	COPY_cmp(x81_ + 1, (A));\
1138 
	x81_->ag_ptr = ( B ) ;\
 1122 
	x81_->ag_ptr = (B);\
1139 
	( C ) = x81_ ;\
 1123 
	(C) = x81_;\
1140 
    }
 1124 
    }
1141 
 
 1125 
 
1142 
#define UN_CONS_cmp( A, B, C )\
 1126 
#define UN_CONS_cmp(A, B, C)\
1143 
    {\
 1127 
    {\
1144 
	calculus *x82_ = CHECK_NULL ( C ) ;\
 1128 
	calculus *x82_ = CHECK_NULL(C);\
1145 
	DEREF_cmp ( x82_ + 1, ( A ) ) ;\
 1129 
	DEREF_cmp(x82_ + 1, (A));\
1146 
	( B ) = x82_->ag_ptr ;\
 1130 
	(B) = x82_->ag_ptr;\
1147 
    }
 1131 
    }
1148 
 
 1132 
 
1149 
#define DESTROY_CONS_cmp( D, A, B, C )\
 1133 
#define DESTROY_CONS_cmp(D, A, B, C)\
1150 
    {\
 1134 
    {\
1151 
	calculus *x83_ = CHECK_NULL ( C ) ;\
 1135 
	calculus *x83_ = CHECK_NULL(C);\
1152 
	DEREF_cmp ( x83_ + 1, ( A ) ) ;\
 1136 
	DEREF_cmp(x83_ + 1, (A));\
1153 
	( B ) = x83_->ag_ptr ;\
 1137 
	(B) = x83_->ag_ptr;\
1154 
	( D ) ( x83_, ( unsigned ) 4 ) ;\
 1138 
	(D)(x83_, (unsigned)4);\
1155 
    }
 1139 
    }
1156 
 
 1140 
 
1157 
#define PUSH_cmp( A, B )\
 1141 
#define PUSH_cmp(A, B)\
1158 
    {\
 1142 
    {\
1159 
	calculus **r84_ = &( B ) ;\
 1143 
	calculus **r84_ = &(B);\
1160 
	calculus *x84_ = GEN_calculus ( 4, TYPEID_stack ) ;\
 1144 
	calculus *x84_ = GEN_calculus(4, TYPEID_stack);\
1161 
	COPY_cmp ( x84_ + 1, ( A ) ) ;\
 1145 
	COPY_cmp(x84_ + 1, (A));\
1162 
	x84_->ag_ptr = *r84_ ;\
 1146 
	x84_->ag_ptr = *r84_;\
1163 
	*r84_ = x84_ ;\
 1147 
	*r84_ = x84_;\
1164 
    }
 1148 
    }
1165 
 
 1149 
 
1166 
#define POP_cmp( A, B )\
 1150 
#define POP_cmp(A, B)\
1167 
    {\
 1151 
    {\
1168 
	calculus **r85_ = &( B ) ;\
 1152 
	calculus **r85_ = &(B);\
1169 
	calculus *x85_ = CHECK_NULL ( *r85_ ) ;\
 1153 
	calculus *x85_ = CHECK_NULL(*r85_);\
1170 
	DEREF_cmp ( x85_ + 1, ( A ) ) ;\
 1154 
	DEREF_cmp(x85_ + 1, (A));\
1171 
	*r85_ = x85_->ag_ptr ;\
 1155 
	*r85_ = x85_->ag_ptr;\
1172 
	destroy_calculus ( x85_, ( unsigned ) 4 ) ;\
 1156 
	destroy_calculus(x85_, (unsigned)4);\
1173 
    }
 1157 
    }
1174 
 
 1158 
 
1175 
 
 1159 
 
1176 
/* Definitions for structure STRUCTURE */
 1160 
/* Definitions for structure STRUCTURE */
1177 
 
 1161 
 
1178 
#define str_id( P )			( ( P ) + 0 )
 1162 
#define str_id(P)			((P) + 0)
1179 
#define str_base( P )			( ( P ) + 1 )
 1163 
#define str_base(P)			((P) + 1)
1180 
#define str_defn( P )			( ( P ) + 2 )
 1164 
#define str_defn(P)			((P) + 2)
1181 
#define str_output( P )			( ( P ) + 3 )
 1165 
#define str_output(P)			((P) + 3)
1182 
#define SIZE_str			4
 1166 
#define SIZE_str			4
1183 
 
 1167 
 
1184 
#define COPY_str( A, B )\
 1168 
#define COPY_str(A, B)\
1185 
    {\
 1169 
    {\
1186 
	calculus *x86_ = CHECK_NULL ( A ) ;\
 1170 
	calculus *x86_ = CHECK_NULL(A);\
1187 
	STRUCTURE y86_ ;\
 1171 
	STRUCTURE y86_;\
1188 
	y86_ = ( B ) ;\
 1172 
	y86_ = (B);\
1189 
	COPY_ptr ( x86_ + 0, y86_.id ) ;\
 1173 
	COPY_ptr(x86_ + 0, y86_.id);\
1190 
	COPY_ptr ( x86_ + 1, y86_.base ) ;\
 1174 
	COPY_ptr(x86_ + 1, y86_.base);\
1191 
	COPY_list ( x86_ + 2, y86_.defn ) ;\
 1175 
	COPY_list(x86_ + 2, y86_.defn);\
1192 
	COPY_int ( x86_ + 3, y86_.output ) ;\
 1176 
	COPY_int(x86_ + 3, y86_.output);\
1193 
    }
 1177 
    }
1194 
 
 1178 
 
1195 
#define DEREF_str( A, B )\
 1179 
#define DEREF_str(A, B)\
1196 
    {\
 1180 
    {\
1197 
	calculus *x87_ = CHECK_NULL ( A ) ;\
 1181 
	calculus *x87_ = CHECK_NULL(A);\
1198 
	STRUCTURE *y87_ = &( B ) ;\
 1182 
	STRUCTURE *y87_ = &(B);\
1199 
	y87_->id = DEREF_ptr ( x87_ + 0 ) ;\
 1183 
	y87_->id = DEREF_ptr(x87_ + 0);\
1200 
	y87_->base = DEREF_ptr ( x87_ + 1 ) ;\
 1184 
	y87_->base = DEREF_ptr(x87_ + 1);\
1201 
	y87_->defn = DEREF_list ( x87_ + 2 ) ;\
 1185 
	y87_->defn = DEREF_list(x87_ + 2);\
1202 
	y87_->output = DEREF_int ( x87_ + 3 ) ;\
 1186 
	y87_->output = DEREF_int(x87_ + 3);\
1203 
    }
 1187 
    }
1204 
 
 1188 
 
1205 
#define MAKE_str( id_, base_, defn_, output_, str_ )\
 1189 
#define MAKE_str(id_, base_, defn_, output_, str_)\
1206 
    {\
 1190 
    {\
1207 
	calculus *x88_ = CHECK_NULL ( str_ ) ;\
 1191 
	calculus *x88_ = CHECK_NULL(str_);\
1208 
	COPY_ptr ( x88_ + 0, ( id_ ) ) ;\
 1192 
	COPY_ptr(x88_ + 0, (id_));\
1209 
	COPY_ptr ( x88_ + 1, ( base_ ) ) ;\
 1193 
	COPY_ptr(x88_ + 1, (base_));\
1210 
	COPY_list ( x88_ + 2, ( defn_ ) ) ;\
 1194 
	COPY_list(x88_ + 2, (defn_));\
1211 
	COPY_int ( x88_ + 3, ( output_ ) ) ;\
 1195 
	COPY_int(x88_ + 3, (output_));\
1212 
    }
 1196 
    }
1213 
 
 1197 
 
1214 
#define CONS_str( A, B, C )\
 1198 
#define CONS_str(A, B, C)\
1215 
    {\
 1199 
    {\
1216 
	calculus *x89_ = GEN_calculus ( 5, TYPEID_list ) ;\
 1200 
	calculus *x89_ = GEN_calculus(5, TYPEID_list);\
1217 
	COPY_str ( x89_ + 1, ( A ) ) ;\
 1201 
	COPY_str(x89_ + 1, (A));\
1218 
	x89_->ag_ptr = ( B ) ;\
 1202 
	x89_->ag_ptr = (B);\
1219 
	( C ) = x89_ ;\
 1203 
	(C) = x89_;\
1220 
    }
 1204 
    }
1221 
 
 1205 
 
1222 
#define UN_CONS_str( A, B, C )\
 1206 
#define UN_CONS_str(A, B, C)\
1223 
    {\
 1207 
    {\
1224 
	calculus *x90_ = CHECK_NULL ( C ) ;\
 1208 
	calculus *x90_ = CHECK_NULL(C);\
1225 
	DEREF_str ( x90_ + 1, ( A ) ) ;\
 1209 
	DEREF_str(x90_ + 1, (A));\
1226 
	( B ) = x90_->ag_ptr ;\
 1210 
	(B) = x90_->ag_ptr;\
1227 
    }
 1211 
    }
1228 
 
 1212 
 
1229 
#define DESTROY_CONS_str( D, A, B, C )\
 1213 
#define DESTROY_CONS_str(D, A, B, C)\
1230 
    {\
 1214 
    {\
1231 
	calculus *x91_ = CHECK_NULL ( C ) ;\
 1215 
	calculus *x91_ = CHECK_NULL(C);\
1232 
	DEREF_str ( x91_ + 1, ( A ) ) ;\
 1216 
	DEREF_str(x91_ + 1, (A));\
1233 
	( B ) = x91_->ag_ptr ;\
 1217 
	(B) = x91_->ag_ptr;\
1234 
	( D ) ( x91_, ( unsigned ) 5 ) ;\
 1218 
	(D)(x91_, (unsigned)5);\
1235 
    }
 1219 
    }
1236 
 
 1220 
 
1237 
#define PUSH_str( A, B )\
 1221 
#define PUSH_str(A, B)\
1238 
    {\
 1222 
    {\
1239 
	calculus **r92_ = &( B ) ;\
 1223 
	calculus **r92_ = &(B);\
1240 
	calculus *x92_ = GEN_calculus ( 5, TYPEID_stack ) ;\
 1224 
	calculus *x92_ = GEN_calculus(5, TYPEID_stack);\
1241 
	COPY_str ( x92_ + 1, ( A ) ) ;\
 1225 
	COPY_str(x92_ + 1, (A));\
1242 
	x92_->ag_ptr = *r92_ ;\
 1226 
	x92_->ag_ptr = *r92_;\
1243 
	*r92_ = x92_ ;\
 1227 
	*r92_ = x92_;\
1244 
    }
 1228 
    }
1245 
 
 1229 
 
1246 
#define POP_str( A, B )\
 1230 
#define POP_str(A, B)\
1247 
    {\
 1231 
    {\
1248 
	calculus **r93_ = &( B ) ;\
 1232 
	calculus **r93_ = &(B);\
1249 
	calculus *x93_ = CHECK_NULL ( *r93_ ) ;\
 1233 
	calculus *x93_ = CHECK_NULL(*r93_);\
1250 
	DEREF_str ( x93_ + 1, ( A ) ) ;\
 1234 
	DEREF_str(x93_ + 1, (A));\
1251 
	*r93_ = x93_->ag_ptr ;\
 1235 
	*r93_ = x93_->ag_ptr;\
1252 
	destroy_calculus ( x93_, ( unsigned ) 5 ) ;\
 1236 
	destroy_calculus(x93_, (unsigned)5);\
1253 
    }
 1237 
    }
1254 
 
 1238 
 
1255 
 
 1239 
 
1256 
/* Definitions for structure FIELD */
 1240 
/* Definitions for structure FIELD */
1257 
 
 1241 
 
1258 
#define fld_name( P )			( ( P ) + 0 )
 1242 
#define fld_name(P)			((P) + 0)
1259 
#define fld_tag( P )			( ( P ) + 1 )
 1243 
#define fld_tag(P)			((P) + 1)
1260 
#define fld_flag( P )			( ( P ) + 2 )
 1244 
#define fld_flag(P)			((P) + 2)
1261 
#define fld_set( P )			( ( P ) + 3 )
 1245 
#define fld_set(P)			((P) + 3)
1262 
#define fld_base( P )			( ( P ) + 4 )
 1246 
#define fld_base(P)			((P) + 4)
1263 
#define fld_defn( P )			( ( P ) + 5 )
 1247 
#define fld_defn(P)			((P) + 5)
1264 
#define SIZE_fld			6
 1248 
#define SIZE_fld			6
1265 
 
 1249 
 
1266 
#define COPY_fld( A, B )\
 1250 
#define COPY_fld(A, B)\
1267 
    {\
 1251 
    {\
1268 
	calculus *x94_ = CHECK_NULL ( A ) ;\
 1252 
	calculus *x94_ = CHECK_NULL(A);\
1269 
	FIELD y94_ ;\
 1253 
	FIELD y94_;\
1270 
	y94_ = ( B ) ;\
 1254 
	y94_ = (B);\
1271 
	COPY_string ( x94_ + 0, y94_.name ) ;\
 1255 
	COPY_string(x94_ + 0, y94_.name);\
1272 
	COPY_int ( x94_ + 1, y94_.tag ) ;\
 1256 
	COPY_int(x94_ + 1, y94_.tag);\
1273 
	COPY_int ( x94_ + 2, y94_.flag ) ;\
 1257 
	COPY_int(x94_ + 2, y94_.flag);\
1274 
	COPY_int ( x94_ + 3, y94_.set ) ;\
 1258 
	COPY_int(x94_ + 3, y94_.set);\
1275 
	COPY_ptr ( x94_ + 4, y94_.base ) ;\
 1259 
	COPY_ptr(x94_ + 4, y94_.base);\
1276 
	COPY_list ( x94_ + 5, y94_.defn ) ;\
 1260 
	COPY_list(x94_ + 5, y94_.defn);\
1277 
    }
 1261 
    }
1278 
 
 1262 
 
1279 
#define DEREF_fld( A, B )\
 1263 
#define DEREF_fld(A, B)\
1280 
    {\
 1264 
    {\
1281 
	calculus *x95_ = CHECK_NULL ( A ) ;\
 1265 
	calculus *x95_ = CHECK_NULL(A);\
1282 
	FIELD *y95_ = &( B ) ;\
 1266 
	FIELD *y95_ = &(B);\
1283 
	y95_->name = DEREF_string ( x95_ + 0 ) ;\
 1267 
	y95_->name = DEREF_string(x95_ + 0);\
1284 
	y95_->tag = DEREF_int ( x95_ + 1 ) ;\
 1268 
	y95_->tag = DEREF_int(x95_ + 1);\
1285 
	y95_->flag = DEREF_int ( x95_ + 2 ) ;\
 1269 
	y95_->flag = DEREF_int(x95_ + 2);\
1286 
	y95_->set = DEREF_int ( x95_ + 3 ) ;\
 1270 
	y95_->set = DEREF_int(x95_ + 3);\
1287 
	y95_->base = DEREF_ptr ( x95_ + 4 ) ;\
 1271 
	y95_->base = DEREF_ptr(x95_ + 4);\
1288 
	y95_->defn = DEREF_list ( x95_ + 5 ) ;\
 1272 
	y95_->defn = DEREF_list(x95_ + 5);\
1289 
    }
 1273 
    }
1290 
 
 1274 
 
1291 
#define MAKE_fld( name_, tag_, flag_, set_, base_, defn_, fld_ )\
 1275 
#define MAKE_fld(name_, tag_, flag_, set_, base_, defn_, fld_)\
1292 
    {\
 1276 
    {\
1293 
	calculus *x96_ = CHECK_NULL ( fld_ ) ;\
 1277 
	calculus *x96_ = CHECK_NULL(fld_);\
1294 
	COPY_string ( x96_ + 0, ( name_ ) ) ;\
 1278 
	COPY_string(x96_ + 0, (name_));\
1295 
	COPY_int ( x96_ + 1, ( tag_ ) ) ;\
 1279 
	COPY_int(x96_ + 1, (tag_));\
1296 
	COPY_int ( x96_ + 2, ( flag_ ) ) ;\
 1280 
	COPY_int(x96_ + 2, (flag_));\
1297 
	COPY_int ( x96_ + 3, ( set_ ) ) ;\
 1281 
	COPY_int(x96_ + 3, (set_));\
1298 
	COPY_ptr ( x96_ + 4, ( base_ ) ) ;\
 1282 
	COPY_ptr(x96_ + 4, (base_));\
1299 
	COPY_list ( x96_ + 5, ( defn_ ) ) ;\
 1283 
	COPY_list(x96_ + 5, (defn_));\
1300 
    }
 1284 
    }
1301 
 
 1285 
 
1302 
#define CONS_fld( A, B, C )\
 1286 
#define CONS_fld(A, B, C)\
1303 
    {\
 1287 
    {\
1304 
	calculus *x97_ = GEN_calculus ( 7, TYPEID_list ) ;\
 1288 
	calculus *x97_ = GEN_calculus(7, TYPEID_list);\
1305 
	COPY_fld ( x97_ + 1, ( A ) ) ;\
 1289 
	COPY_fld(x97_ + 1, (A));\
1306 
	x97_->ag_ptr = ( B ) ;\
 1290 
	x97_->ag_ptr = (B);\
1307 
	( C ) = x97_ ;\
 1291 
	(C) = x97_;\
1308 
    }
 1292 
    }
1309 
 
 1293 
 
1310 
#define UN_CONS_fld( A, B, C )\
 1294 
#define UN_CONS_fld(A, B, C)\
1311 
    {\
 1295 
    {\
1312 
	calculus *x98_ = CHECK_NULL ( C ) ;\
 1296 
	calculus *x98_ = CHECK_NULL(C);\
1313 
	DEREF_fld ( x98_ + 1, ( A ) ) ;\
 1297 
	DEREF_fld(x98_ + 1, (A));\
1314 
	( B ) = x98_->ag_ptr ;\
 1298 
	(B) = x98_->ag_ptr;\
1315 
    }
 1299 
    }
1316 
 
 1300 
 
1317 
#define DESTROY_CONS_fld( D, A, B, C )\
 1301 
#define DESTROY_CONS_fld(D, A, B, C)\
1318 
    {\
 1302 
    {\
1319 
	calculus *x99_ = CHECK_NULL ( C ) ;\
 1303 
	calculus *x99_ = CHECK_NULL(C);\
1320 
	DEREF_fld ( x99_ + 1, ( A ) ) ;\
 1304 
	DEREF_fld(x99_ + 1, (A));\
1321 
	( B ) = x99_->ag_ptr ;\
 1305 
	(B) = x99_->ag_ptr;\
1322 
	( D ) ( x99_, ( unsigned ) 7 ) ;\
 1306 
	(D)(x99_, (unsigned)7);\
1323 
    }
 1307 
    }
1324 
 
 1308 
 
1325 
#define PUSH_fld( A, B )\
 1309 
#define PUSH_fld(A, B)\
1326 
    {\
 1310 
    {\
1327 
	calculus **r100_ = &( B ) ;\
 1311 
	calculus **r100_ = &(B);\
1328 
	calculus *x100_ = GEN_calculus ( 7, TYPEID_stack ) ;\
 1312 
	calculus *x100_ = GEN_calculus(7, TYPEID_stack);\
1329 
	COPY_fld ( x100_ + 1, ( A ) ) ;\
 1313 
	COPY_fld(x100_ + 1, (A));\
1330 
	x100_->ag_ptr = *r100_ ;\
 1314 
	x100_->ag_ptr = *r100_;\
1331 
	*r100_ = x100_ ;\
 1315 
	*r100_ = x100_;\
1332 
    }
 1316 
    }
1333 
 
 1317 
 
1334 
#define POP_fld( A, B )\
 1318 
#define POP_fld(A, B)\
1335 
    {\
 1319 
    {\
1336 
	calculus **r101_ = &( B ) ;\
 1320 
	calculus **r101_ = &(B);\
1337 
	calculus *x101_ = CHECK_NULL ( *r101_ ) ;\
 1321 
	calculus *x101_ = CHECK_NULL(*r101_);\
1338 
	DEREF_fld ( x101_ + 1, ( A ) ) ;\
 1322 
	DEREF_fld(x101_ + 1, (A));\
1339 
	*r101_ = x101_->ag_ptr ;\
 1323 
	*r101_ = x101_->ag_ptr;\
1340 
	destroy_calculus ( x101_, ( unsigned ) 7 ) ;\
 1324 
	destroy_calculus(x101_, (unsigned)7);\
1341 
    }
 1325 
    }
1342 
 
 1326 
 
1343 
 
 1327 
 
1344 
/* Definitions for structure ARGUMENT */
 1328 
/* Definitions for structure ARGUMENT */
1345 
 
 1329 
 
1346 
#define arg_name( P )			( ( P ) + 0 )
 1330 
#define arg_name(P)			((P) + 0)
1347 
#define arg_type( P )			( ( P ) + 1 )
 1331 
#define arg_type(P)			((P) + 1)
1348 
#define SIZE_arg			2
 1332 
#define SIZE_arg			2
1349 
 
 1333 
 
1350 
#define COPY_arg( A, B )\
 1334 
#define COPY_arg(A, B)\
1351 
    {\
 1335 
    {\
1352 
	calculus *x102_ = CHECK_NULL ( A ) ;\
 1336 
	calculus *x102_ = CHECK_NULL(A);\
1353 
	ARGUMENT y102_ ;\
 1337 
	ARGUMENT y102_;\
1354 
	y102_ = ( B ) ;\
 1338 
	y102_ = (B);\
1355 
	COPY_string ( x102_ + 0, y102_.name ) ;\
 1339 
	COPY_string(x102_ + 0, y102_.name);\
1356 
	COPY_ptr ( x102_ + 1, y102_.type ) ;\
 1340 
	COPY_ptr(x102_ + 1, y102_.type);\
1357 
    }
 1341 
    }
1358 
 
 1342 
 
1359 
#define DEREF_arg( A, B )\
 1343 
#define DEREF_arg(A, B)\
1360 
    {\
 1344 
    {\
1361 
	calculus *x103_ = CHECK_NULL ( A ) ;\
 1345 
	calculus *x103_ = CHECK_NULL(A);\
1362 
	ARGUMENT *y103_ = &( B ) ;\
 1346 
	ARGUMENT *y103_ = &(B);\
1363 
	y103_->name = DEREF_string ( x103_ + 0 ) ;\
 1347 
	y103_->name = DEREF_string(x103_ + 0);\
1364 
	y103_->type = DEREF_ptr ( x103_ + 1 ) ;\
 1348 
	y103_->type = DEREF_ptr(x103_ + 1);\
1365 
    }
 1349 
    }
1366 
 
 1350 
 
1367 
#define MAKE_arg( name_, type_, arg_ )\
 1351 
#define MAKE_arg(name_, type_, arg_)\
1368 
    {\
 1352 
    {\
1369 
	calculus *x104_ = CHECK_NULL ( arg_ ) ;\
 1353 
	calculus *x104_ = CHECK_NULL(arg_);\
1370 
	COPY_string ( x104_ + 0, ( name_ ) ) ;\
 1354 
	COPY_string(x104_ + 0, (name_));\
1371 
	COPY_ptr ( x104_ + 1, ( type_ ) ) ;\
 1355 
	COPY_ptr(x104_ + 1, (type_));\
1372 
    }
 1356 
    }
1373 
 
 1357 
 
1374 
#define CONS_arg( A, B, C )\
 1358 
#define CONS_arg(A, B, C)\
1375 
    {\
 1359 
    {\
1376 
	calculus *x105_ = GEN_calculus ( 3, TYPEID_list ) ;\
 1360 
	calculus *x105_ = GEN_calculus(3, TYPEID_list);\
1377 
	COPY_arg ( x105_ + 1, ( A ) ) ;\
 1361 
	COPY_arg(x105_ + 1, (A));\
1378 
	x105_->ag_ptr = ( B ) ;\
 1362 
	x105_->ag_ptr = (B);\
1379 
	( C ) = x105_ ;\
 1363 
	(C) = x105_;\
1380 
    }
 1364 
    }
1381 
 
 1365 
 
1382 
#define UN_CONS_arg( A, B, C )\
 1366 
#define UN_CONS_arg(A, B, C)\
1383 
    {\
 1367 
    {\
1384 
	calculus *x106_ = CHECK_NULL ( C ) ;\
 1368 
	calculus *x106_ = CHECK_NULL(C);\
1385 
	DEREF_arg ( x106_ + 1, ( A ) ) ;\
 1369 
	DEREF_arg(x106_ + 1, (A));\
1386 
	( B ) = x106_->ag_ptr ;\
 1370 
	(B) = x106_->ag_ptr;\
1387 
    }
 1371 
    }
1388 
 
 1372 
 
1389 
#define DESTROY_CONS_arg( D, A, B, C )\
 1373 
#define DESTROY_CONS_arg(D, A, B, C)\
1390 
    {\
 1374 
    {\
1391 
	calculus *x107_ = CHECK_NULL ( C ) ;\
 1375 
	calculus *x107_ = CHECK_NULL(C);\
1392 
	DEREF_arg ( x107_ + 1, ( A ) ) ;\
 1376 
	DEREF_arg(x107_ + 1, (A));\
1393 
	( B ) = x107_->ag_ptr ;\
 1377 
	(B) = x107_->ag_ptr;\
1394 
	( D ) ( x107_, ( unsigned ) 3 ) ;\
 1378 
	(D)(x107_, (unsigned)3);\
1395 
    }
 1379 
    }
1396 
 
 1380 
 
1397 
#define PUSH_arg( A, B )\
 1381 
#define PUSH_arg(A, B)\
1398 
    {\
 1382 
    {\
1399 
	calculus **r108_ = &( B ) ;\
 1383 
	calculus **r108_ = &(B);\
1400 
	calculus *x108_ = GEN_calculus ( 3, TYPEID_stack ) ;\
 1384 
	calculus *x108_ = GEN_calculus(3, TYPEID_stack);\
1401 
	COPY_arg ( x108_ + 1, ( A ) ) ;\
 1385 
	COPY_arg(x108_ + 1, (A));\
1402 
	x108_->ag_ptr = *r108_ ;\
 1386 
	x108_->ag_ptr = *r108_;\
1403 
	*r108_ = x108_ ;\
 1387 
	*r108_ = x108_;\
1404 
    }
 1388 
    }
1405 
 
 1389 
 
1406 
#define POP_arg( A, B )\
 1390 
#define POP_arg(A, B)\
1407 
    {\
 1391 
    {\
1408 
	calculus **r109_ = &( B ) ;\
 1392 
	calculus **r109_ = &(B);\
1409 
	calculus *x109_ = CHECK_NULL ( *r109_ ) ;\
 1393 
	calculus *x109_ = CHECK_NULL(*r109_);\
1410 
	DEREF_arg ( x109_ + 1, ( A ) ) ;\
 1394 
	DEREF_arg(x109_ + 1, (A));\
1411 
	*r109_ = x109_->ag_ptr ;\
 1395 
	*r109_ = x109_->ag_ptr;\
1412 
	destroy_calculus ( x109_, ( unsigned ) 3 ) ;\
 1396 
	destroy_calculus(x109_, (unsigned)3);\
1413 
    }
 1397 
    }
1414 
 
 1398 
 
1415 
 
 1399 
 
1416 
/* Definitions for structure MAP */
 1400 
/* Definitions for structure MAP */
1417 
 
 1401 
 
1418 
#define map_name( P )			( ( P ) + 0 )
 1402 
#define map_name(P)			((P) + 0)
1419 
#define map_flag( P )			( ( P ) + 1 )
 1403 
#define map_flag(P)			((P) + 1)
1420 
#define map_ret_type( P )		( ( P ) + 2 )
 1404 
#define map_ret_type(P)			((P) + 2)
1421 
#define map_args( P )			( ( P ) + 3 )
 1405 
#define map_args(P)			((P) + 3)
1422 
#define SIZE_map			4
 1406 
#define SIZE_map			4
1423 
 
 1407 
 
1424 
#define COPY_map( A, B )\
 1408 
#define COPY_map(A, B)\
1425 
    {\
 1409 
    {\
1426 
	calculus *x110_ = CHECK_NULL ( A ) ;\
 1410 
	calculus *x110_ = CHECK_NULL(A);\
1427 
	MAP y110_ ;\
 1411 
	MAP y110_;\
1428 
	y110_ = ( B ) ;\
 1412 
	y110_ = (B);\
1429 
	COPY_string ( x110_ + 0, y110_.name ) ;\
 1413 
	COPY_string(x110_ + 0, y110_.name);\
1430 
	COPY_int ( x110_ + 1, y110_.flag ) ;\
 1414 
	COPY_int(x110_ + 1, y110_.flag);\
1431 
	COPY_ptr ( x110_ + 2, y110_.ret_type ) ;\
 1415 
	COPY_ptr(x110_ + 2, y110_.ret_type);\
1432 
	COPY_list ( x110_ + 3, y110_.args ) ;\
 1416 
	COPY_list(x110_ + 3, y110_.args);\
1433 
    }
 1417 
    }
1434 
 
 1418 
 
1435 
#define DEREF_map( A, B )\
 1419 
#define DEREF_map(A, B)\
1436 
    {\
 1420 
    {\
1437 
	calculus *x111_ = CHECK_NULL ( A ) ;\
 1421 
	calculus *x111_ = CHECK_NULL(A);\
1438 
	MAP *y111_ = &( B ) ;\
 1422 
	MAP *y111_ = &(B);\
1439 
	y111_->name = DEREF_string ( x111_ + 0 ) ;\
 1423 
	y111_->name = DEREF_string(x111_ + 0);\
1440 
	y111_->flag = DEREF_int ( x111_ + 1 ) ;\
 1424 
	y111_->flag = DEREF_int(x111_ + 1);\
1441 
	y111_->ret_type = DEREF_ptr ( x111_ + 2 ) ;\
 1425 
	y111_->ret_type = DEREF_ptr(x111_ + 2);\
1442 
	y111_->args = DEREF_list ( x111_ + 3 ) ;\
 1426 
	y111_->args = DEREF_list(x111_ + 3);\
1443 
    }
 1427 
    }
1444 
 
 1428 
 
1445 
#define MAKE_map( name_, flag_, ret_type_, args_, map_ )\
 1429 
#define MAKE_map(name_, flag_, ret_type_, args_, map_)\
1446 
    {\
 1430 
    {\
1447 
	calculus *x112_ = CHECK_NULL ( map_ ) ;\
 1431 
	calculus *x112_ = CHECK_NULL(map_);\
1448 
	COPY_string ( x112_ + 0, ( name_ ) ) ;\
 1432 
	COPY_string(x112_ + 0, (name_));\
1449 
	COPY_int ( x112_ + 1, ( flag_ ) ) ;\
 1433 
	COPY_int(x112_ + 1, (flag_));\
1450 
	COPY_ptr ( x112_ + 2, ( ret_type_ ) ) ;\
 1434 
	COPY_ptr(x112_ + 2, (ret_type_));\
1451 
	COPY_list ( x112_ + 3, ( args_ ) ) ;\
 1435 
	COPY_list(x112_ + 3, (args_));\
1452 
    }
 1436 
    }
1453 
 
 1437 
 
1454 
#define CONS_map( A, B, C )\
 1438 
#define CONS_map(A, B, C)\
1455 
    {\
 1439 
    {\
1456 
	calculus *x113_ = GEN_calculus ( 5, TYPEID_list ) ;\
 1440 
	calculus *x113_ = GEN_calculus(5, TYPEID_list);\
1457 
	COPY_map ( x113_ + 1, ( A ) ) ;\
 1441 
	COPY_map(x113_ + 1, (A));\
1458 
	x113_->ag_ptr = ( B ) ;\
 1442 
	x113_->ag_ptr = (B);\
1459 
	( C ) = x113_ ;\
 1443 
	(C) = x113_;\
1460 
    }
 1444 
    }
1461 
 
 1445 
 
1462 
#define UN_CONS_map( A, B, C )\
 1446 
#define UN_CONS_map(A, B, C)\
1463 
    {\
 1447 
    {\
1464 
	calculus *x114_ = CHECK_NULL ( C ) ;\
 1448 
	calculus *x114_ = CHECK_NULL(C);\
1465 
	DEREF_map ( x114_ + 1, ( A ) ) ;\
 1449 
	DEREF_map(x114_ + 1, (A));\
1466 
	( B ) = x114_->ag_ptr ;\
 1450 
	(B) = x114_->ag_ptr;\
1467 
    }
 1451 
    }
1468 
 
 1452 
 
1469 
#define DESTROY_CONS_map( D, A, B, C )\
 1453 
#define DESTROY_CONS_map(D, A, B, C)\
1470 
    {\
 1454 
    {\
1471 
	calculus *x115_ = CHECK_NULL ( C ) ;\
 1455 
	calculus *x115_ = CHECK_NULL(C);\
1472 
	DEREF_map ( x115_ + 1, ( A ) ) ;\
 1456 
	DEREF_map(x115_ + 1, (A));\
1473 
	( B ) = x115_->ag_ptr ;\
 1457 
	(B) = x115_->ag_ptr;\
1474 
	( D ) ( x115_, ( unsigned ) 5 ) ;\
 1458 
	(D)(x115_, (unsigned)5);\
1475 
    }
 1459 
    }
1476 
 
 1460 
 
1477 
#define PUSH_map( A, B )\
 1461 
#define PUSH_map(A, B)\
1478 
    {\
 1462 
    {\
1479 
	calculus **r116_ = &( B ) ;\
 1463 
	calculus **r116_ = &(B);\
1480 
	calculus *x116_ = GEN_calculus ( 5, TYPEID_stack ) ;\
 1464 
	calculus *x116_ = GEN_calculus(5, TYPEID_stack);\
1481 
	COPY_map ( x116_ + 1, ( A ) ) ;\
 1465 
	COPY_map(x116_ + 1, (A));\
1482 
	x116_->ag_ptr = *r116_ ;\
 1466 
	x116_->ag_ptr = *r116_;\
1483 
	*r116_ = x116_ ;\
 1467 
	*r116_ = x116_;\
1484 
    }
 1468 
    }
1485 
 
 1469 
 
1486 
#define POP_map( A, B )\
 1470 
#define POP_map(A, B)\
1487 
    {\
 1471 
    {\
1488 
	calculus **r117_ = &( B ) ;\
 1472 
	calculus **r117_ = &(B);\
1489 
	calculus *x117_ = CHECK_NULL ( *r117_ ) ;\
 1473 
	calculus *x117_ = CHECK_NULL(*r117_);\
1490 
	DEREF_map ( x117_ + 1, ( A ) ) ;\
 1474 
	DEREF_map(x117_ + 1, (A));\
1491 
	*r117_ = x117_->ag_ptr ;\
 1475 
	*r117_ = x117_->ag_ptr;\
1492 
	destroy_calculus ( x117_, ( unsigned ) 5 ) ;\
 1476 
	destroy_calculus(x117_, (unsigned)5);\
1493 
    }
 1477 
    }
1494 
 
 1478 
 
1495 
 
 1479 
 
1496 
/* Definitions for structure UNION */
 1480 
/* Definitions for structure UNION */
1497 
 
 1481 
 
1498 
#define un_id( P )			( ( P ) + 0 )
 1482 
#define un_id(P)			((P) + 0)
1499 
#define un_base( P )			( ( P ) + 1 )
 1483 
#define un_base(P)			((P) + 1)
1500 
#define un_s_defn( P )			( ( P ) + 2 )
 1484 
#define un_s_defn(P)			((P) + 2)
1501 
#define un_u_defn( P )			( ( P ) + 3 )
 1485 
#define un_u_defn(P)			((P) + 3)
1502 
#define un_map( P )			( ( P ) + 4 )
 1486 
#define un_map(P)			((P) + 4)
1503 
#define un_no_fields( P )		( ( P ) + 5 )
 1487 
#define un_no_fields(P)			((P) + 5)
1504 
#define SIZE_un				6
 1488 
#define SIZE_un				6
1505 
 
 1489 
 
1506 
#define COPY_un( A, B )\
 1490 
#define COPY_un(A, B)\
1507 
    {\
 1491 
    {\
1508 
	calculus *x118_ = CHECK_NULL ( A ) ;\
 1492 
	calculus *x118_ = CHECK_NULL(A);\
1509 
	UNION y118_ ;\
 1493 
	UNION y118_;\
1510 
	y118_ = ( B ) ;\
 1494 
	y118_ = (B);\
1511 
	COPY_ptr ( x118_ + 0, y118_.id ) ;\
 1495 
	COPY_ptr(x118_ + 0, y118_.id);\
1512 
	COPY_ptr ( x118_ + 1, y118_.base ) ;\
 1496 
	COPY_ptr(x118_ + 1, y118_.base);\
1513 
	COPY_list ( x118_ + 2, y118_.s_defn ) ;\
 1497 
	COPY_list(x118_ + 2, y118_.s_defn);\
1514 
	COPY_list ( x118_ + 3, y118_.u_defn ) ;\
 1498 
	COPY_list(x118_ + 3, y118_.u_defn);\
1515 
	COPY_list ( x118_ + 4, y118_.map ) ;\
 1499 
	COPY_list(x118_ + 4, y118_.map);\
1516 
	COPY_int ( x118_ + 5, y118_.no_fields ) ;\
 1500 
	COPY_int(x118_ + 5, y118_.no_fields);\
1517 
    }
 1501 
    }
1518 
 
 1502 
 
1519 
#define DEREF_un( A, B )\
 1503 
#define DEREF_un(A, B)\
1520 
    {\
 1504 
    {\
1521 
	calculus *x119_ = CHECK_NULL ( A ) ;\
 1505 
	calculus *x119_ = CHECK_NULL(A);\
1522 
	UNION *y119_ = &( B ) ;\
 1506 
	UNION *y119_ = &(B);\
1523 
	y119_->id = DEREF_ptr ( x119_ + 0 ) ;\
 1507 
	y119_->id = DEREF_ptr(x119_ + 0);\
1524 
	y119_->base = DEREF_ptr ( x119_ + 1 ) ;\
 1508 
	y119_->base = DEREF_ptr(x119_ + 1);\
1525 
	y119_->s_defn = DEREF_list ( x119_ + 2 ) ;\
 1509 
	y119_->s_defn = DEREF_list(x119_ + 2);\
1526 
	y119_->u_defn = DEREF_list ( x119_ + 3 ) ;\
 1510 
	y119_->u_defn = DEREF_list(x119_ + 3);\
1527 
	y119_->map = DEREF_list ( x119_ + 4 ) ;\
 1511 
	y119_->map = DEREF_list(x119_ + 4);\
1528 
	y119_->no_fields = DEREF_int ( x119_ + 5 ) ;\
 1512 
	y119_->no_fields = DEREF_int(x119_ + 5);\
1529 
    }
 1513 
    }
1530 
 
 1514 
 
1531 
#define MAKE_un( id_, base_, s_defn_, u_defn_, map_, no_fields_, un_ )\
 1515 
#define MAKE_un(id_, base_, s_defn_, u_defn_, map_, no_fields_, un_)\
1532 
    {\
 1516 
    {\
1533 
	calculus *x120_ = CHECK_NULL ( un_ ) ;\
 1517 
	calculus *x120_ = CHECK_NULL(un_);\
1534 
	COPY_ptr ( x120_ + 0, ( id_ ) ) ;\
 1518 
	COPY_ptr(x120_ + 0, (id_));\
1535 
	COPY_ptr ( x120_ + 1, ( base_ ) ) ;\
 1519 
	COPY_ptr(x120_ + 1, (base_));\
1536 
	COPY_list ( x120_ + 2, ( s_defn_ ) ) ;\
 1520 
	COPY_list(x120_ + 2, (s_defn_));\
1537 
	COPY_list ( x120_ + 3, ( u_defn_ ) ) ;\
 1521 
	COPY_list(x120_ + 3, (u_defn_));\
1538 
	COPY_list ( x120_ + 4, ( map_ ) ) ;\
 1522 
	COPY_list(x120_ + 4, (map_));\
1539 
	COPY_int ( x120_ + 5, ( no_fields_ ) ) ;\
 1523 
	COPY_int(x120_ + 5, (no_fields_));\
1540 
    }
 1524 
    }
1541 
 
 1525 
 
1542 
#define CONS_un( A, B, C )\
 1526 
#define CONS_un(A, B, C)\
1543 
    {\
 1527 
    {\
1544 
	calculus *x121_ = GEN_calculus ( 7, TYPEID_list ) ;\
 1528 
	calculus *x121_ = GEN_calculus(7, TYPEID_list);\
1545 
	COPY_un ( x121_ + 1, ( A ) ) ;\
 1529 
	COPY_un(x121_ + 1, (A));\
1546 
	x121_->ag_ptr = ( B ) ;\
 1530 
	x121_->ag_ptr = (B);\
1547 
	( C ) = x121_ ;\
 1531 
	(C) = x121_;\
1548 
    }
 1532 
    }
1549 
 
 1533 
 
1550 
#define UN_CONS_un( A, B, C )\
 1534 
#define UN_CONS_un(A, B, C)\
1551 
    {\
 1535 
    {\
1552 
	calculus *x122_ = CHECK_NULL ( C ) ;\
 1536 
	calculus *x122_ = CHECK_NULL(C);\
1553 
	DEREF_un ( x122_ + 1, ( A ) ) ;\
 1537 
	DEREF_un(x122_ + 1, (A));\
1554 
	( B ) = x122_->ag_ptr ;\
 1538 
	(B) = x122_->ag_ptr;\
1555 
    }
 1539 
    }
1556 
 
 1540 
 
1557 
#define DESTROY_CONS_un( D, A, B, C )\
 1541 
#define DESTROY_CONS_un(D, A, B, C)\
1558 
    {\
 1542 
    {\
1559 
	calculus *x123_ = CHECK_NULL ( C ) ;\
 1543 
	calculus *x123_ = CHECK_NULL(C);\
1560 
	DEREF_un ( x123_ + 1, ( A ) ) ;\
 1544 
	DEREF_un(x123_ + 1, (A));\
1561 
	( B ) = x123_->ag_ptr ;\
 1545 
	(B) = x123_->ag_ptr;\
1562 
	( D ) ( x123_, ( unsigned ) 7 ) ;\
 1546 
	(D)(x123_, (unsigned)7);\
1563 
    }
 1547 
    }
1564 
 
 1548 
 
1565 
#define PUSH_un( A, B )\
 1549 
#define PUSH_un(A, B)\
1566 
    {\
 1550 
    {\
1567 
	calculus **r124_ = &( B ) ;\
 1551 
	calculus **r124_ = &(B);\
1568 
	calculus *x124_ = GEN_calculus ( 7, TYPEID_stack ) ;\
 1552 
	calculus *x124_ = GEN_calculus(7, TYPEID_stack);\
1569 
	COPY_un ( x124_ + 1, ( A ) ) ;\
 1553 
	COPY_un(x124_ + 1, (A));\
1570 
	x124_->ag_ptr = *r124_ ;\
 1554 
	x124_->ag_ptr = *r124_;\
1571 
	*r124_ = x124_ ;\
 1555 
	*r124_ = x124_;\
1572 
    }
 1556 
    }
1573 
 
 1557 
 
1574 
#define POP_un( A, B )\
 1558 
#define POP_un(A, B)\
1575 
    {\
 1559 
    {\
1576 
	calculus **r125_ = &( B ) ;\
 1560 
	calculus **r125_ = &(B);\
1577 
	calculus *x125_ = CHECK_NULL ( *r125_ ) ;\
 1561 
	calculus *x125_ = CHECK_NULL(*r125_);\
1578 
	DEREF_un ( x125_ + 1, ( A ) ) ;\
 1562 
	DEREF_un(x125_ + 1, (A));\
1579 
	*r125_ = x125_->ag_ptr ;\
 1563 
	*r125_ = x125_->ag_ptr;\
1580 
	destroy_calculus ( x125_, ( unsigned ) 7 ) ;\
 1564 
	destroy_calculus(x125_, (unsigned)7);\
1581 
    }
 1565 
    }
1582 
 
 1566 
 
1583 
 
 1567 
 
1584 
/* Definitions for union TYPE */
 1568 
/* Definitions for union TYPE */
1585 
 
 1569 
 
1586 
#define ORDER_type			( ( unsigned ) 12 )
 1570 
#define ORDER_type			((unsigned) 12)
1587 
#define SIZE_type			1
 1571 
#define SIZE_type			1
1588 
#define NULL_type			( ( TYPE ) 0 )
 1572 
#define NULL_type			((TYPE) 0)
1589 
#define IS_NULL_type( A )		( ( A ) == 0 )
 1573 
#define IS_NULL_type(A)			((A) == 0)
1590 
#define EQ_type( A, B )			( ( A ) == ( B ) )
 1574 
#define EQ_type(A, B)			((A) == (B))
1591 
 
 1575 
 
1592 
#define COPY_type( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 1576 
#define COPY_type(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
1593 
#define DEREF_type( A )			( CHECK_NULL ( A )->ag_ptr )
 1577 
#define DEREF_type(A)			(CHECK_NULL(A)->ag_ptr)
1594 
 
 1578 
 
1595 
#define CONS_type( A, B, C )\
 1579 
#define CONS_type(A, B, C)\
1596 
    {\
 1580 
    {\
1597 
	calculus *x126_ = GEN_calculus ( 2, TYPEID_list ) ;\
 1581 
	calculus *x126_ = GEN_calculus(2, TYPEID_list);\
1598 
	COPY_type ( x126_ + 1, ( A ) ) ;\
 1582 
	COPY_type(x126_ + 1, (A));\
1599 
	x126_->ag_ptr = ( B ) ;\
 1583 
	x126_->ag_ptr = (B);\
1600 
	( C ) = x126_ ;\
 1584 
	(C) = x126_;\
1601 
    }
 1585 
    }
1602 
 
 1586 
 
1603 
#define UN_CONS_type( A, B, C )\
 1587 
#define UN_CONS_type(A, B, C)\
1604 
    {\
 1588 
    {\
1605 
	calculus *x127_ = CHECK_NULL ( C ) ;\
 1589 
	calculus *x127_ = CHECK_NULL(C);\
1606 
	( A ) = DEREF_type ( x127_ + 1 ) ;\
 1590 
	(A) = DEREF_type(x127_ + 1);\
1607 
	( B ) = x127_->ag_ptr ;\
 1591 
	(B) = x127_->ag_ptr;\
1608 
    }
 1592 
    }
1609 
 
 1593 
 
1610 
#define DESTROY_CONS_type( D, A, B, C )\
 1594 
#define DESTROY_CONS_type(D, A, B, C)\
1611 
    {\
 1595 
    {\
1612 
	calculus *x128_ = CHECK_NULL ( C ) ;\
 1596 
	calculus *x128_ = CHECK_NULL(C);\
1613 
	( A ) = DEREF_type ( x128_ + 1 ) ;\
 1597 
	(A) = DEREF_type(x128_ + 1);\
1614 
	( B ) = x128_->ag_ptr ;\
 1598 
	(B) = x128_->ag_ptr;\
1615 
	( D ) ( x128_, ( unsigned ) 2 ) ;\
 1599 
	(D)(x128_, (unsigned)2);\
1616 
    }
 1600 
    }
1617 
 
 1601 
 
1618 
#define PUSH_type( A, B )\
 1602 
#define PUSH_type(A, B)\
1619 
    {\
 1603 
    {\
1620 
	calculus **r129_ = &( B ) ;\
 1604 
	calculus **r129_ = &(B);\
1621 
	calculus *x129_ = GEN_calculus ( 2, TYPEID_stack ) ;\
 1605 
	calculus *x129_ = GEN_calculus(2, TYPEID_stack);\
1622 
	COPY_type ( x129_ + 1, ( A ) ) ;\
 1606 
	COPY_type(x129_ + 1, (A));\
1623 
	x129_->ag_ptr = *r129_ ;\
 1607 
	x129_->ag_ptr = *r129_;\
1624 
	*r129_ = x129_ ;\
 1608 
	*r129_ = x129_;\
1625 
    }
 1609 
    }
1626 
 
 1610 
 
1627 
#define POP_type( A, B )\
 1611 
#define POP_type(A, B)\
1628 
    {\
 1612 
    {\
1629 
	calculus **r130_ = &( B ) ;\
 1613 
	calculus **r130_ = &(B);\
1630 
	calculus *x130_ = CHECK_NULL ( *r130_ ) ;\
 1614 
	calculus *x130_ = CHECK_NULL(*r130_);\
1631 
	( A ) = DEREF_type ( x130_ + 1 ) ;\
 1615 
	(A) = DEREF_type(x130_ + 1);\
1632 
	*r130_ = x130_->ag_ptr ;\
 1616 
	*r130_ = x130_->ag_ptr;\
1633 
	destroy_calculus ( x130_, ( unsigned ) 2 ) ;\
 1617 
	destroy_calculus(x130_, (unsigned)2);\
1634 
    }
 1618 
    }
1635 
 
 1619 
 
1636 
 
 1620 
 
1637 
/* Definitions for union COMMAND */
 1621 
/* Definitions for union COMMAND */
1638 
 
 1622 
 
1639 
#define ORDER_cmd			( ( unsigned ) 4 )
 1623 
#define ORDER_cmd			((unsigned) 4)
1640 
#define SIZE_cmd			1
 1624 
#define SIZE_cmd			1
1641 
#define NULL_cmd			( ( COMMAND ) 0 )
 1625 
#define NULL_cmd			((COMMAND) 0)
1642 
#define IS_NULL_cmd( A )		( ( A ) == 0 )
 1626 
#define IS_NULL_cmd(A)			((A) == 0)
1643 
#define EQ_cmd( A, B )			( ( A ) == ( B ) )
 1627 
#define EQ_cmd(A, B)			((A) == (B))
1644 
 
 1628 
 
1645 
#define COPY_cmd( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 1629 
#define COPY_cmd(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
1646 
#define DEREF_cmd( A )			( CHECK_NULL ( A )->ag_ptr )
 1630 
#define DEREF_cmd(A)			(CHECK_NULL(A)->ag_ptr)
1647 
 
 1631 
 
1648 
#define CONS_cmd( A, B, C )\
 1632 
#define CONS_cmd(A, B, C)\
1649 
    {\
 1633 
    {\
1650 
	calculus *x131_ = GEN_calculus ( 2, TYPEID_list ) ;\
 1634 
	calculus *x131_ = GEN_calculus(2, TYPEID_list);\
1651 
	COPY_cmd ( x131_ + 1, ( A ) ) ;\
 1635 
	COPY_cmd(x131_ + 1, (A));\
1652 
	x131_->ag_ptr = ( B ) ;\
 1636 
	x131_->ag_ptr = (B);\
1653 
	( C ) = x131_ ;\
 1637 
	(C) = x131_;\
1654 
    }
 1638 
    }
1655 
 
 1639 
 
1656 
#define UN_CONS_cmd( A, B, C )\
 1640 
#define UN_CONS_cmd(A, B, C)\
1657 
    {\
 1641 
    {\
1658 
	calculus *x132_ = CHECK_NULL ( C ) ;\
 1642 
	calculus *x132_ = CHECK_NULL(C);\
1659 
	( A ) = DEREF_cmd ( x132_ + 1 ) ;\
 1643 
	(A) = DEREF_cmd(x132_ + 1);\
1660 
	( B ) = x132_->ag_ptr ;\
 1644 
	(B) = x132_->ag_ptr;\
1661 
    }
 1645 
    }
1662 
 
 1646 
 
1663 
#define DESTROY_CONS_cmd( D, A, B, C )\
 1647 
#define DESTROY_CONS_cmd(D, A, B, C)\
1664 
    {\
 1648 
    {\
1665 
	calculus *x133_ = CHECK_NULL ( C ) ;\
 1649 
	calculus *x133_ = CHECK_NULL(C);\
1666 
	( A ) = DEREF_cmd ( x133_ + 1 ) ;\
 1650 
	(A) = DEREF_cmd(x133_ + 1);\
1667 
	( B ) = x133_->ag_ptr ;\
 1651 
	(B) = x133_->ag_ptr;\
1668 
	( D ) ( x133_, ( unsigned ) 2 ) ;\
 1652 
	(D)(x133_, (unsigned)2);\
1669 
    }
 1653 
    }
1670 
 
 1654 
 
1671 
#define PUSH_cmd( A, B )\
 1655 
#define PUSH_cmd(A, B)\
1672 
    {\
 1656 
    {\
1673 
	calculus **r134_ = &( B ) ;\
 1657 
	calculus **r134_ = &(B);\
1674 
	calculus *x134_ = GEN_calculus ( 2, TYPEID_stack ) ;\
 1658 
	calculus *x134_ = GEN_calculus(2, TYPEID_stack);\
1675 
	COPY_cmd ( x134_ + 1, ( A ) ) ;\
 1659 
	COPY_cmd(x134_ + 1, (A));\
1676 
	x134_->ag_ptr = *r134_ ;\
 1660 
	x134_->ag_ptr = *r134_;\
1677 
	*r134_ = x134_ ;\
 1661 
	*r134_ = x134_;\
1678 
    }
 1662 
    }
1679 
 
 1663 
 
1680 
#define POP_cmd( A, B )\
 1664 
#define POP_cmd(A, B)\
1681 
    {\
 1665 
    {\
1682 
	calculus **r135_ = &( B ) ;\
 1666 
	calculus **r135_ = &(B);\
1683 
	calculus *x135_ = CHECK_NULL ( *r135_ ) ;\
 1667 
	calculus *x135_ = CHECK_NULL(*r135_);\
1684 
	( A ) = DEREF_cmd ( x135_ + 1 ) ;\
 1668 
	(A) = DEREF_cmd(x135_ + 1);\
1685 
	*r135_ = x135_->ag_ptr ;\
 1669 
	*r135_ = x135_->ag_ptr;\
1686 
	destroy_calculus ( x135_, ( unsigned ) 2 ) ;\
 1670 
	destroy_calculus(x135_, (unsigned)2);\
1687 
    }
 1671 
    }
1688 
 
 1672 
 
1689 
 
 1673 
 
1690 
/* Maximum allocation size */
 1674 
/* Maximum allocation size */
1691 
 
 1675