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 1... Line 1...
1 
/*
 1 
/*
2 
    		 Crown Copyright (c) 1997
 2 
    		 Crown Copyright (c) 1997
3
3 
 
4 
    This TenDRA(r) Computer Program is subject to Copyright
 4 
    This TenDRA(r) Computer Program is subject to Copyright
5 
    owned by the United Kingdom Secretary of State for Defence
 5 
    owned by the United Kingdom Secretary of State for Defence
6 
    acting through the Defence Evaluation and Research Agency
 6 
    acting through the Defence Evaluation and Research Agency
7 
    (DERA).  It is made available to Recipients with a
 7 
    (DERA).  It is made available to Recipients with a
8 
    royalty-free licence for its use, reproduction, transfer
 8 
    royalty-free licence for its use, reproduction, transfer
9 
    to other parties and amendment for any purpose not excluding
 9 
    to other parties and amendment for any purpose not excluding
10 
    product development provided that any such use et cetera
 10 
    product development provided that any such use et cetera
11 
    shall be deemed to be acceptance of the following conditions:-
 11 
    shall be deemed to be acceptance of the following conditions:-
12
12 
 
13 
        (1) Its Recipients shall ensure that this Notice is
 13 
        (1) Its Recipients shall ensure that this Notice is
14 
        reproduced upon any copies or amended versions of it;
 14 
        reproduced upon any copies or amended versions of it;
15
15 
 
16 
        (2) Any amended version of it shall be clearly marked to
 16 
        (2) Any amended version of it shall be clearly marked to
17 
        show both the nature of and the organisation responsible
 17 
        show both the nature of and the organisation responsible
18 
        for the relevant amendment or amendments;
 18 
        for the relevant amendment or amendments;
19
19 
 
20 
        (3) Its onward transfer from a recipient to another
 20 
        (3) Its onward transfer from a recipient to another
21 
        party shall be deemed to be that party's acceptance of
 21 
        party shall be deemed to be that party's acceptance of
22 
        these conditions;
 22 
        these conditions;
23
23 
 
24 
        (4) DERA gives no warranty or assurance as to its
 24 
        (4) DERA gives no warranty or assurance as to its
25 
        quality or suitability for any purpose and DERA accepts
 25 
        quality or suitability for any purpose and DERA accepts
26 
        no liability whatsoever in relation to any use to which
 26 
        no liability whatsoever in relation to any use to which
27 
        it may be put.
 27 
        it may be put.
28 
*/
 28 
*/
29 
 
 29 
 
30 
/*
 30 
/*
31 
    AUTOMATICALLY GENERATED FROM ALGEBRA errors (VERSION 1.0)
 31 
    AUTOMATICALLY GENERATED FROM ALGEBRA errors (VERSION 1.0)
32 
    BY calculus (VERSION 1.2)
 32 
    BY calculus (VERSION 1.2)
33 
*/
 33 
*/
34 
 
 34 
 
35 
#ifndef ERRORS_H_INCLUDED
 35 
#ifndef ERRORS_H_INCLUDED
36 
#define ERRORS_H_INCLUDED
 36 
#define ERRORS_H_INCLUDED
37 
 
 37 
 
38 
#ifndef errors_NAME
 38 
#ifndef errors_NAME
39 
#define errors_NAME			"errors"
 39 
#define errors_NAME			"errors"
40 
#define errors_VERSION			"1.0"
 40 
#define errors_VERSION			"1.0"
41 
#define errors_SPECIFICATION		0
 41 
#define errors_SPECIFICATION		0
42 
#define errors_IMPLEMENTATION		1
 42 
#define errors_IMPLEMENTATION		1
43 
#endif
 43 
#endif
44 
 
 44 
 
45 
 
 45 
 
46 
/* Prototype macros */
 46 
/* Prototype macros */
47 
 
 - 
 
48 
#ifndef PROTO_S
 - 
 
49 
#ifdef __STDC__
 - 
 
50 
#define PROTO_S( types )		types
 - 
 
51 
#define PROTO_N( names )
 - 
 
52 
#define PROTO_T( parms )		( parms )
 - 
 
53 
#define PROTO_Z()			( void )
 - 
 
54 
#define X				,
 - 
 
55 
#else
 - 
 
56 
#define PROTO_S( types )		()
 - 
 
57 
#define PROTO_N( names )		names
 - 
 
58 
#define PROTO_T( parms )		parms ;
 - 
 
59 
#define PROTO_Z()			()
 - 
 
60 
#define X				;
 - 
 
61 
#endif
 - 
 
62 
#endif
 - 
 
63 
 
 47 
 
64 
#ifndef CONST_S
 48 
#ifndef CONST_S
65 
#define CONST_S
 49 
#define CONST_S
66 
#endif
 50 
#endif
67 
 
 51 
 
68 
 
 52 
 
69 
/* Primitive types */
 53 
/* Primitive types */
70 
 
 54 
 
71 
typedef char * string ;
 55 
typedef char * string;
72 
 
 56 
 
73 
 
 57 
 
74 
/* Basic types */
 58 
/* Basic types */
75 
 
 59 
 
76 
typedef union errors_tag {
 60 
typedef union errors_tag {
77 
    unsigned ag_tag ;
 61 
    unsigned ag_tag;
78 
    union errors_tag *ag_ptr ;
 62 
    union errors_tag *ag_ptr;
79 
    unsigned ag_enum ;
 63 
    unsigned ag_enum;
80 
    unsigned long ag_long_enum ;
 64 
    unsigned long ag_long_enum;
81 
    int ag_prim_int ;
 65 
    int ag_prim_int;
82 
    string ag_prim_string ;
 66 
    string ag_prim_string;
83 
} errors ;
 67 
} errors;
84 
 
 68 
 
85 
typedef errors *errors_PTR ;
 69 
typedef errors *errors_PTR;
86 
 
 70 
 
87 
#ifndef errors_DESTR_DEFINED
 71 
#ifndef errors_DESTR_DEFINED
88 
#define errors_DESTR_DEFINED
 72 
#define errors_DESTR_DEFINED
89 
typedef void ( *DESTROYER ) PROTO_S ( ( errors *, unsigned ) ) ;
 73 
typedef void (*DESTROYER)(errors *, unsigned);
90 
#endif
 74 
#endif
91 
 
 75 
 
92 
#define PTR( A )	errors_PTR
 76 
#define PTR(A)	errors_PTR
93 
#define LIST( A )	errors_PTR
 77 
#define LIST(A)	errors_PTR
94 
#define STACK( A )	errors_PTR
 78 
#define STACK(A)	errors_PTR
95 
#define SIZE( A )	int
 79 
#define SIZE(A)	int
96 
 
 80 
 
97 
 
 81 
 
98 
/* Assertion macros */
 82 
/* Assertion macros */
99 
 
 83 
 
100 
#ifdef ASSERTS
 84 
#ifdef ASSERTS
101 
extern errors *check_null_errors PROTO_S ( ( errors *, CONST_S char *, int ) ) ;
 85 
extern errors *check_null_errors(errors *, char *, int);
102 
extern errors *check_tag_errors PROTO_S ( ( errors *, unsigned, CONST_S char *, int ) ) ;
 86 
extern errors *check_tag_errors(errors *, unsigned, char *, int);
103 
extern errors *check_tag_etc_errors PROTO_S ( ( errors *, unsigned, unsigned, CONST_S char *, int ) ) ;
 87 
extern errors *check_tag_etc_errors(errors *, unsigned, unsigned, char *, int);
104 
#define CHECK_NULL( P )\
 88 
#define CHECK_NULL(P)\
105 
    ( check_null_errors ( ( P ), __FILE__, __LINE__ ) )
 89 
    (check_null_errors((P), __FILE__, __LINE__))
106 
#define CHECK_TAG( P, N )\
 90 
#define CHECK_TAG(P, N)\
107 
    ( check_tag_errors ( ( P ), ( unsigned ) ( N ), __FILE__, __LINE__ ) )
 91 
    (check_tag_errors((P), (unsigned)(N), __FILE__, __LINE__))
108 
#define CHECK_TAG_ETC( P, L, U )\
 92 
#define CHECK_TAG_ETC(P, L, U)\
109 
    ( check_tag_etc_errors ( ( P ), ( unsigned ) ( L ), ( unsigned ) ( U ), __FILE__, __LINE__ ) )
 93 
    (check_tag_etc_errors((P), (unsigned)(L), (unsigned)(U), __FILE__, __LINE__))
110 
#else
 94 
#else
111 
#define CHECK_NULL( P )			( P )
 95 
#define CHECK_NULL(P)			(P)
112 
#define CHECK_TAG( P, N )		( P )
 96 
#define CHECK_TAG(P, N)			(P)
113 
#define CHECK_TAG_ETC( P, L, U )	( P )
 97 
#define CHECK_TAG_ETC(P, L, U)		(P)
114 
#endif
 98 
#endif
115 
 
 99 
 
116 
 
 100 
 
117 
/* Enumeration definitions */
 101 
/* Enumeration definitions */
118 
 
 102 
 
119 
 
 103 
 
120 
 
 104 
 
121 
/* Union type definitions */
 105 
/* Union type definitions */
122 
 
 106 
 
123 
typedef errors *NAME ;
 107 
typedef errors *NAME;
124 
typedef errors *MESSAGE ;
 108 
typedef errors *MESSAGE;
125 
typedef errors *MAP ;
 109 
typedef errors *MAP;
126 
typedef errors *PARAM ;
 110 
typedef errors *PARAM;
127 
typedef errors *ENTRY ;
 111 
typedef errors *ENTRY;
128 
 
 112 
 
129 
 
 113 
 
130 
/* Structure declarations */
 114 
/* Structure declarations */
131 
 
 115 
 
132 
 
 116 
 
133 
 
 117 
 
134 
/* Identity type definitions */
 118 
/* Identity type definitions */
135 
 
 119 
 
136 
typedef NAME KEY ;
 120 
typedef NAME KEY;
137 
typedef NAME PROPERTY ;
 121 
typedef NAME PROPERTY;
138 
typedef NAME TYPE ;
 122 
typedef NAME TYPE;
139 
typedef NAME USAGE ;
 123 
typedef NAME USAGE;
140 
 
 124 
 
141 
 
 125 
 
142 
/* Structure definitions */
 126 
/* Structure definitions */
143 
 
 127 
 
144 
#ifndef errors_STRUCT_DEFINED
 128 
#ifndef errors_STRUCT_DEFINED
Line 147... Line 131...
147 
#endif /* errors_STRUCT_DEFINED */
 131 
#endif /* errors_STRUCT_DEFINED */
148 
 
 132 
 
149 
 
 133 
 
150 
/* Function declarations */
 134 
/* Function declarations */
151 
 
 135 
 
152 
extern errors *gen_errors PROTO_S ( ( unsigned ) ) ;
 136 
extern errors *gen_errors(unsigned);
153 
extern void destroy_errors PROTO_S ( ( errors *, unsigned ) ) ;
 137 
extern void destroy_errors(errors *, unsigned);
154 
extern void dummy_destroy_errors PROTO_S ( ( errors *, unsigned ) ) ;
 138 
extern void dummy_destroy_errors (errors *, unsigned);
155 
extern void destroy_errors_list PROTO_S ( ( errors *, unsigned ) ) ;
 139 
extern void destroy_errors_list (errors *, unsigned);
156 
extern errors *append_errors_list PROTO_S ( ( errors *, errors * ) ) ;
 140 
extern errors *append_errors_list(errors *, errors *);
157 
extern errors *end_errors_list PROTO_S ( ( errors * ) ) ;
 141 
extern errors *end_errors_list(errors *);
158 
extern unsigned length_errors_list PROTO_S ( ( errors * ) ) ;
 142 
extern unsigned length_errors_list(errors *);
159 
extern errors *reverse_errors_list PROTO_S ( ( errors * ) ) ;
 143 
extern errors *reverse_errors_list(errors *);
160 
#ifdef errors_IO_ROUTINES
 144 
#ifdef errors_IO_ROUTINES
161 
extern unsigned crt_errors_alias ;
 145 
extern unsigned crt_errors_alias;
162 
extern void set_errors_alias PROTO_S ( ( errors *, unsigned ) ) ;
 146 
extern void set_errors_alias(errors *, unsigned);
163 
extern errors *find_errors_alias PROTO_S ( ( unsigned ) ) ;
 147 
extern errors *find_errors_alias(unsigned);
164 
extern void clear_errors_alias PROTO_S ( ( void ) ) ;
 148 
extern void clear_errors_alias(void);
165 
#endif
 149 
#endif
166 
 
 150 
 
167 
 
 151 
 
168 
/* Run-time type information */
 152 
/* Run-time type information */
169 
 
 153 
 
170 
#ifndef GEN_errors
 154 
#ifndef GEN_errors
171 
#define GEN_errors( A, B )		gen_errors ( ( unsigned ) ( A ) )
 155 
#define GEN_errors(A, B)		gen_errors((unsigned)(A))
172 
#endif
 156 
#endif
173 
#define TYPEID_ptr			( ( unsigned ) 0 )
 157 
#define TYPEID_ptr			((unsigned)0)
174 
#define TYPEID_list			( ( unsigned ) 1 )
 158 
#define TYPEID_list			((unsigned)1)
175 
#define TYPEID_stack			( ( unsigned ) 2 )
 159 
#define TYPEID_stack			((unsigned)2)
176 
#define TYPEID_name			( ( unsigned ) 3 )
 160 
#define TYPEID_name			((unsigned)3)
177 
#define TYPEID_msg			( ( unsigned ) 4 )
 161 
#define TYPEID_msg			((unsigned)4)
178 
#define TYPEID_map			( ( unsigned ) 5 )
 162 
#define TYPEID_map			((unsigned)5)
179 
#define TYPEID_param			( ( unsigned ) 6 )
 163 
#define TYPEID_param			((unsigned)6)
180 
#define TYPEID_entry			( ( unsigned ) 7 )
 164 
#define TYPEID_entry			((unsigned)7)
181 
 
 165 
 
182 
 
 166 
 
183 
/* Definitions for pointers */
 167 
/* Definitions for pointers */
184 
 
 168 
 
185 
#define STEP_ptr( A, B )		( CHECK_NULL ( A ) + B )
 169 
#define STEP_ptr(A, B)			(CHECK_NULL(A) + B)
186 
#define SIZE_ptr( A )			1
 170 
#define SIZE_ptr(A)			1
187 
#define NULL_ptr( A )			( ( errors * ) 0 )
 171 
#define NULL_ptr(A)			((errors *)0)
188 
#define IS_NULL_ptr( A )		( ( A ) == 0 )
 172 
#define IS_NULL_ptr(A)			((A) == 0)
189 
#define EQ_ptr( A, B )			( ( A ) == ( B ) )
 173 
#define EQ_ptr(A, B)			((A) == (B))
190 
#define MAKE_ptr( A )			GEN_errors ( ( A ), TYPEID_ptr )
 174 
#define MAKE_ptr(A)			GEN_errors((A), TYPEID_ptr)
191 
#define DESTROY_ptr( A, B )		destroy_errors ( ( A ), ( unsigned ) ( B ) )
 175 
#define DESTROY_ptr(A, B)		destroy_errors((A), (unsigned)(B))
192 
#define UNIQ_ptr( A )			GEN_errors ( 1, TYPEID_ptr )
 176 
#define UNIQ_ptr(A)			GEN_errors(1, TYPEID_ptr)
193 
#define DESTROY_UNIQ_ptr( A )		destroy_errors ( ( A ), ( unsigned ) 1 )
 177 
#define DESTROY_UNIQ_ptr(A)		destroy_errors((A), (unsigned)1)
194 
#ifdef errors_IO_ROUTINES
 178 
#ifdef errors_IO_ROUTINES
195 
#define VOIDSTAR_ptr( A )		( ( void * ) ( A ) )
 179 
#define VOIDSTAR_ptr(A)			((void *)(A))
196 
#endif
 180 
#endif
197 
 
 181 
 
198 
#define COPY_ptr( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 182 
#define COPY_ptr(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
199 
#define DEREF_ptr( A )			( CHECK_NULL ( A )->ag_ptr )
 183 
#define DEREF_ptr(A)			(CHECK_NULL(A)->ag_ptr)
200 
#define CONS_ptr( A, B, C )\
 184 
#define CONS_ptr(A, B, C)\
201 
    {\
 185 
    {\
202 
	errors *x0_ = GEN_errors ( 2, TYPEID_list ) ;\
 186 
	errors *x0_ = GEN_errors(2, TYPEID_list);\
203 
	x0_ [1].ag_ptr = ( A ) ;\
 187 
	x0_[1].ag_ptr = (A);\
204 
	x0_->ag_ptr = ( B ) ;\
 188 
	x0_->ag_ptr = (B);\
205 
	( C ) = x0_ ;\
 189 
	(C) = x0_;\
206 
    }
 190 
    }
207 
 
 191 
 
208 
#define UN_CONS_ptr( A, B, C )\
 192 
#define UN_CONS_ptr(A, B, C)\
209 
    {\
 193 
    {\
210 
	errors *x1_ = CHECK_NULL ( C ) ;\
 194 
	errors *x1_ = CHECK_NULL(C);\
211 
	( A ) = x1_ [1].ag_ptr ;\
 195 
	(A) = x1_[1].ag_ptr;\
212 
	( B ) = x1_->ag_ptr ;\
 196 
	(B) = x1_->ag_ptr;\
213 
    }
 197 
    }
214 
 
 198 
 
215 
#define DESTROY_CONS_ptr( D, A, B, C )\
 199 
#define DESTROY_CONS_ptr(D, A, B, C)\
216 
    {\
 200 
    {\
217 
	errors *x2_ = CHECK_NULL ( C ) ;\
 201 
	errors *x2_ = CHECK_NULL(C);\
218 
	( A ) = x2_ [1].ag_ptr ;\
 202 
	(A) = x2_[1].ag_ptr;\
219 
	( B ) = x2_->ag_ptr ;\
 203 
	(B) = x2_->ag_ptr;\
220 
	( D ) ( x2_, ( unsigned ) 2 ) ;\
 204 
	(D)(x2_, (unsigned)2);\
221 
    }
 205 
    }
222 
 
 206 
 
223 
#define PUSH_ptr( A, B )\
 207 
#define PUSH_ptr(A, B)\
224 
    {\
 208 
    {\
225 
	errors **r3_ = &( B ) ;\
 209 
	errors **r3_ = &(B);\
226 
	errors *x3_ = GEN_errors ( 2, TYPEID_stack ) ;\
 210 
	errors *x3_ = GEN_errors(2, TYPEID_stack);\
227 
	x3_ [1].ag_ptr = ( A ) ;\
 211 
	x3_[1].ag_ptr = (A);\
228 
	x3_->ag_ptr = *r3_ ;\
 212 
	x3_->ag_ptr = *r3_;\
229 
	*r3_ = x3_ ;\
 213 
	*r3_ = x3_;\
230 
    }
 214 
    }
231 
 
 215 
 
232 
#define POP_ptr( A, B )\
 216 
#define POP_ptr(A, B)\
233 
    {\
 217 
    {\
234 
	errors **r4_ = &( B ) ;\
 218 
	errors **r4_ = &(B);\
235 
	errors *x4_ = CHECK_NULL ( *r4_ ) ;\
 219 
	errors *x4_ = CHECK_NULL(*r4_);\
236 
	( A ) = x4_ [1].ag_ptr ;\
 220 
	(A) = x4_[1].ag_ptr;\
237 
	*r4_ = x4_->ag_ptr ;\
 221 
	*r4_ = x4_->ag_ptr;\
238 
	destroy_errors ( x4_, ( unsigned ) 2 ) ;\
 222 
	destroy_errors(x4_, (unsigned)2);\
239 
    }
 223 
    }
240 
 
 224 
 
241 
 
 225 
 
242 
/* Definitions for lists */
 226 
/* Definitions for lists */
243 
 
 227 
 
244 
#define HEAD_list( A )			( CHECK_NULL ( A ) + 1 )
 228 
#define HEAD_list(A)			(CHECK_NULL(A) + 1)
245 
#define PTR_TAIL_list( A )		( CHECK_NULL ( A ) )
 229 
#define PTR_TAIL_list(A)		(CHECK_NULL(A))
246 
#define TAIL_list( A )			( CHECK_NULL ( A )->ag_ptr )
 230 
#define TAIL_list(A)			(CHECK_NULL(A)->ag_ptr)
247 
#define LENGTH_list( A )		length_errors_list ( ( A ) )
 231 
#define LENGTH_list(A)			length_errors_list((A))
248 
#define END_list( A )			end_errors_list ( ( A ) )
 232 
#define END_list(A)			end_errors_list((A))
249 
#define REVERSE_list( A )		reverse_errors_list ( ( A ) )
 233 
#define REVERSE_list(A)			reverse_errors_list((A))
250 
#define APPEND_list( A, B )		append_errors_list ( ( A ), ( B ) )
 234 
#define APPEND_list(A, B)		append_errors_list((A), (B))
251 
 
 235 
 
252 
#define SIZE_list( A )			1
 236 
#define SIZE_list(A)			1
253 
#define NULL_list( A )			( ( errors * ) 0 )
 237 
#define NULL_list(A)			((errors *) 0)
254 
#define IS_NULL_list( A )		( ( A ) == 0 )
 238 
#define IS_NULL_list(A)			((A) == 0)
255 
#define EQ_list( A, B )			( ( A ) == ( B ) )
 239 
#define EQ_list(A, B)			((A) == (B))
256 
#define UNIQ_list( A )			GEN_errors ( 1, TYPEID_list )
 240 
#define UNIQ_list(A)			GEN_errors(1, TYPEID_list)
257 
#define DESTROY_UNIQ_list( A )		destroy_errors ( ( A ), ( unsigned ) 1 )
 241 
#define DESTROY_UNIQ_list(A)		destroy_errors((A), (unsigned)1)
258 
#ifdef errors_IO_ROUTINES
 242 
#ifdef errors_IO_ROUTINES
259 
#define VOIDSTAR_list( A )		( ( void * ) ( A ) )
 243 
#define VOIDSTAR_list(A)		((void *)(A))
260 
#endif
 244 
#endif
261 
 
 245 
 
262 
#define DESTROY_list( A, B )\
 246 
#define DESTROY_list(A, B)\
263 
    {\
 247 
    {\
264 
	destroy_errors_list ( ( A ), ( unsigned ) ( B ) ) ;\
 248 
	destroy_errors_list((A), (unsigned)(B));\
265 
    }
 249 
    }
266 
 
 250 
 
267 
#define COPY_list( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 251 
#define COPY_list(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
268 
#define DEREF_list( A )			( CHECK_NULL ( A )->ag_ptr )
 252 
#define DEREF_list(A)			(CHECK_NULL(A)->ag_ptr)
269 
#define CONS_list( A, B, C )\
 253 
#define CONS_list(A, B, C)\
270 
    {\
 254 
    {\
271 
	errors *x5_ = GEN_errors ( 2, TYPEID_list ) ;\
 255 
	errors *x5_ = GEN_errors(2, TYPEID_list);\
272 
	x5_ [1].ag_ptr = ( A ) ;\
 256 
	x5_[1].ag_ptr = (A);\
273 
	x5_->ag_ptr = ( B ) ;\
 257 
	x5_->ag_ptr = (B);\
274 
	( C ) = x5_ ;\
 258 
	(C) = x5_;\
275 
    }
 259 
    }
276 
 
 260 
 
277 
#define UN_CONS_list( A, B, C )\
 261 
#define UN_CONS_list(A, B, C)\
278 
    {\
 262 
    {\
279 
	errors *x6_ = CHECK_NULL ( C ) ;\
 263 
	errors *x6_ = CHECK_NULL(C);\
280 
	( A ) = x6_ [1].ag_ptr ;\
 264 
	(A) = x6_[1].ag_ptr;\
281 
	( B ) = x6_->ag_ptr ;\
 265 
	(B) = x6_->ag_ptr;\
282 
    }
 266 
    }
283 
 
 267 
 
284 
#define DESTROY_CONS_list( D, A, B, C )\
 268 
#define DESTROY_CONS_list(D, A, B, C)\
285 
    {\
 269 
    {\
286 
	errors *x7_ = CHECK_NULL ( C ) ;\
 270 
	errors *x7_ = CHECK_NULL(C);\
287 
	( A ) = x7_ [1].ag_ptr ;\
 271 
	(A) = x7_[1].ag_ptr;\
288 
	( B ) = x7_->ag_ptr ;\
 272 
	(B) = x7_->ag_ptr;\
289 
	( D ) ( x7_, ( unsigned ) 2 ) ;\
 273 
	(D)(x7_, (unsigned)2);\
290 
    }
 274 
    }
291 
 
 275 
 
292 
#define PUSH_list( A, B )\
 276 
#define PUSH_list(A, B)\
293 
    {\
 277 
    {\
294 
	errors **r8_ = &( B ) ;\
 278 
	errors **r8_ = &(B);\
295 
	errors *x8_ = GEN_errors ( 2, TYPEID_stack ) ;\
 279 
	errors *x8_ = GEN_errors(2, TYPEID_stack);\
296 
	x8_ [1].ag_ptr = ( A ) ;\
 280 
	x8_[1].ag_ptr = (A);\
297 
	x8_->ag_ptr = *r8_ ;\
 281 
	x8_->ag_ptr = *r8_;\
298 
	*r8_ = x8_ ;\
 282 
	*r8_ = x8_;\
299 
    }
 283 
    }
300 
 
 284 
 
301 
#define POP_list( A, B )\
 285 
#define POP_list(A, B)\
302 
    {\
 286 
    {\
303 
	errors **r9_ = &( B ) ;\
 287 
	errors **r9_ = &(B);\
304 
	errors *x9_ = CHECK_NULL ( *r9_ ) ;\
 288 
	errors *x9_ = CHECK_NULL(*r9_);\
305 
	( A ) = x9_ [1].ag_ptr ;\
 289 
	(A) = x9_[1].ag_ptr;\
306 
	*r9_ = x9_->ag_ptr ;\
 290 
	*r9_ = x9_->ag_ptr;\
307 
	destroy_errors ( x9_, ( unsigned ) 2 ) ;\
 291 
	destroy_errors(x9_, (unsigned)2);\
308 
    }
 292 
    }
309 
 
 293 
 
310 
 
 294 
 
311 
/* Definitions for stacks */
 295 
/* Definitions for stacks */
312 
 
 296 
 
313 
#define SIZE_stack( A )			1
 297 
#define SIZE_stack(A)			1
314 
#define NULL_stack( A )			( ( errors * ) 0 )
 298 
#define NULL_stack(A)			((errors *) 0)
315 
#define IS_NULL_stack( A )		( ( A ) == 0 )
 299 
#define IS_NULL_stack(A)		((A) == 0)
316 
#define STACK_list( A )			( A )
 300 
#define STACK_list(A)			(A)
317 
#define LIST_stack( A )			( A )
 301 
#define LIST_stack(A)			(A)
318 
 
 302 
 
319 
#define COPY_stack( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 303 
#define COPY_stack(A, B)		(CHECK_NULL(A)->ag_ptr = (B))
320 
#define DEREF_stack( A )		( CHECK_NULL ( A )->ag_ptr )
 304 
#define DEREF_stack(A)			(CHECK_NULL(A)->ag_ptr)
321 
#define CONS_stack( A, B, C )\
 305 
#define CONS_stack(A, B, C)\
322 
    {\
 306 
    {\
323 
	errors *x10_ = GEN_errors ( 2, TYPEID_list ) ;\
 307 
	errors *x10_ = GEN_errors(2, TYPEID_list);\
324 
	x10_ [1].ag_ptr = ( A ) ;\
 308 
	x10_[1].ag_ptr = (A);\
325 
	x10_->ag_ptr = ( B ) ;\
 309 
	x10_->ag_ptr = (B);\
326 
	( C ) = x10_ ;\
 310 
	(C) = x10_;\
327 
    }
 311 
    }
328 
 
 312 
 
329 
#define UN_CONS_stack( A, B, C )\
 313 
#define UN_CONS_stack(A, B, C)\
330 
    {\
 314 
    {\
331 
	errors *x11_ = CHECK_NULL ( C ) ;\
 315 
	errors *x11_ = CHECK_NULL(C);\
332 
	( A ) = x11_ [1].ag_ptr ;\
 316 
	(A) = x11_[1].ag_ptr;\
333 
	( B ) = x11_->ag_ptr ;\
 317 
	(B) = x11_->ag_ptr;\
334 
    }
 318 
    }
335 
 
 319 
 
336 
#define DESTROY_CONS_stack( D, A, B, C )\
 320 
#define DESTROY_CONS_stack(D, A, B, C)\
337 
    {\
 321 
    {\
338 
	errors *x12_ = CHECK_NULL ( C ) ;\
 322 
	errors *x12_ = CHECK_NULL(C);\
339 
	( A ) = x12_ [1].ag_ptr ;\
 323 
	(A) = x12_[1].ag_ptr;\
340 
	( B ) = x12_->ag_ptr ;\
 324 
	(B) = x12_->ag_ptr;\
341 
	( D ) ( x12_, ( unsigned ) 2 ) ;\
 325 
	(D)(x12_, (unsigned)2);\
342 
    }
 326 
    }
343 
 
 327 
 
344 
#define PUSH_stack( A, B )\
 328 
#define PUSH_stack(A, B)\
345 
    {\
 329 
    {\
346 
	errors **r13_ = &( B ) ;\
 330 
	errors **r13_ = &(B);\
347 
	errors *x13_ = GEN_errors ( 2, TYPEID_stack ) ;\
 331 
	errors *x13_ = GEN_errors(2, TYPEID_stack);\
348 
	x13_ [1].ag_ptr = ( A ) ;\
 332 
	x13_[1].ag_ptr = (A);\
349 
	x13_->ag_ptr = *r13_ ;\
 333 
	x13_->ag_ptr = *r13_;\
350 
	*r13_ = x13_ ;\
 334 
	*r13_ = x13_;\
351 
    }
 335 
    }
352 
 
 336 
 
353 
#define POP_stack( A, B )\
 337 
#define POP_stack(A, B)\
354 
    {\
 338 
    {\
355 
	errors **r14_ = &( B ) ;\
 339 
	errors **r14_ = &(B);\
356 
	errors *x14_ = CHECK_NULL ( *r14_ ) ;\
 340 
	errors *x14_ = CHECK_NULL(*r14_);\
357 
	( A ) = x14_ [1].ag_ptr ;\
 341 
	(A) = x14_[1].ag_ptr;\
358 
	*r14_ = x14_->ag_ptr ;\
 342 
	*r14_ = x14_->ag_ptr;\
359 
	destroy_errors ( x14_, ( unsigned ) 2 ) ;\
 343 
	destroy_errors(x14_, (unsigned)2);\
360 
    }
 344 
    }
361 
 
 345 
 
362 
 
 346 
 
363 
/* Definitions for sizes */
 347 
/* Definitions for sizes */
364 
 
 348 
 
365 
#define SCALE( A, B )			( ( A ) * ( int ) ( B ) )
 349 
#define SCALE(A, B)			((A)*(int)(B))
366 
 
 350 
 
367 
 
 351 
 
368 
/* Definitions for primitive int */
 352 
/* Definitions for primitive int */
369 
 
 353 
 
370 
#define SIZE_int			1
 354 
#define SIZE_int			1
371 
 
 355 
 
372 
#define COPY_int( A, B )		( CHECK_NULL ( A )->ag_prim_int = ( B ) )
 356 
#define COPY_int(A, B)			(CHECK_NULL(A)->ag_prim_int = (B))
373 
#define DEREF_int( A )			( CHECK_NULL ( A )->ag_prim_int )
 357 
#define DEREF_int(A)			(CHECK_NULL(A)->ag_prim_int)
374 
#define CONS_int( A, B, C )\
 358 
#define CONS_int(A, B, C)\
375 
    {\
 359 
    {\
376 
	errors *x15_ = GEN_errors ( 2, TYPEID_list ) ;\
 360 
	errors *x15_ = GEN_errors(2, TYPEID_list);\
377 
	COPY_int ( x15_ + 1, ( A ) ) ;\
 361 
	COPY_int(x15_ + 1, (A));\
378 
	x15_->ag_ptr = ( B ) ;\
 362 
	x15_->ag_ptr = (B);\
379 
	( C ) = x15_ ;\
 363 
	(C) = x15_;\
380 
    }
 364 
    }
381 
 
 365 
 
382 
#define UN_CONS_int( A, B, C )\
 366 
#define UN_CONS_int(A, B, C)\
383 
    {\
 367 
    {\
384 
	errors *x16_ = CHECK_NULL ( C ) ;\
 368 
	errors *x16_ = CHECK_NULL(C);\
385 
	( A ) = DEREF_int ( x16_ + 1 ) ;\
 369 
	(A) = DEREF_int(x16_ + 1);\
386 
	( B ) = x16_->ag_ptr ;\
 370 
	(B) = x16_->ag_ptr;\
387 
    }
 371 
    }
388 
 
 372 
 
389 
#define DESTROY_CONS_int( D, A, B, C )\
 373 
#define DESTROY_CONS_int(D, A, B, C)\
390 
    {\
 374 
    {\
391 
	errors *x17_ = CHECK_NULL ( C ) ;\
 375 
	errors *x17_ = CHECK_NULL(C);\
392 
	( A ) = DEREF_int ( x17_ + 1 ) ;\
 376 
	(A) = DEREF_int(x17_ + 1);\
393 
	( B ) = x17_->ag_ptr ;\
 377 
	(B) = x17_->ag_ptr;\
394 
	( D ) ( x17_, ( unsigned ) 2 ) ;\
 378 
	(D)(x17_, (unsigned)2);\
395 
    }
 379 
    }
396 
 
 380 
 
397 
#define PUSH_int( A, B )\
 381 
#define PUSH_int(A, B)\
398 
    {\
 382 
    {\
399 
	errors **r18_ = &( B ) ;\
 383 
	errors **r18_ = &(B);\
400 
	errors *x18_ = GEN_errors ( 2, TYPEID_stack ) ;\
 384 
	errors *x18_ = GEN_errors(2, TYPEID_stack);\
401 
	COPY_int ( x18_ + 1, ( A ) ) ;\
 385 
	COPY_int(x18_ + 1, (A));\
402 
	x18_->ag_ptr = *r18_ ;\
 386 
	x18_->ag_ptr = *r18_;\
403 
	*r18_ = x18_ ;\
 387 
	*r18_ = x18_;\
404 
    }
 388 
    }
405 
 
 389 
 
406 
#define POP_int( A, B )\
 390 
#define POP_int(A, B)\
407 
    {\
 391 
    {\
408 
	errors **r19_ = &( B ) ;\
 392 
	errors **r19_ = &(B);\
409 
	errors *x19_ = CHECK_NULL ( *r19_ ) ;\
 393 
	errors *x19_ = CHECK_NULL(*r19_);\
410 
	( A ) = DEREF_int ( x19_ + 1 ) ;\
 394 
	(A) = DEREF_int(x19_ + 1);\
411 
	*r19_ = x19_->ag_ptr ;\
 395 
	*r19_ = x19_->ag_ptr;\
412 
	destroy_errors ( x19_, ( unsigned ) 2 ) ;\
 396 
	destroy_errors(x19_, (unsigned)2);\
413 
    }
 397 
    }
414 
 
 398 
 
415 
 
 399 
 
416 
/* Definitions for primitive string */
 400 
/* Definitions for primitive string */
417 
 
 401 
 
418 
#define SIZE_string			1
 402 
#define SIZE_string			1
419 
 
 403 
 
420 
#define COPY_string( A, B )		( CHECK_NULL ( A )->ag_prim_string = ( B ) )
 404 
#define COPY_string(A, B)		(CHECK_NULL(A)->ag_prim_string = (B))
421 
#define DEREF_string( A )		( CHECK_NULL ( A )->ag_prim_string )
 405 
#define DEREF_string(A)			(CHECK_NULL(A)->ag_prim_string)
422 
#define CONS_string( A, B, C )\
 406 
#define CONS_string(A, B, C)\
423 
    {\
 407 
    {\
424 
	errors *x20_ = GEN_errors ( 2, TYPEID_list ) ;\
 408 
	errors *x20_ = GEN_errors(2, TYPEID_list);\
425 
	COPY_string ( x20_ + 1, ( A ) ) ;\
 409 
	COPY_string(x20_ + 1, (A));\
426 
	x20_->ag_ptr = ( B ) ;\
 410 
	x20_->ag_ptr = (B);\
427 
	( C ) = x20_ ;\
 411 
	(C) = x20_;\
428 
    }
 412 
    }
429 
 
 413 
 
430 
#define UN_CONS_string( A, B, C )\
 414 
#define UN_CONS_string(A, B, C)\
431 
    {\
 415 
    {\
432 
	errors *x21_ = CHECK_NULL ( C ) ;\
 416 
	errors *x21_ = CHECK_NULL(C);\
433 
	( A ) = DEREF_string ( x21_ + 1 ) ;\
 417 
	(A) = DEREF_string(x21_ + 1);\
434 
	( B ) = x21_->ag_ptr ;\
 418 
	(B) = x21_->ag_ptr;\
435 
    }
 419 
    }
436 
 
 420 
 
437 
#define DESTROY_CONS_string( D, A, B, C )\
 421 
#define DESTROY_CONS_string(D, A, B, C)\
438 
    {\
 422 
    {\
439 
	errors *x22_ = CHECK_NULL ( C ) ;\
 423 
	errors *x22_ = CHECK_NULL(C);\
440 
	( A ) = DEREF_string ( x22_ + 1 ) ;\
 424 
	(A) = DEREF_string(x22_ + 1);\
441 
	( B ) = x22_->ag_ptr ;\
 425 
	(B) = x22_->ag_ptr;\
442 
	( D ) ( x22_, ( unsigned ) 2 ) ;\
 426 
	(D)(x22_, (unsigned)2);\
443 
    }
 427 
    }
444 
 
 428 
 
445 
#define PUSH_string( A, B )\
 429 
#define PUSH_string(A, B)\
446 
    {\
 430 
    {\
447 
	errors **r23_ = &( B ) ;\
 431 
	errors **r23_ = &(B);\
448 
	errors *x23_ = GEN_errors ( 2, TYPEID_stack ) ;\
 432 
	errors *x23_ = GEN_errors(2, TYPEID_stack);\
449 
	COPY_string ( x23_ + 1, ( A ) ) ;\
 433 
	COPY_string(x23_ + 1, (A));\
450 
	x23_->ag_ptr = *r23_ ;\
 434 
	x23_->ag_ptr = *r23_;\
451 
	*r23_ = x23_ ;\
 435 
	*r23_ = x23_;\
452 
    }
 436 
    }
453 
 
 437 
 
454 
#define POP_string( A, B )\
 438 
#define POP_string(A, B)\
455 
    {\
 439 
    {\
456 
	errors **r24_ = &( B ) ;\
 440 
	errors **r24_ = &(B);\
457 
	errors *x24_ = CHECK_NULL ( *r24_ ) ;\
 441 
	errors *x24_ = CHECK_NULL(*r24_);\
458 
	( A ) = DEREF_string ( x24_ + 1 ) ;\
 442 
	(A) = DEREF_string(x24_ + 1);\
459 
	*r24_ = x24_->ag_ptr ;\
 443 
	*r24_ = x24_->ag_ptr;\
460 
	destroy_errors ( x24_, ( unsigned ) 2 ) ;\
 444 
	destroy_errors(x24_, (unsigned)2);\
461 
    }
 445 
    }
462 
 
 446 
 
463 
 
 447 
 
464 
/* Definitions for union NAME */
 448 
/* Definitions for union NAME */
465 
 
 449 
 
466 
#define ORDER_name			( ( unsigned ) 1 )
 450 
#define ORDER_name			((unsigned) 1)
467 
#define SIZE_name			1
 451 
#define SIZE_name			1
468 
#define NULL_name			( ( NAME ) 0 )
 452 
#define NULL_name			((NAME) 0)
469 
#define IS_NULL_name( A )		( ( A ) == 0 )
 453 
#define IS_NULL_name(A)			((A) == 0)
470 
#define EQ_name( A, B )			( ( A ) == ( B ) )
 454 
#define EQ_name(A, B)			((A) == (B))
471 
 
 455 
 
472 
#define COPY_name( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 456 
#define COPY_name(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
473 
#define DEREF_name( A )			( CHECK_NULL ( A )->ag_ptr )
 457 
#define DEREF_name(A)			(CHECK_NULL(A)->ag_ptr)
474 
 
 458 
 
475 
#define CONS_name( A, B, C )\
 459 
#define CONS_name(A, B, C)\
476 
    {\
 460 
    {\
477 
	errors *x25_ = GEN_errors ( 2, TYPEID_list ) ;\
 461 
	errors *x25_ = GEN_errors(2, TYPEID_list);\
478 
	COPY_name ( x25_ + 1, ( A ) ) ;\
 462 
	COPY_name(x25_ + 1, (A));\
479 
	x25_->ag_ptr = ( B ) ;\
 463 
	x25_->ag_ptr = (B);\
480 
	( C ) = x25_ ;\
 464 
	(C) = x25_;\
481 
    }
 465 
    }
482 
 
 466 
 
483 
#define UN_CONS_name( A, B, C )\
 467 
#define UN_CONS_name(A, B, C)\
484 
    {\
 468 
    {\
485 
	errors *x26_ = CHECK_NULL ( C ) ;\
 469 
	errors *x26_ = CHECK_NULL(C);\
486 
	( A ) = DEREF_name ( x26_ + 1 ) ;\
 470 
	(A) = DEREF_name(x26_ + 1);\
487 
	( B ) = x26_->ag_ptr ;\
 471 
	(B) = x26_->ag_ptr;\
488 
    }
 472 
    }
489 
 
 473 
 
490 
#define DESTROY_CONS_name( D, A, B, C )\
 474 
#define DESTROY_CONS_name(D, A, B, C)\
491 
    {\
 475 
    {\
492 
	errors *x27_ = CHECK_NULL ( C ) ;\
 476 
	errors *x27_ = CHECK_NULL(C);\
493 
	( A ) = DEREF_name ( x27_ + 1 ) ;\
 477 
	(A) = DEREF_name(x27_ + 1);\
494 
	( B ) = x27_->ag_ptr ;\
 478 
	(B) = x27_->ag_ptr;\
495 
	( D ) ( x27_, ( unsigned ) 2 ) ;\
 479 
	(D)(x27_, (unsigned)2);\
496 
    }
 480 
    }
497 
 
 481 
 
498 
#define PUSH_name( A, B )\
 482 
#define PUSH_name(A, B)\
499 
    {\
 483 
    {\
500 
	errors **r28_ = &( B ) ;\
 484 
	errors **r28_ = &(B);\
501 
	errors *x28_ = GEN_errors ( 2, TYPEID_stack ) ;\
 485 
	errors *x28_ = GEN_errors(2, TYPEID_stack);\
502 
	COPY_name ( x28_ + 1, ( A ) ) ;\
 486 
	COPY_name(x28_ + 1, (A));\
503 
	x28_->ag_ptr = *r28_ ;\
 487 
	x28_->ag_ptr = *r28_;\
504 
	*r28_ = x28_ ;\
 488 
	*r28_ = x28_;\
505 
    }
 489 
    }
506 
 
 490 
 
507 
#define POP_name( A, B )\
 491 
#define POP_name(A, B)\
508 
    {\
 492 
    {\
509 
	errors **r29_ = &( B ) ;\
 493 
	errors **r29_ = &(B);\
510 
	errors *x29_ = CHECK_NULL ( *r29_ ) ;\
 494 
	errors *x29_ = CHECK_NULL(*r29_);\
511 
	( A ) = DEREF_name ( x29_ + 1 ) ;\
 495 
	(A) = DEREF_name(x29_ + 1);\
512 
	*r29_ = x29_->ag_ptr ;\
 496 
	*r29_ = x29_->ag_ptr;\
513 
	destroy_errors ( x29_, ( unsigned ) 2 ) ;\
 497 
	destroy_errors(x29_, (unsigned)2);\
514 
    }
 498 
    }
515 
 
 499 
 
516 
 
 500 
 
517 
/* Definitions for union MESSAGE */
 501 
/* Definitions for union MESSAGE */
518 
 
 502 
 
519 
#define ORDER_msg			( ( unsigned ) 2 )
 503 
#define ORDER_msg			((unsigned) 2)
520 
#define SIZE_msg			1
 504 
#define SIZE_msg			1
521 
#define NULL_msg			( ( MESSAGE ) 0 )
 505 
#define NULL_msg			((MESSAGE) 0)
522 
#define IS_NULL_msg( A )		( ( A ) == 0 )
 506 
#define IS_NULL_msg(A)			((A) == 0)
523 
#define EQ_msg( A, B )			( ( A ) == ( B ) )
 507 
#define EQ_msg(A, B)			((A) == (B))
524 
 
 508 
 
525 
#define COPY_msg( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 509 
#define COPY_msg(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
526 
#define DEREF_msg( A )			( CHECK_NULL ( A )->ag_ptr )
 510 
#define DEREF_msg(A)			(CHECK_NULL(A)->ag_ptr)
527 
 
 511 
 
528 
#define CONS_msg( A, B, C )\
 512 
#define CONS_msg(A, B, C)\
529 
    {\
 513 
    {\
530 
	errors *x30_ = GEN_errors ( 2, TYPEID_list ) ;\
 514 
	errors *x30_ = GEN_errors(2, TYPEID_list);\
531 
	COPY_msg ( x30_ + 1, ( A ) ) ;\
 515 
	COPY_msg(x30_ + 1, (A));\
532 
	x30_->ag_ptr = ( B ) ;\
 516 
	x30_->ag_ptr = (B);\
533 
	( C ) = x30_ ;\
 517 
	(C) = x30_;\
534 
    }
 518 
    }
535 
 
 519 
 
536 
#define UN_CONS_msg( A, B, C )\
 520 
#define UN_CONS_msg(A, B, C)\
537 
    {\
 521 
    {\
538 
	errors *x31_ = CHECK_NULL ( C ) ;\
 522 
	errors *x31_ = CHECK_NULL(C);\
539 
	( A ) = DEREF_msg ( x31_ + 1 ) ;\
 523 
	(A) = DEREF_msg(x31_ + 1);\
540 
	( B ) = x31_->ag_ptr ;\
 524 
	(B) = x31_->ag_ptr;\
541 
    }
 525 
    }
542 
 
 526 
 
543 
#define DESTROY_CONS_msg( D, A, B, C )\
 527 
#define DESTROY_CONS_msg(D, A, B, C)\
544 
    {\
 528 
    {\
545 
	errors *x32_ = CHECK_NULL ( C ) ;\
 529 
	errors *x32_ = CHECK_NULL(C);\
546 
	( A ) = DEREF_msg ( x32_ + 1 ) ;\
 530 
	(A) = DEREF_msg(x32_ + 1);\
547 
	( B ) = x32_->ag_ptr ;\
 531 
	(B) = x32_->ag_ptr;\
548 
	( D ) ( x32_, ( unsigned ) 2 ) ;\
 532 
	(D)(x32_, (unsigned)2);\
549 
    }
 533 
    }
550 
 
 534 
 
551 
#define PUSH_msg( A, B )\
 535 
#define PUSH_msg(A, B)\
552 
    {\
 536 
    {\
553 
	errors **r33_ = &( B ) ;\
 537 
	errors **r33_ = &(B);\
554 
	errors *x33_ = GEN_errors ( 2, TYPEID_stack ) ;\
 538 
	errors *x33_ = GEN_errors(2, TYPEID_stack);\
555 
	COPY_msg ( x33_ + 1, ( A ) ) ;\
 539 
	COPY_msg(x33_ + 1, (A));\
556 
	x33_->ag_ptr = *r33_ ;\
 540 
	x33_->ag_ptr = *r33_;\
557 
	*r33_ = x33_ ;\
 541 
	*r33_ = x33_;\
558 
    }
 542 
    }
559 
 
 543 
 
560 
#define POP_msg( A, B )\
 544 
#define POP_msg(A, B)\
561 
    {\
 545 
    {\
562 
	errors **r34_ = &( B ) ;\
 546 
	errors **r34_ = &(B);\
563 
	errors *x34_ = CHECK_NULL ( *r34_ ) ;\
 547 
	errors *x34_ = CHECK_NULL(*r34_);\
564 
	( A ) = DEREF_msg ( x34_ + 1 ) ;\
 548 
	(A) = DEREF_msg(x34_ + 1);\
565 
	*r34_ = x34_->ag_ptr ;\
 549 
	*r34_ = x34_->ag_ptr;\
566 
	destroy_errors ( x34_, ( unsigned ) 2 ) ;\
 550 
	destroy_errors(x34_, (unsigned)2);\
567 
    }
 551 
    }
568 
 
 552 
 
569 
 
 553 
 
570 
/* Definitions for union MAP */
 554 
/* Definitions for union MAP */
571 
 
 555 
 
572 
#define ORDER_map			( ( unsigned ) 1 )
 556 
#define ORDER_map			((unsigned) 1)
573 
#define SIZE_map			1
 557 
#define SIZE_map			1
574 
#define NULL_map			( ( MAP ) 0 )
 558 
#define NULL_map			((MAP) 0)
575 
#define IS_NULL_map( A )		( ( A ) == 0 )
 559 
#define IS_NULL_map(A)			((A) == 0)
576 
#define EQ_map( A, B )			( ( A ) == ( B ) )
 560 
#define EQ_map(A, B)			((A) == (B))
577 
 
 561 
 
578 
#define COPY_map( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 562 
#define COPY_map(A, B)			(CHECK_NULL(A)->ag_ptr = (B))
579 
#define DEREF_map( A )			( CHECK_NULL ( A )->ag_ptr )
 563 
#define DEREF_map(A)			(CHECK_NULL(A)->ag_ptr)
580 
 
 564 
 
581 
#define CONS_map( A, B, C )\
 565 
#define CONS_map(A, B, C)\
582 
    {\
 566 
    {\
583 
	errors *x35_ = GEN_errors ( 2, TYPEID_list ) ;\
 567 
	errors *x35_ = GEN_errors(2, TYPEID_list);\
584 
	COPY_map ( x35_ + 1, ( A ) ) ;\
 568 
	COPY_map(x35_ + 1, (A));\
585 
	x35_->ag_ptr = ( B ) ;\
 569 
	x35_->ag_ptr = (B);\
586 
	( C ) = x35_ ;\
 570 
	(C) = x35_;\
587 
    }
 571 
    }
588 
 
 572 
 
589 
#define UN_CONS_map( A, B, C )\
 573 
#define UN_CONS_map(A, B, C)\
590 
    {\
 574 
    {\
591 
	errors *x36_ = CHECK_NULL ( C ) ;\
 575 
	errors *x36_ = CHECK_NULL(C);\
592 
	( A ) = DEREF_map ( x36_ + 1 ) ;\
 576 
	(A) = DEREF_map(x36_ + 1);\
593 
	( B ) = x36_->ag_ptr ;\
 577 
	(B) = x36_->ag_ptr;\
594 
    }
 578 
    }
595 
 
 579 
 
596 
#define DESTROY_CONS_map( D, A, B, C )\
 580 
#define DESTROY_CONS_map(D, A, B, C)\
597 
    {\
 581 
    {\
598 
	errors *x37_ = CHECK_NULL ( C ) ;\
 582 
	errors *x37_ = CHECK_NULL(C);\
599 
	( A ) = DEREF_map ( x37_ + 1 ) ;\
 583 
	(A) = DEREF_map(x37_ + 1);\
600 
	( B ) = x37_->ag_ptr ;\
 584 
	(B) = x37_->ag_ptr;\
601 
	( D ) ( x37_, ( unsigned ) 2 ) ;\
 585 
	(D)(x37_, (unsigned)2);\
602 
    }
 586 
    }
603 
 
 587 
 
604 
#define PUSH_map( A, B )\
 588 
#define PUSH_map(A, B)\
605 
    {\
 589 
    {\
606 
	errors **r38_ = &( B ) ;\
 590 
	errors **r38_ = &(B);\
607 
	errors *x38_ = GEN_errors ( 2, TYPEID_stack ) ;\
 591 
	errors *x38_ = GEN_errors(2, TYPEID_stack);\
608 
	COPY_map ( x38_ + 1, ( A ) ) ;\
 592 
	COPY_map(x38_ + 1, (A));\
609 
	x38_->ag_ptr = *r38_ ;\
 593 
	x38_->ag_ptr = *r38_;\
610 
	*r38_ = x38_ ;\
 594 
	*r38_ = x38_;\
611 
    }
 595 
    }
612 
 
 596 
 
613 
#define POP_map( A, B )\
 597 
#define POP_map(A, B)\
614 
    {\
 598 
    {\
615 
	errors **r39_ = &( B ) ;\
 599 
	errors **r39_ = &(B);\
616 
	errors *x39_ = CHECK_NULL ( *r39_ ) ;\
 600 
	errors *x39_ = CHECK_NULL(*r39_);\
617 
	( A ) = DEREF_map ( x39_ + 1 ) ;\
 601 
	(A) = DEREF_map(x39_ + 1);\
618 
	*r39_ = x39_->ag_ptr ;\
 602 
	*r39_ = x39_->ag_ptr;\
619 
	destroy_errors ( x39_, ( unsigned ) 2 ) ;\
 603 
	destroy_errors(x39_, (unsigned)2);\
620 
    }
 604 
    }
621 
 
 605 
 
622 
 
 606 
 
623 
/* Definitions for union PARAM */
 607 
/* Definitions for union PARAM */
624 
 
 608 
 
625 
#define ORDER_param			( ( unsigned ) 1 )
 609 
#define ORDER_param			((unsigned) 1)
626 
#define SIZE_param			1
 610 
#define SIZE_param			1
627 
#define NULL_param			( ( PARAM ) 0 )
 611 
#define NULL_param			((PARAM) 0)
628 
#define IS_NULL_param( A )		( ( A ) == 0 )
 612 
#define IS_NULL_param(A)		((A) == 0)
629 
#define EQ_param( A, B )		( ( A ) == ( B ) )
 613 
#define EQ_param(A, B)			((A) == (B))
630 
 
 614 
 
631 
#define COPY_param( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 615 
#define COPY_param(A, B)		(CHECK_NULL(A)->ag_ptr = (B))
632 
#define DEREF_param( A )		( CHECK_NULL ( A )->ag_ptr )
 616 
#define DEREF_param(A)			(CHECK_NULL(A)->ag_ptr)
633 
 
 617 
 
634 
#define CONS_param( A, B, C )\
 618 
#define CONS_param(A, B, C)\
635 
    {\
 619 
    {\
636 
	errors *x40_ = GEN_errors ( 2, TYPEID_list ) ;\
 620 
	errors *x40_ = GEN_errors(2, TYPEID_list);\
637 
	COPY_param ( x40_ + 1, ( A ) ) ;\
 621 
	COPY_param(x40_ + 1, (A));\
638 
	x40_->ag_ptr = ( B ) ;\
 622 
	x40_->ag_ptr = (B);\
639 
	( C ) = x40_ ;\
 623 
	(C) = x40_;\
640 
    }
 624 
    }
641 
 
 625 
 
642 
#define UN_CONS_param( A, B, C )\
 626 
#define UN_CONS_param(A, B, C)\
643 
    {\
 627 
    {\
644 
	errors *x41_ = CHECK_NULL ( C ) ;\
 628 
	errors *x41_ = CHECK_NULL(C);\
645 
	( A ) = DEREF_param ( x41_ + 1 ) ;\
 629 
	(A) = DEREF_param(x41_ + 1);\
646 
	( B ) = x41_->ag_ptr ;\
 630 
	(B) = x41_->ag_ptr;\
647 
    }
 631 
    }
648 
 
 632 
 
649 
#define DESTROY_CONS_param( D, A, B, C )\
 633 
#define DESTROY_CONS_param(D, A, B, C)\
650 
    {\
 634 
    {\
651 
	errors *x42_ = CHECK_NULL ( C ) ;\
 635 
	errors *x42_ = CHECK_NULL(C);\
652 
	( A ) = DEREF_param ( x42_ + 1 ) ;\
 636 
	(A) = DEREF_param(x42_ + 1);\
653 
	( B ) = x42_->ag_ptr ;\
 637 
	(B) = x42_->ag_ptr;\
654 
	( D ) ( x42_, ( unsigned ) 2 ) ;\
 638 
	(D)(x42_, (unsigned)2);\
655 
    }
 639 
    }
656 
 
 640 
 
657 
#define PUSH_param( A, B )\
 641 
#define PUSH_param(A, B)\
658 
    {\
 642 
    {\
659 
	errors **r43_ = &( B ) ;\
 643 
	errors **r43_ = &(B);\
660 
	errors *x43_ = GEN_errors ( 2, TYPEID_stack ) ;\
 644 
	errors *x43_ = GEN_errors(2, TYPEID_stack);\
661 
	COPY_param ( x43_ + 1, ( A ) ) ;\
 645 
	COPY_param(x43_ + 1, (A));\
662 
	x43_->ag_ptr = *r43_ ;\
 646 
	x43_->ag_ptr = *r43_;\
663 
	*r43_ = x43_ ;\
 647 
	*r43_ = x43_;\
664 
    }
 648 
    }
665 
 
 649 
 
666 
#define POP_param( A, B )\
 650 
#define POP_param(A, B)\
667 
    {\
 651 
    {\
668 
	errors **r44_ = &( B ) ;\
 652 
	errors **r44_ = &(B);\
669 
	errors *x44_ = CHECK_NULL ( *r44_ ) ;\
 653 
	errors *x44_ = CHECK_NULL(*r44_);\
670 
	( A ) = DEREF_param ( x44_ + 1 ) ;\
 654 
	(A) = DEREF_param(x44_ + 1);\
671 
	*r44_ = x44_->ag_ptr ;\
 655 
	*r44_ = x44_->ag_ptr;\
672 
	destroy_errors ( x44_, ( unsigned ) 2 ) ;\
 656 
	destroy_errors(x44_, (unsigned)2);\
673 
    }
 657 
    }
674 
 
 658 
 
675 
 
 659 
 
676 
/* Definitions for union ENTRY */
 660 
/* Definitions for union ENTRY */
677 
 
 661 
 
678 
#define ORDER_entry			( ( unsigned ) 1 )
 662 
#define ORDER_entry			((unsigned) 1)
679 
#define SIZE_entry			1
 663 
#define SIZE_entry			1
680 
#define NULL_entry			( ( ENTRY ) 0 )
 664 
#define NULL_entry			((ENTRY) 0)
681 
#define IS_NULL_entry( A )		( ( A ) == 0 )
 665 
#define IS_NULL_entry(A)		((A) == 0)
682 
#define EQ_entry( A, B )		( ( A ) == ( B ) )
 666 
#define EQ_entry(A, B)			((A) == (B))
683 
 
 667 
 
684 
#define COPY_entry( A, B )		( CHECK_NULL ( A )->ag_ptr = ( B ) )
 668 
#define COPY_entry(A, B)		(CHECK_NULL(A)->ag_ptr = (B))
685 
#define DEREF_entry( A )		( CHECK_NULL ( A )->ag_ptr )
 669 
#define DEREF_entry(A)			(CHECK_NULL(A)->ag_ptr)
686 
 
 670 
 
687 
#define CONS_entry( A, B, C )\
 671 
#define CONS_entry(A, B, C)\
688 
    {\
 672 
    {\
689 
	errors *x45_ = GEN_errors ( 2, TYPEID_list ) ;\
 673 
	errors *x45_ = GEN_errors(2, TYPEID_list);\
690 
	COPY_entry ( x45_ + 1, ( A ) ) ;\
 674 
	COPY_entry(x45_ + 1, (A));\
691 
	x45_->ag_ptr = ( B ) ;\
 675 
	x45_->ag_ptr = (B);\
692 
	( C ) = x45_ ;\
 676 
	(C) = x45_;\
693 
    }
 677 
    }
694 
 
 678 
 
695 
#define UN_CONS_entry( A, B, C )\
 679 
#define UN_CONS_entry(A, B, C)\
696 
    {\
 680 
    {\
697 
	errors *x46_ = CHECK_NULL ( C ) ;\
 681 
	errors *x46_ = CHECK_NULL(C);\
698 
	( A ) = DEREF_entry ( x46_ + 1 ) ;\
 682 
	(A) = DEREF_entry(x46_ + 1);\
699 
	( B ) = x46_->ag_ptr ;\
 683 
	(B) = x46_->ag_ptr;\
700 
    }
 684 
    }
701 
 
 685 
 
702 
#define DESTROY_CONS_entry( D, A, B, C )\
 686 
#define DESTROY_CONS_entry(D, A, B, C)\
703 
    {\
 687 
    {\
704 
	errors *x47_ = CHECK_NULL ( C ) ;\
 688 
	errors *x47_ = CHECK_NULL(C);\
705 
	( A ) = DEREF_entry ( x47_ + 1 ) ;\
 689 
	(A) = DEREF_entry(x47_ + 1);\
706 
	( B ) = x47_->ag_ptr ;\
 690 
	(B) = x47_->ag_ptr;\
707 
	( D ) ( x47_, ( unsigned ) 2 ) ;\
 691 
	(D)(x47_, (unsigned)2);\
708 
    }
 692 
    }
709 
 
 693 
 
710 
#define PUSH_entry( A, B )\
 694 
#define PUSH_entry(A, B)\
711 
    {\
 695 
    {\
712 
	errors **r48_ = &( B ) ;\
 696 
	errors **r48_ = &(B);\
713 
	errors *x48_ = GEN_errors ( 2, TYPEID_stack ) ;\
 697 
	errors *x48_ = GEN_errors(2, TYPEID_stack);\
714 
	COPY_entry ( x48_ + 1, ( A ) ) ;\
 698 
	COPY_entry(x48_ + 1, (A));\
715 
	x48_->ag_ptr = *r48_ ;\
 699 
	x48_->ag_ptr = *r48_;\
716 
	*r48_ = x48_ ;\
 700 
	*r48_ = x48_;\
717 
    }
 701 
    }
718 
 
 702 
 
719 
#define POP_entry( A, B )\
 703 
#define POP_entry(A, B)\
720 
    {\
 704 
    {\
721 
	errors **r49_ = &( B ) ;\
 705 
	errors **r49_ = &(B);\
722 
	errors *x49_ = CHECK_NULL ( *r49_ ) ;\
 706 
	errors *x49_ = CHECK_NULL(*r49_);\
723 
	( A ) = DEREF_entry ( x49_ + 1 ) ;\
 707 
	(A) = DEREF_entry(x49_ + 1);\
724 
	*r49_ = x49_->ag_ptr ;\
 708 
	*r49_ = x49_->ag_ptr;\
725 
	destroy_errors ( x49_, ( unsigned ) 2 ) ;\
 709 
	destroy_errors(x49_, (unsigned)2);\
726 
    }
 710 
    }
727 
 
 711 
 
728 
 
 712 
 
729 
/* Maximum allocation size */
 713 
/* Maximum allocation size */
730 
 
 714