Subversion Repositories tendra.SVN

Rev

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

Rev Author Line No. Line
2 7u83 1 
/*
2 
    		 Crown Copyright (c) 1997, 1998
3 
 
4 
    This TenDRA(r) Computer Program is subject to Copyright
5 
    owned by the United Kingdom Secretary of State for Defence
6 
    acting through the Defence Evaluation and Research Agency
7 
    (DERA).  It is made available to Recipients with a
8 
    royalty-free licence for its use, reproduction, transfer
9 
    to other parties and amendment for any purpose not excluding
10 
    product development provided that any such use et cetera
11 
    shall be deemed to be acceptance of the following conditions:-
12 
 
13 
        (1) Its Recipients shall ensure that this Notice is
14 
        reproduced upon any copies or amended versions of it;
15 
 
16 
        (2) Any amended version of it shall be clearly marked to
17 
        show both the nature of and the organisation responsible
18 
        for the relevant amendment or amendments;
19 
 
20 
        (3) Its onward transfer from a recipient to another
21 
        party shall be deemed to be that party's acceptance of
22 
        these conditions;
23 
 
24 
        (4) DERA gives no warranty or assurance as to its
25 
        quality or suitability for any purpose and DERA accepts
26 
        no liability whatsoever in relation to any use to which
27 
        it may be put.
28 
*/
29 
 
30 
/*
31 
    AUTOMATICALLY GENERATED FROM ALGEBRA c_class (VERSION 1.1)
32 
    BY calculus (VERSION 1.2)
33 
*/
34 
 
35 
#ifndef EXP_OPS_H_INCLUDED
36 
#define EXP_OPS_H_INCLUDED
37 
 
38 
/* Operations for union EXP */
39 
 
7 7u83 40 
#define TAG_exp(P)			(CHECK_NULL(P)->ag_tag)
2 7u83 41 
 
42 
 
43 
/* Operations for component type of union EXP */
44 
 
7 7u83 45 
#define exp_type(P)			(CHECK_NULL(P) + 1)
2 7u83 46 
 
47 
 
48 
/* Operations for field set identifier_etc of union EXP */
49 
 
7 7u83 50 
#define exp_identifier_etc_tag		((unsigned)4)
51 
#define IS_exp_identifier_etc(P)	((unsigned)(CHECK_NULL(P)->ag_tag - 0) < (unsigned)4)
2 7u83 52 
 
7 7u83 53 
#define exp_identifier_etc_id(P)	(CHECK_TAG_ETC((P), 0, 4) + 2)
54 
#define exp_identifier_etc_qual(P)	(CHECK_TAG_ETC((P), 0, 4) + 3)
2 7u83 55 
 
7 7u83 56 
#define MAKE_exp_identifier_etc(tag, type_, id_, qual_, c_class_exp)\
2 7u83 57 
    {\
7 7u83 58 
	c_class *x486_ = GEN_c_class(4, TYPEID_exp);\
59 
	x486_->ag_tag = (tag);\
60 
	COPY_type(x486_ + 1, (type_));\
61 
	COPY_id(x486_ + 2, (id_));\
62 
	COPY_qual(x486_ + 3, (qual_));\
63 
	(c_class_exp) = CHECK_TAG_ETC(x486_, 0, 4);\
2 7u83 64 
    }
65 
 
7 7u83 66 
#define MODIFY_exp_identifier_etc(tag, c_class_exp)\
2 7u83 67 
    {\
7 7u83 68 
	c_class *x487_ = CHECK_TAG_ETC ((c_class_exp), 0, 4);\
69 
	x487_->ag_tag = (tag);\
70 
	(void) CHECK_TAG_ETC (x487_, 0, 4);\
2 7u83 71 
    }
72 
 
7 7u83 73 
#define DECONS_exp_identifier_etc(type_, id_, qual_, c_class_exp)\
2 7u83 74 
    {\
7 7u83 75 
	c_class *x488_ = CHECK_TAG_ETC((c_class_exp), 0, 4);\
76 
	(type_) = DEREF_type(x488_ + 1);\
77 
	(id_) = DEREF_id(x488_ + 2);\
78 
	(qual_) = DEREF_qual(x488_ + 3);\
2 7u83 79 
    }
80 
 
7 7u83 81 
#define DESTROY_exp_identifier_etc(destroyer_, type_, id_, qual_, c_class_exp)\
2 7u83 82 
    {\
7 7u83 83 
	c_class *x489_ = CHECK_TAG_ETC((c_class_exp), 0, 4);\
84 
	(type_) = DEREF_type(x489_ + 1);\
85 
	(id_) = DEREF_id(x489_ + 2);\
86 
	(qual_) = DEREF_qual(x489_ + 3);\
87 
	(destroyer_)(x489_, (unsigned)4);\
2 7u83 88 
    }
89 
 
90 
 
91 
/* Operations for field identifier of union EXP */
92 
 
7 7u83 93 
#define exp_identifier_tag		((unsigned)0)
94 
#define IS_exp_identifier(P)		(CHECK_NULL(P)->ag_tag == 0)
2 7u83 95 
 
7 7u83 96 
#define exp_identifier_id(P)		(CHECK_TAG((P), 0) + 2)
97 
#define exp_identifier_qual(P)		(CHECK_TAG((P), 0) + 3)
2 7u83 98 
 
7 7u83 99 
#define MAKE_exp_identifier(type_, id_, qual_, c_class_exp)\
2 7u83 100 
    {\
7 7u83 101 
	c_class *x490_ = GEN_c_class(4, TYPEID_exp);\
102 
	x490_->ag_tag = 0;\
103 
	COPY_type(x490_ + 1, (type_));\
104 
	COPY_id(x490_ + 2, (id_));\
105 
	COPY_qual(x490_ + 3, (qual_));\
106 
	(c_class_exp) = x490_;\
2 7u83 107 
    }
108 
 
7 7u83 109 
#define DECONS_exp_identifier(type_, id_, qual_, c_class_exp)\
2 7u83 110 
    {\
7 7u83 111 
	c_class *x491_ = CHECK_TAG((c_class_exp), 0);\
112 
	(type_) = DEREF_type(x491_ + 1);\
113 
	(id_) = DEREF_id(x491_ + 2);\
114 
	(qual_) = DEREF_qual(x491_ + 3);\
2 7u83 115 
    }
116 
 
7 7u83 117 
#define DESTROY_exp_identifier(destroyer_, type_, id_, qual_, c_class_exp)\
2 7u83 118 
    {\
7 7u83 119 
	c_class *x492_ = CHECK_TAG((c_class_exp), 0);\
120 
	(type_) = DEREF_type(x492_ + 1);\
121 
	(id_) = DEREF_id(x492_ + 2);\
122 
	(qual_) = DEREF_qual(x492_ + 3);\
123 
	(destroyer_)(x492_, (unsigned)4);\
2 7u83 124 
    }
125 
 
126 
 
127 
/* Operations for field member of union EXP */
128 
 
7 7u83 129 
#define exp_member_tag			((unsigned)1)
130 
#define IS_exp_member(P)		(CHECK_NULL(P)->ag_tag == 1)
2 7u83 131 
 
7 7u83 132 
#define exp_member_id(P)		(CHECK_TAG((P), 1) + 2)
133 
#define exp_member_qual(P)		(CHECK_TAG((P), 1) + 3)
2 7u83 134 
 
7 7u83 135 
#define MAKE_exp_member(type_, id_, qual_, c_class_exp)\
2 7u83 136 
    {\
7 7u83 137 
	c_class *x493_ = GEN_c_class(4, TYPEID_exp);\
138 
	x493_->ag_tag = 1;\
139 
	COPY_type(x493_ + 1, (type_));\
140 
	COPY_id(x493_ + 2, (id_));\
141 
	COPY_qual(x493_ + 3, (qual_));\
142 
	(c_class_exp) = x493_;\
2 7u83 143 
    }
144 
 
7 7u83 145 
#define DECONS_exp_member(type_, id_, qual_, c_class_exp)\
2 7u83 146 
    {\
7 7u83 147 
	c_class *x494_ = CHECK_TAG((c_class_exp), 1);\
148 
	(type_) = DEREF_type(x494_ + 1);\
149 
	(id_) = DEREF_id(x494_ + 2);\
150 
	(qual_) = DEREF_qual(x494_ + 3);\
2 7u83 151 
    }
152 
 
7 7u83 153 
#define DESTROY_exp_member(destroyer_, type_, id_, qual_, c_class_exp)\
2 7u83 154 
    {\
7 7u83 155 
	c_class *x495_ = CHECK_TAG((c_class_exp), 1);\
156 
	(type_) = DEREF_type(x495_ + 1);\
157 
	(id_) = DEREF_id(x495_ + 2);\
158 
	(qual_) = DEREF_qual(x495_ + 3);\
159 
	(destroyer_)(x495_, (unsigned)4);\
2 7u83 160 
    }
161 
 
162 
 
163 
/* Operations for field ambiguous of union EXP */
164 
 
7 7u83 165 
#define exp_ambiguous_tag		((unsigned)2)
166 
#define IS_exp_ambiguous(P)		(CHECK_NULL(P)->ag_tag == 2)
2 7u83 167 
 
7 7u83 168 
#define exp_ambiguous_id(P)		(CHECK_TAG((P), 2) + 2)
169 
#define exp_ambiguous_qual(P)		(CHECK_TAG((P), 2) + 3)
2 7u83 170 
 
7 7u83 171 
#define MAKE_exp_ambiguous(type_, id_, qual_, c_class_exp)\
2 7u83 172 
    {\
7 7u83 173 
	c_class *x496_ = GEN_c_class(4, TYPEID_exp);\
174 
	x496_->ag_tag = 2;\
175 
	COPY_type(x496_ + 1, (type_));\
176 
	COPY_id(x496_ + 2, (id_));\
177 
	COPY_qual(x496_ + 3, (qual_));\
178 
	(c_class_exp) = x496_;\
2 7u83 179 
    }
180 
 
7 7u83 181 
#define DECONS_exp_ambiguous(type_, id_, qual_, c_class_exp)\
2 7u83 182 
    {\
7 7u83 183 
	c_class *x497_ = CHECK_TAG((c_class_exp), 2);\
184 
	(type_) = DEREF_type(x497_ + 1);\
185 
	(id_) = DEREF_id(x497_ + 2);\
186 
	(qual_) = DEREF_qual(x497_ + 3);\
2 7u83 187 
    }
188 
 
7 7u83 189 
#define DESTROY_exp_ambiguous(destroyer_, type_, id_, qual_, c_class_exp)\
2 7u83 190 
    {\
7 7u83 191 
	c_class *x498_ = CHECK_TAG((c_class_exp), 2);\
192 
	(type_) = DEREF_type(x498_ + 1);\
193 
	(id_) = DEREF_id(x498_ + 2);\
194 
	(qual_) = DEREF_qual(x498_ + 3);\
195 
	(destroyer_)(x498_, (unsigned)4);\
2 7u83 196 
    }
197 
 
198 
 
199 
/* Operations for field undeclared of union EXP */
200 
 
7 7u83 201 
#define exp_undeclared_tag		((unsigned)3)
202 
#define IS_exp_undeclared(P)		(CHECK_NULL(P)->ag_tag == 3)
2 7u83 203 
 
7 7u83 204 
#define exp_undeclared_id(P)		(CHECK_TAG((P), 3) + 2)
205 
#define exp_undeclared_qual(P)		(CHECK_TAG((P), 3) + 3)
2 7u83 206 
 
7 7u83 207 
#define MAKE_exp_undeclared(type_, id_, qual_, c_class_exp)\
2 7u83 208 
    {\
7 7u83 209 
	c_class *x499_ = GEN_c_class(4, TYPEID_exp);\
210 
	x499_->ag_tag = 3;\
211 
	COPY_type(x499_ + 1, (type_));\
212 
	COPY_id(x499_ + 2, (id_));\
213 
	COPY_qual(x499_ + 3, (qual_));\
214 
	(c_class_exp) = x499_;\
2 7u83 215 
    }
216 
 
7 7u83 217 
#define DECONS_exp_undeclared(type_, id_, qual_, c_class_exp)\
2 7u83 218 
    {\
7 7u83 219 
	c_class *x500_ = CHECK_TAG((c_class_exp), 3);\
220 
	(type_) = DEREF_type(x500_ + 1);\
221 
	(id_) = DEREF_id(x500_ + 2);\
222 
	(qual_) = DEREF_qual(x500_ + 3);\
2 7u83 223 
    }
224 
 
7 7u83 225 
#define DESTROY_exp_undeclared(destroyer_, type_, id_, qual_, c_class_exp)\
2 7u83 226 
    {\
7 7u83 227 
	c_class *x501_ = CHECK_TAG((c_class_exp), 3);\
228 
	(type_) = DEREF_type(x501_ + 1);\
229 
	(id_) = DEREF_id(x501_ + 2);\
230 
	(qual_) = DEREF_qual(x501_ + 3);\
231 
	(destroyer_)(x501_, (unsigned)4);\
2 7u83 232 
    }
233 
 
234 
 
235 
/* Operations for field int_lit of union EXP */
236 
 
7 7u83 237 
#define exp_int_lit_tag			((unsigned)4)
238 
#define IS_exp_int_lit(P)		(CHECK_NULL(P)->ag_tag == 4)
2 7u83 239 
 
7 7u83 240 
#define exp_int_lit_nat(P)		(CHECK_TAG((P), 4) + 2)
241 
#define exp_int_lit_etag(P)		(CHECK_TAG((P), 4) + 3)
2 7u83 242 
 
7 7u83 243 
#define MAKE_exp_int_lit(type_, nat_, etag_, c_class_exp)\
2 7u83 244 
    {\
7 7u83 245 
	c_class *x502_ = GEN_c_class(4, TYPEID_exp);\
246 
	x502_->ag_tag = 4;\
247 
	COPY_type(x502_ + 1, (type_));\
248 
	COPY_nat(x502_ + 2, (nat_));\
249 
	COPY_unsigned(x502_ + 3, (etag_));\
250 
	(c_class_exp) = x502_;\
2 7u83 251 
    }
252 
 
7 7u83 253 
#define DECONS_exp_int_lit(type_, nat_, etag_, c_class_exp)\
2 7u83 254 
    {\
7 7u83 255 
	c_class *x503_ = CHECK_TAG((c_class_exp), 4);\
256 
	(type_) = DEREF_type(x503_ + 1);\
257 
	(nat_) = DEREF_nat(x503_ + 2);\
258 
	(etag_) = DEREF_unsigned(x503_ + 3);\
2 7u83 259 
    }
260 
 
7 7u83 261 
#define DESTROY_exp_int_lit(destroyer_, type_, nat_, etag_, c_class_exp)\
2 7u83 262 
    {\
7 7u83 263 
	c_class *x504_ = CHECK_TAG((c_class_exp), 4);\
264 
	(type_) = DEREF_type(x504_ + 1);\
265 
	(nat_) = DEREF_nat(x504_ + 2);\
266 
	(etag_) = DEREF_unsigned(x504_ + 3);\
267 
	(destroyer_)(x504_, (unsigned)4);\
2 7u83 268 
    }
269 
 
270 
 
271 
/* Operations for field float_lit of union EXP */
272 
 
7 7u83 273 
#define exp_float_lit_tag		((unsigned)5)
274 
#define IS_exp_float_lit(P)		(CHECK_NULL(P)->ag_tag == 5)
2 7u83 275 
 
7 7u83 276 
#define exp_float_lit_flt(P)		(CHECK_TAG((P), 5) + 2)
2 7u83 277 
 
7 7u83 278 
#define MAKE_exp_float_lit(type_, flt_, c_class_exp)\
2 7u83 279 
    {\
7 7u83 280 
	c_class *x505_ = GEN_c_class(3, TYPEID_exp);\
281 
	x505_->ag_tag = 5;\
282 
	COPY_type(x505_ + 1, (type_));\
283 
	COPY_flt(x505_ + 2, (flt_));\
284 
	(c_class_exp) = x505_;\
2 7u83 285 
    }
286 
 
7 7u83 287 
#define DECONS_exp_float_lit(type_, flt_, c_class_exp)\
2 7u83 288 
    {\
7 7u83 289 
	c_class *x506_ = CHECK_TAG((c_class_exp), 5);\
290 
	(type_) = DEREF_type(x506_ + 1);\
291 
	(flt_) = DEREF_flt(x506_ + 2);\
2 7u83 292 
    }
293 
 
7 7u83 294 
#define DESTROY_exp_float_lit(destroyer_, type_, flt_, c_class_exp)\
2 7u83 295 
    {\
7 7u83 296 
	c_class *x507_ = CHECK_TAG((c_class_exp), 5);\
297 
	(type_) = DEREF_type(x507_ + 1);\
298 
	(flt_) = DEREF_flt(x507_ + 2);\
299 
	(destroyer_)(x507_, (unsigned)3);\
2 7u83 300 
    }
301 
 
302 
 
303 
/* Operations for field char_lit of union EXP */
304 
 
7 7u83 305 
#define exp_char_lit_tag		((unsigned)6)
306 
#define IS_exp_char_lit(P)		(CHECK_NULL(P)->ag_tag == 6)
2 7u83 307 
 
7 7u83 308 
#define exp_char_lit_str(P)		(CHECK_TAG((P), 6) + 2)
309 
#define exp_char_lit_digit(P)		(CHECK_TAG((P), 6) + 3)
2 7u83 310 
 
7 7u83 311 
#define MAKE_exp_char_lit(type_, str_, digit_, c_class_exp)\
2 7u83 312 
    {\
7 7u83 313 
	c_class *x508_ = GEN_c_class(4, TYPEID_exp);\
314 
	x508_->ag_tag = 6;\
315 
	COPY_type(x508_ + 1, (type_));\
316 
	COPY_str(x508_ + 2, (str_));\
317 
	COPY_int(x508_ + 3, (digit_));\
318 
	(c_class_exp) = x508_;\
2 7u83 319 
    }
320 
 
7 7u83 321 
#define DECONS_exp_char_lit(type_, str_, digit_, c_class_exp)\
2 7u83 322 
    {\
7 7u83 323 
	c_class *x509_ = CHECK_TAG((c_class_exp), 6);\
324 
	(type_) = DEREF_type(x509_ + 1);\
325 
	(str_) = DEREF_str(x509_ + 2);\
326 
	(digit_) = DEREF_int(x509_ + 3);\
2 7u83 327 
    }
328 
 
7 7u83 329 
#define DESTROY_exp_char_lit(destroyer_, type_, str_, digit_, c_class_exp)\
2 7u83 330 
    {\
7 7u83 331 
	c_class *x510_ = CHECK_TAG((c_class_exp), 6);\
332 
	(type_) = DEREF_type(x510_ + 1);\
333 
	(str_) = DEREF_str(x510_ + 2);\
334 
	(digit_) = DEREF_int(x510_ + 3);\
335 
	(destroyer_)(x510_, (unsigned)4);\
2 7u83 336 
    }
337 
 
338 
 
339 
/* Operations for field string_lit of union EXP */
340 
 
7 7u83 341 
#define exp_string_lit_tag		((unsigned)7)
342 
#define IS_exp_string_lit(P)		(CHECK_NULL(P)->ag_tag == 7)
2 7u83 343 
 
7 7u83 344 
#define exp_string_lit_str(P)		(CHECK_TAG((P), 7) + 2)
2 7u83 345 
 
7 7u83 346 
#define MAKE_exp_string_lit(type_, str_, c_class_exp)\
2 7u83 347 
    {\
7 7u83 348 
	c_class *x511_ = GEN_c_class(3, TYPEID_exp);\
349 
	x511_->ag_tag = 7;\
350 
	COPY_type(x511_ + 1, (type_));\
351 
	COPY_str(x511_ + 2, (str_));\
352 
	(c_class_exp) = x511_;\
2 7u83 353 
    }
354 
 
7 7u83 355 
#define DECONS_exp_string_lit(type_, str_, c_class_exp)\
2 7u83 356 
    {\
7 7u83 357 
	c_class *x512_ = CHECK_TAG((c_class_exp), 7);\
358 
	(type_) = DEREF_type(x512_ + 1);\
359 
	(str_) = DEREF_str(x512_ + 2);\
2 7u83 360 
    }
361 
 
7 7u83 362 
#define DESTROY_exp_string_lit(destroyer_, type_, str_, c_class_exp)\
2 7u83 363 
    {\
7 7u83 364 
	c_class *x513_ = CHECK_TAG((c_class_exp), 7);\
365 
	(type_) = DEREF_type(x513_ + 1);\
366 
	(str_) = DEREF_str(x513_ + 2);\
367 
	(destroyer_)(x513_, (unsigned)3);\
2 7u83 368 
    }
369 
 
370 
 
371 
/* Operations for field value of union EXP */
372 
 
7 7u83 373 
#define exp_value_tag			((unsigned)8)
374 
#define IS_exp_value(P)			(CHECK_NULL(P)->ag_tag == 8)
2 7u83 375 
 
376 
 
7 7u83 377 
#define MAKE_exp_value(type_, c_class_exp)\
2 7u83 378 
    {\
7 7u83 379 
	c_class *x514_ = GEN_c_class(2, TYPEID_exp);\
380 
	x514_->ag_tag = 8;\
381 
	COPY_type(x514_ + 1, (type_));\
382 
	(c_class_exp) = x514_;\
2 7u83 383 
    }
384 
 
7 7u83 385 
#define DECONS_exp_value(type_, c_class_exp)\
2 7u83 386 
    {\
7 7u83 387 
	c_class *x515_ = CHECK_TAG((c_class_exp), 8);\
388 
	(type_) = DEREF_type(x515_ + 1);\
2 7u83 389 
    }
390 
 
7 7u83 391 
#define DESTROY_exp_value(destroyer_, type_, c_class_exp)\
2 7u83 392 
    {\
7 7u83 393 
	c_class *x516_ = CHECK_TAG((c_class_exp), 8);\
394 
	(type_) = DEREF_type(x516_ + 1);\
395 
	(destroyer_)(x516_, (unsigned)2);\
2 7u83 396 
    }
397 
 
398 
 
399 
/* Operations for field set null_etc of union EXP */
400 
 
7 7u83 401 
#define exp_null_etc_tag		((unsigned)11)
402 
#define IS_exp_null_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 9) < (unsigned)2)
2 7u83 403 
 
404 
 
7 7u83 405 
#define MAKE_exp_null_etc(tag, type_, c_class_exp)\
2 7u83 406 
    {\
7 7u83 407 
	c_class *x517_ = GEN_c_class(2, TYPEID_exp);\
408 
	x517_->ag_tag = (tag);\
409 
	COPY_type(x517_ + 1, (type_));\
410 
	(c_class_exp) = CHECK_TAG_ETC(x517_, 9, 11);\
2 7u83 411 
    }
412 
 
7 7u83 413 
#define MODIFY_exp_null_etc(tag, c_class_exp)\
2 7u83 414 
    {\
7 7u83 415 
	c_class *x518_ = CHECK_TAG_ETC ((c_class_exp), 9, 11);\
416 
	x518_->ag_tag = (tag);\
417 
	(void) CHECK_TAG_ETC (x518_, 9, 11);\
2 7u83 418 
    }
419 
 
7 7u83 420 
#define DECONS_exp_null_etc(type_, c_class_exp)\
2 7u83 421 
    {\
7 7u83 422 
	c_class *x519_ = CHECK_TAG_ETC((c_class_exp), 9, 11);\
423 
	(type_) = DEREF_type(x519_ + 1);\
2 7u83 424 
    }
425 
 
7 7u83 426 
#define DESTROY_exp_null_etc(destroyer_, type_, c_class_exp)\
2 7u83 427 
    {\
7 7u83 428 
	c_class *x520_ = CHECK_TAG_ETC((c_class_exp), 9, 11);\
429 
	(type_) = DEREF_type(x520_ + 1);\
430 
	(destroyer_)(x520_, (unsigned)2);\
2 7u83 431 
    }
432 
 
433 
 
434 
/* Operations for field null of union EXP */
435 
 
7 7u83 436 
#define exp_null_tag			((unsigned)9)
437 
#define IS_exp_null(P)			(CHECK_NULL(P)->ag_tag == 9)
2 7u83 438 
 
439 
 
7 7u83 440 
#define MAKE_exp_null(type_, c_class_exp)\
2 7u83 441 
    {\
7 7u83 442 
	c_class *x521_ = GEN_c_class(2, TYPEID_exp);\
443 
	x521_->ag_tag = 9;\
444 
	COPY_type(x521_ + 1, (type_));\
445 
	(c_class_exp) = x521_;\
2 7u83 446 
    }
447 
 
7 7u83 448 
#define DECONS_exp_null(type_, c_class_exp)\
2 7u83 449 
    {\
7 7u83 450 
	c_class *x522_ = CHECK_TAG((c_class_exp), 9);\
451 
	(type_) = DEREF_type(x522_ + 1);\
2 7u83 452 
    }
453 
 
7 7u83 454 
#define DESTROY_exp_null(destroyer_, type_, c_class_exp)\
2 7u83 455 
    {\
7 7u83 456 
	c_class *x523_ = CHECK_TAG((c_class_exp), 9);\
457 
	(type_) = DEREF_type(x523_ + 1);\
458 
	(destroyer_)(x523_, (unsigned)2);\
2 7u83 459 
    }
460 
 
461 
 
462 
/* Operations for field zero of union EXP */
463 
 
7 7u83 464 
#define exp_zero_tag			((unsigned)10)
465 
#define IS_exp_zero(P)			(CHECK_NULL(P)->ag_tag == 10)
2 7u83 466 
 
467 
 
7 7u83 468 
#define MAKE_exp_zero(type_, c_class_exp)\
2 7u83 469 
    {\
7 7u83 470 
	c_class *x524_ = GEN_c_class(2, TYPEID_exp);\
471 
	x524_->ag_tag = 10;\
472 
	COPY_type(x524_ + 1, (type_));\
473 
	(c_class_exp) = x524_;\
2 7u83 474 
    }
475 
 
7 7u83 476 
#define DECONS_exp_zero(type_, c_class_exp)\
2 7u83 477 
    {\
7 7u83 478 
	c_class *x525_ = CHECK_TAG((c_class_exp), 10);\
479 
	(type_) = DEREF_type(x525_ + 1);\
2 7u83 480 
    }
481 
 
7 7u83 482 
#define DESTROY_exp_zero(destroyer_, type_, c_class_exp)\
2 7u83 483 
    {\
7 7u83 484 
	c_class *x526_ = CHECK_TAG((c_class_exp), 10);\
485 
	(type_) = DEREF_type(x526_ + 1);\
486 
	(destroyer_)(x526_, (unsigned)2);\
2 7u83 487 
    }
488 
 
489 
 
490 
/* Operations for field set paren_etc of union EXP */
491 
 
7 7u83 492 
#define exp_paren_etc_tag		((unsigned)13)
493 
#define IS_exp_paren_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 11) < (unsigned)2)
2 7u83 494 
 
7 7u83 495 
#define exp_paren_etc_arg(P)		(CHECK_TAG_ETC((P), 11, 13) + 2)
2 7u83 496 
 
7 7u83 497 
#define MAKE_exp_paren_etc(tag, type_, arg_, c_class_exp)\
2 7u83 498 
    {\
7 7u83 499 
	c_class *x527_ = GEN_c_class(3, TYPEID_exp);\
500 
	x527_->ag_tag = (tag);\
501 
	COPY_type(x527_ + 1, (type_));\
502 
	COPY_exp(x527_ + 2, (arg_));\
503 
	(c_class_exp) = CHECK_TAG_ETC(x527_, 11, 13);\
2 7u83 504 
    }
505 
 
7 7u83 506 
#define MODIFY_exp_paren_etc(tag, c_class_exp)\
2 7u83 507 
    {\
7 7u83 508 
	c_class *x528_ = CHECK_TAG_ETC ((c_class_exp), 11, 13);\
509 
	x528_->ag_tag = (tag);\
510 
	(void) CHECK_TAG_ETC (x528_, 11, 13);\
2 7u83 511 
    }
512 
 
7 7u83 513 
#define DECONS_exp_paren_etc(type_, arg_, c_class_exp)\
2 7u83 514 
    {\
7 7u83 515 
	c_class *x529_ = CHECK_TAG_ETC((c_class_exp), 11, 13);\
516 
	(type_) = DEREF_type(x529_ + 1);\
517 
	(arg_) = DEREF_exp(x529_ + 2);\
2 7u83 518 
    }
519 
 
7 7u83 520 
#define DESTROY_exp_paren_etc(destroyer_, type_, arg_, c_class_exp)\
2 7u83 521 
    {\
7 7u83 522 
	c_class *x530_ = CHECK_TAG_ETC((c_class_exp), 11, 13);\
523 
	(type_) = DEREF_type(x530_ + 1);\
524 
	(arg_) = DEREF_exp(x530_ + 2);\
525 
	(destroyer_)(x530_, (unsigned)3);\
2 7u83 526 
    }
527 
 
528 
 
529 
/* Operations for field paren of union EXP */
530 
 
7 7u83 531 
#define exp_paren_tag			((unsigned)11)
532 
#define IS_exp_paren(P)			(CHECK_NULL(P)->ag_tag == 11)
2 7u83 533 
 
7 7u83 534 
#define exp_paren_arg(P)		(CHECK_TAG((P), 11) + 2)
2 7u83 535 
 
7 7u83 536 
#define MAKE_exp_paren(type_, arg_, c_class_exp)\
2 7u83 537 
    {\
7 7u83 538 
	c_class *x531_ = GEN_c_class(3, TYPEID_exp);\
539 
	x531_->ag_tag = 11;\
540 
	COPY_type(x531_ + 1, (type_));\
541 
	COPY_exp(x531_ + 2, (arg_));\
542 
	(c_class_exp) = x531_;\
2 7u83 543 
    }
544 
 
7 7u83 545 
#define DECONS_exp_paren(type_, arg_, c_class_exp)\
2 7u83 546 
    {\
7 7u83 547 
	c_class *x532_ = CHECK_TAG((c_class_exp), 11);\
548 
	(type_) = DEREF_type(x532_ + 1);\
549 
	(arg_) = DEREF_exp(x532_ + 2);\
2 7u83 550 
    }
551 
 
7 7u83 552 
#define DESTROY_exp_paren(destroyer_, type_, arg_, c_class_exp)\
2 7u83 553 
    {\
7 7u83 554 
	c_class *x533_ = CHECK_TAG((c_class_exp), 11);\
555 
	(type_) = DEREF_type(x533_ + 1);\
556 
	(arg_) = DEREF_exp(x533_ + 2);\
557 
	(destroyer_)(x533_, (unsigned)3);\
2 7u83 558 
    }
559 
 
560 
 
561 
/* Operations for field copy of union EXP */
562 
 
7 7u83 563 
#define exp_copy_tag			((unsigned)12)
564 
#define IS_exp_copy(P)			(CHECK_NULL(P)->ag_tag == 12)
2 7u83 565 
 
7 7u83 566 
#define exp_copy_arg(P)			(CHECK_TAG((P), 12) + 2)
2 7u83 567 
 
7 7u83 568 
#define MAKE_exp_copy(type_, arg_, c_class_exp)\
2 7u83 569 
    {\
7 7u83 570 
	c_class *x534_ = GEN_c_class(3, TYPEID_exp);\
571 
	x534_->ag_tag = 12;\
572 
	COPY_type(x534_ + 1, (type_));\
573 
	COPY_exp(x534_ + 2, (arg_));\
574 
	(c_class_exp) = x534_;\
2 7u83 575 
    }
576 
 
7 7u83 577 
#define DECONS_exp_copy(type_, arg_, c_class_exp)\
2 7u83 578 
    {\
7 7u83 579 
	c_class *x535_ = CHECK_TAG((c_class_exp), 12);\
580 
	(type_) = DEREF_type(x535_ + 1);\
581 
	(arg_) = DEREF_exp(x535_ + 2);\
2 7u83 582 
    }
583 
 
7 7u83 584 
#define DESTROY_exp_copy(destroyer_, type_, arg_, c_class_exp)\
2 7u83 585 
    {\
7 7u83 586 
	c_class *x536_ = CHECK_TAG((c_class_exp), 12);\
587 
	(type_) = DEREF_type(x536_ + 1);\
588 
	(arg_) = DEREF_exp(x536_ + 2);\
589 
	(destroyer_)(x536_, (unsigned)3);\
2 7u83 590 
    }
591 
 
592 
 
593 
/* Operations for field assign of union EXP */
594 
 
7 7u83 595 
#define exp_assign_tag			((unsigned)13)
596 
#define IS_exp_assign(P)		(CHECK_NULL(P)->ag_tag == 13)
2 7u83 597 
 
7 7u83 598 
#define exp_assign_ref(P)		(CHECK_TAG((P), 13) + 2)
599 
#define exp_assign_arg(P)		(CHECK_TAG((P), 13) + 3)
2 7u83 600 
 
7 7u83 601 
#define MAKE_exp_assign(type_, ref_, arg_, c_class_exp)\
2 7u83 602 
    {\
7 7u83 603 
	c_class *x537_ = GEN_c_class(4, TYPEID_exp);\
604 
	x537_->ag_tag = 13;\
605 
	COPY_type(x537_ + 1, (type_));\
606 
	COPY_exp(x537_ + 2, (ref_));\
607 
	COPY_exp(x537_ + 3, (arg_));\
608 
	(c_class_exp) = x537_;\
2 7u83 609 
    }
610 
 
7 7u83 611 
#define DECONS_exp_assign(type_, ref_, arg_, c_class_exp)\
2 7u83 612 
    {\
7 7u83 613 
	c_class *x538_ = CHECK_TAG((c_class_exp), 13);\
614 
	(type_) = DEREF_type(x538_ + 1);\
615 
	(ref_) = DEREF_exp(x538_ + 2);\
616 
	(arg_) = DEREF_exp(x538_ + 3);\
2 7u83 617 
    }
618 
 
7 7u83 619 
#define DESTROY_exp_assign(destroyer_, type_, ref_, arg_, c_class_exp)\
2 7u83 620 
    {\
7 7u83 621 
	c_class *x539_ = CHECK_TAG((c_class_exp), 13);\
622 
	(type_) = DEREF_type(x539_ + 1);\
623 
	(ref_) = DEREF_exp(x539_ + 2);\
624 
	(arg_) = DEREF_exp(x539_ + 3);\
625 
	(destroyer_)(x539_, (unsigned)4);\
2 7u83 626 
    }
627 
 
628 
 
629 
/* Operations for field init of union EXP */
630 
 
7 7u83 631 
#define exp_init_tag			((unsigned)14)
632 
#define IS_exp_init(P)			(CHECK_NULL(P)->ag_tag == 14)
2 7u83 633 
 
7 7u83 634 
#define exp_init_id(P)			(CHECK_TAG((P), 14) + 2)
635 
#define exp_init_arg(P)			(CHECK_TAG((P), 14) + 3)
2 7u83 636 
 
7 7u83 637 
#define MAKE_exp_init(type_, id_, arg_, c_class_exp)\
2 7u83 638 
    {\
7 7u83 639 
	c_class *x540_ = GEN_c_class(4, TYPEID_exp);\
640 
	x540_->ag_tag = 14;\
641 
	COPY_type(x540_ + 1, (type_));\
642 
	COPY_id(x540_ + 2, (id_));\
643 
	COPY_exp(x540_ + 3, (arg_));\
644 
	(c_class_exp) = x540_;\
2 7u83 645 
    }
646 
 
7 7u83 647 
#define DECONS_exp_init(type_, id_, arg_, c_class_exp)\
2 7u83 648 
    {\
7 7u83 649 
	c_class *x541_ = CHECK_TAG((c_class_exp), 14);\
650 
	(type_) = DEREF_type(x541_ + 1);\
651 
	(id_) = DEREF_id(x541_ + 2);\
652 
	(arg_) = DEREF_exp(x541_ + 3);\
2 7u83 653 
    }
654 
 
7 7u83 655 
#define DESTROY_exp_init(destroyer_, type_, id_, arg_, c_class_exp)\
2 7u83 656 
    {\
7 7u83 657 
	c_class *x542_ = CHECK_TAG((c_class_exp), 14);\
658 
	(type_) = DEREF_type(x542_ + 1);\
659 
	(id_) = DEREF_id(x542_ + 2);\
660 
	(arg_) = DEREF_exp(x542_ + 3);\
661 
	(destroyer_)(x542_, (unsigned)4);\
2 7u83 662 
    }
663 
 
664 
 
665 
/* Operations for field preinc of union EXP */
666 
 
7 7u83 667 
#define exp_preinc_tag			((unsigned)15)
668 
#define IS_exp_preinc(P)		(CHECK_NULL(P)->ag_tag == 15)
2 7u83 669 
 
7 7u83 670 
#define exp_preinc_ref(P)		(CHECK_TAG((P), 15) + 2)
671 
#define exp_preinc_op(P)		(CHECK_TAG((P), 15) + 3)
672 
#define exp_preinc_becomes(P)		(CHECK_TAG((P), 15) + 4)
2 7u83 673 
 
7 7u83 674 
#define MAKE_exp_preinc(type_, ref_, op_, becomes_, c_class_exp)\
2 7u83 675 
    {\
7 7u83 676 
	c_class *x543_ = GEN_c_class(5, TYPEID_exp);\
677 
	x543_->ag_tag = 15;\
678 
	COPY_type(x543_ + 1, (type_));\
679 
	COPY_exp(x543_ + 2, (ref_));\
680 
	COPY_exp(x543_ + 3, (op_));\
681 
	COPY_int(x543_ + 4, (becomes_));\
682 
	(c_class_exp) = x543_;\
2 7u83 683 
    }
684 
 
7 7u83 685 
#define DECONS_exp_preinc(type_, ref_, op_, becomes_, c_class_exp)\
2 7u83 686 
    {\
7 7u83 687 
	c_class *x544_ = CHECK_TAG((c_class_exp), 15);\
688 
	(type_) = DEREF_type(x544_ + 1);\
689 
	(ref_) = DEREF_exp(x544_ + 2);\
690 
	(op_) = DEREF_exp(x544_ + 3);\
691 
	(becomes_) = DEREF_int(x544_ + 4);\
2 7u83 692 
    }
693 
 
7 7u83 694 
#define DESTROY_exp_preinc(destroyer_, type_, ref_, op_, becomes_, c_class_exp)\
2 7u83 695 
    {\
7 7u83 696 
	c_class *x545_ = CHECK_TAG((c_class_exp), 15);\
697 
	(type_) = DEREF_type(x545_ + 1);\
698 
	(ref_) = DEREF_exp(x545_ + 2);\
699 
	(op_) = DEREF_exp(x545_ + 3);\
700 
	(becomes_) = DEREF_int(x545_ + 4);\
701 
	(destroyer_)(x545_, (unsigned)5);\
2 7u83 702 
    }
703 
 
704 
 
705 
/* Operations for field postinc of union EXP */
706 
 
7 7u83 707 
#define exp_postinc_tag			((unsigned)16)
708 
#define IS_exp_postinc(P)		(CHECK_NULL(P)->ag_tag == 16)
2 7u83 709 
 
7 7u83 710 
#define exp_postinc_ref(P)		(CHECK_TAG((P), 16) + 2)
711 
#define exp_postinc_value(P)		(CHECK_TAG((P), 16) + 3)
712 
#define exp_postinc_op(P)		(CHECK_TAG((P), 16) + 4)
2 7u83 713 
 
7 7u83 714 
#define MAKE_exp_postinc(type_, ref_, value_, op_, c_class_exp)\
2 7u83 715 
    {\
7 7u83 716 
	c_class *x546_ = GEN_c_class(5, TYPEID_exp);\
717 
	x546_->ag_tag = 16;\
718 
	COPY_type(x546_ + 1, (type_));\
719 
	COPY_exp(x546_ + 2, (ref_));\
720 
	COPY_exp(x546_ + 3, (value_));\
721 
	COPY_exp(x546_ + 4, (op_));\
722 
	(c_class_exp) = x546_;\
2 7u83 723 
    }
724 
 
7 7u83 725 
#define DECONS_exp_postinc(type_, ref_, value_, op_, c_class_exp)\
2 7u83 726 
    {\
7 7u83 727 
	c_class *x547_ = CHECK_TAG((c_class_exp), 16);\
728 
	(type_) = DEREF_type(x547_ + 1);\
729 
	(ref_) = DEREF_exp(x547_ + 2);\
730 
	(value_) = DEREF_exp(x547_ + 3);\
731 
	(op_) = DEREF_exp(x547_ + 4);\
2 7u83 732 
    }
733 
 
7 7u83 734 
#define DESTROY_exp_postinc(destroyer_, type_, ref_, value_, op_, c_class_exp)\
2 7u83 735 
    {\
7 7u83 736 
	c_class *x548_ = CHECK_TAG((c_class_exp), 16);\
737 
	(type_) = DEREF_type(x548_ + 1);\
738 
	(ref_) = DEREF_exp(x548_ + 2);\
739 
	(value_) = DEREF_exp(x548_ + 3);\
740 
	(op_) = DEREF_exp(x548_ + 4);\
741 
	(destroyer_)(x548_, (unsigned)5);\
2 7u83 742 
    }
743 
 
744 
 
745 
/* Operations for field indir of union EXP */
746 
 
7 7u83 747 
#define exp_indir_tag			((unsigned)17)
748 
#define IS_exp_indir(P)			(CHECK_NULL(P)->ag_tag == 17)
2 7u83 749 
 
7 7u83 750 
#define exp_indir_ptr(P)		(CHECK_TAG((P), 17) + 2)
751 
#define exp_indir_index(P)		(CHECK_TAG((P), 17) + 3)
2 7u83 752 
 
7 7u83 753 
#define MAKE_exp_indir(type_, ptr_, c_class_exp)\
2 7u83 754 
    {\
7 7u83 755 
	c_class *x549_ = GEN_c_class(4, TYPEID_exp);\
756 
	x549_->ag_tag = 17;\
757 
	COPY_type(x549_ + 1, (type_));\
758 
	COPY_exp(x549_ + 2, (ptr_));\
759 
	COPY_int(x549_ + 3, 0);\
760 
	(c_class_exp) = x549_;\
2 7u83 761 
    }
762 
 
7 7u83 763 
#define DECONS_exp_indir(type_, ptr_, index_, c_class_exp)\
2 7u83 764 
    {\
7 7u83 765 
	c_class *x550_ = CHECK_TAG((c_class_exp), 17);\
766 
	(type_) = DEREF_type(x550_ + 1);\
767 
	(ptr_) = DEREF_exp(x550_ + 2);\
768 
	(index_) = DEREF_int(x550_ + 3);\
2 7u83 769 
    }
770 
 
7 7u83 771 
#define DESTROY_exp_indir(destroyer_, type_, ptr_, index_, c_class_exp)\
2 7u83 772 
    {\
7 7u83 773 
	c_class *x551_ = CHECK_TAG((c_class_exp), 17);\
774 
	(type_) = DEREF_type(x551_ + 1);\
775 
	(ptr_) = DEREF_exp(x551_ + 2);\
776 
	(index_) = DEREF_int(x551_ + 3);\
777 
	(destroyer_)(x551_, (unsigned)4);\
2 7u83 778 
    }
779 
 
780 
 
781 
/* Operations for field contents of union EXP */
782 
 
7 7u83 783 
#define exp_contents_tag		((unsigned)18)
784 
#define IS_exp_contents(P)		(CHECK_NULL(P)->ag_tag == 18)
2 7u83 785 
 
7 7u83 786 
#define exp_contents_ptr(P)		(CHECK_TAG((P), 18) + 2)
2 7u83 787 
 
7 7u83 788 
#define MAKE_exp_contents(type_, ptr_, c_class_exp)\
2 7u83 789 
    {\
7 7u83 790 
	c_class *x552_ = GEN_c_class(3, TYPEID_exp);\
791 
	x552_->ag_tag = 18;\
792 
	COPY_type(x552_ + 1, (type_));\
793 
	COPY_exp(x552_ + 2, (ptr_));\
794 
	(c_class_exp) = x552_;\
2 7u83 795 
    }
796 
 
7 7u83 797 
#define DECONS_exp_contents(type_, ptr_, c_class_exp)\
2 7u83 798 
    {\
7 7u83 799 
	c_class *x553_ = CHECK_TAG((c_class_exp), 18);\
800 
	(type_) = DEREF_type(x553_ + 1);\
801 
	(ptr_) = DEREF_exp(x553_ + 2);\
2 7u83 802 
    }
803 
 
7 7u83 804 
#define DESTROY_exp_contents(destroyer_, type_, ptr_, c_class_exp)\
2 7u83 805 
    {\
7 7u83 806 
	c_class *x554_ = CHECK_TAG((c_class_exp), 18);\
807 
	(type_) = DEREF_type(x554_ + 1);\
808 
	(ptr_) = DEREF_exp(x554_ + 2);\
809 
	(destroyer_)(x554_, (unsigned)3);\
2 7u83 810 
    }
811 
 
812 
 
813 
/* Operations for field address of union EXP */
814 
 
7 7u83 815 
#define exp_address_tag			((unsigned)19)
816 
#define IS_exp_address(P)		(CHECK_NULL(P)->ag_tag == 19)
2 7u83 817 
 
7 7u83 818 
#define exp_address_arg(P)		(CHECK_TAG((P), 19) + 2)
2 7u83 819 
 
7 7u83 820 
#define MAKE_exp_address(type_, arg_, c_class_exp)\
2 7u83 821 
    {\
7 7u83 822 
	c_class *x555_ = GEN_c_class(3, TYPEID_exp);\
823 
	x555_->ag_tag = 19;\
824 
	COPY_type(x555_ + 1, (type_));\
825 
	COPY_exp(x555_ + 2, (arg_));\
826 
	(c_class_exp) = x555_;\
2 7u83 827 
    }
828 
 
7 7u83 829 
#define DECONS_exp_address(type_, arg_, c_class_exp)\
2 7u83 830 
    {\
7 7u83 831 
	c_class *x556_ = CHECK_TAG((c_class_exp), 19);\
832 
	(type_) = DEREF_type(x556_ + 1);\
833 
	(arg_) = DEREF_exp(x556_ + 2);\
2 7u83 834 
    }
835 
 
7 7u83 836 
#define DESTROY_exp_address(destroyer_, type_, arg_, c_class_exp)\
2 7u83 837 
    {\
7 7u83 838 
	c_class *x557_ = CHECK_TAG((c_class_exp), 19);\
839 
	(type_) = DEREF_type(x557_ + 1);\
840 
	(arg_) = DEREF_exp(x557_ + 2);\
841 
	(destroyer_)(x557_, (unsigned)3);\
2 7u83 842 
    }
843 
 
844 
 
845 
/* Operations for field address_mem of union EXP */
846 
 
7 7u83 847 
#define exp_address_mem_tag		((unsigned)20)
848 
#define IS_exp_address_mem(P)		(CHECK_NULL(P)->ag_tag == 20)
2 7u83 849 
 
7 7u83 850 
#define exp_address_mem_arg(P)		(CHECK_TAG((P), 20) + 2)
851 
#define exp_address_mem_paren(P)	(CHECK_TAG((P), 20) + 3)
2 7u83 852 
 
7 7u83 853 
#define MAKE_exp_address_mem(type_, arg_, paren_, c_class_exp)\
2 7u83 854 
    {\
7 7u83 855 
	c_class *x558_ = GEN_c_class(4, TYPEID_exp);\
856 
	x558_->ag_tag = 20;\
857 
	COPY_type(x558_ + 1, (type_));\
858 
	COPY_exp(x558_ + 2, (arg_));\
859 
	COPY_int(x558_ + 3, (paren_));\
860 
	(c_class_exp) = x558_;\
2 7u83 861 
    }
862 
 
7 7u83 863 
#define DECONS_exp_address_mem(type_, arg_, paren_, c_class_exp)\
2 7u83 864 
    {\
7 7u83 865 
	c_class *x559_ = CHECK_TAG((c_class_exp), 20);\
866 
	(type_) = DEREF_type(x559_ + 1);\
867 
	(arg_) = DEREF_exp(x559_ + 2);\
868 
	(paren_) = DEREF_int(x559_ + 3);\
2 7u83 869 
    }
870 
 
7 7u83 871 
#define DESTROY_exp_address_mem(destroyer_, type_, arg_, paren_, c_class_exp)\
2 7u83 872 
    {\
7 7u83 873 
	c_class *x560_ = CHECK_TAG((c_class_exp), 20);\
874 
	(type_) = DEREF_type(x560_ + 1);\
875 
	(arg_) = DEREF_exp(x560_ + 2);\
876 
	(paren_) = DEREF_int(x560_ + 3);\
877 
	(destroyer_)(x560_, (unsigned)4);\
2 7u83 878 
    }
879 
 
880 
 
881 
/* Operations for field func of union EXP */
882 
 
7 7u83 883 
#define exp_func_tag			((unsigned)21)
884 
#define IS_exp_func(P)			(CHECK_NULL(P)->ag_tag == 21)
2 7u83 885 
 
7 7u83 886 
#define exp_func_fn(P)			(CHECK_TAG((P), 21) + 2)
887 
#define exp_func_args(P)		(CHECK_TAG((P), 21) + 3)
888 
#define exp_func_extra(P)		(CHECK_TAG((P), 21) + 4)
2 7u83 889 
 
7 7u83 890 
#define MAKE_exp_func(type_, fn_, args_, c_class_exp)\
2 7u83 891 
    {\
7 7u83 892 
	c_class *x561_ = GEN_c_class(5, TYPEID_exp);\
893 
	x561_->ag_tag = 21;\
894 
	COPY_type(x561_ + 1, (type_));\
895 
	COPY_exp(x561_ + 2, (fn_));\
896 
	COPY_list(x561_ + 3, (args_));\
897 
	COPY_unsigned(x561_ + 4, 0);\
898 
	(c_class_exp) = x561_;\
2 7u83 899 
    }
900 
 
7 7u83 901 
#define DECONS_exp_func(type_, fn_, args_, extra_, c_class_exp)\
2 7u83 902 
    {\
7 7u83 903 
	c_class *x562_ = CHECK_TAG((c_class_exp), 21);\
904 
	(type_) = DEREF_type(x562_ + 1);\
905 
	(fn_) = DEREF_exp(x562_ + 2);\
906 
	(args_) = DEREF_list(x562_ + 3);\
907 
	(extra_) = DEREF_unsigned(x562_ + 4);\
2 7u83 908 
    }
909 
 
7 7u83 910 
#define DESTROY_exp_func(destroyer_, type_, fn_, args_, extra_, c_class_exp)\
2 7u83 911 
    {\
7 7u83 912 
	c_class *x563_ = CHECK_TAG((c_class_exp), 21);\
913 
	(type_) = DEREF_type(x563_ + 1);\
914 
	(fn_) = DEREF_exp(x563_ + 2);\
915 
	(args_) = DEREF_list(x563_ + 3);\
916 
	(extra_) = DEREF_unsigned(x563_ + 4);\
917 
	(destroyer_)(x563_, (unsigned)5);\
2 7u83 918 
    }
919 
 
920 
 
921 
/* Operations for field func_id of union EXP */
922 
 
7 7u83 923 
#define exp_func_id_tag			((unsigned)22)
924 
#define IS_exp_func_id(P)		(CHECK_NULL(P)->ag_tag == 22)
2 7u83 925 
 
7 7u83 926 
#define exp_func_id_id(P)		(CHECK_TAG((P), 22) + 2)
927 
#define exp_func_id_args(P)		(CHECK_TAG((P), 22) + 3)
928 
#define exp_func_id_virt(P)		(CHECK_TAG((P), 22) + 4)
929 
#define exp_func_id_extra(P)		(CHECK_TAG((P), 22) + 5)
2 7u83 930 
 
7 7u83 931 
#define MAKE_exp_func_id(type_, id_, args_, virt_, c_class_exp)\
2 7u83 932 
    {\
7 7u83 933 
	c_class *x564_ = GEN_c_class(6, TYPEID_exp);\
934 
	x564_->ag_tag = 22;\
935 
	COPY_type(x564_ + 1, (type_));\
936 
	COPY_id(x564_ + 2, (id_));\
937 
	COPY_list(x564_ + 3, (args_));\
938 
	COPY_exp(x564_ + 4, (virt_));\
939 
	COPY_unsigned(x564_ + 5, 0);\
940 
	(c_class_exp) = x564_;\
2 7u83 941 
    }
942 
 
7 7u83 943 
#define DECONS_exp_func_id(type_, id_, args_, virt_, extra_, c_class_exp)\
2 7u83 944 
    {\
7 7u83 945 
	c_class *x565_ = CHECK_TAG((c_class_exp), 22);\
946 
	(type_) = DEREF_type(x565_ + 1);\
947 
	(id_) = DEREF_id(x565_ + 2);\
948 
	(args_) = DEREF_list(x565_ + 3);\
949 
	(virt_) = DEREF_exp(x565_ + 4);\
950 
	(extra_) = DEREF_unsigned(x565_ + 5);\
2 7u83 951 
    }
952 
 
7 7u83 953 
#define DESTROY_exp_func_id(destroyer_, type_, id_, args_, virt_, extra_, c_class_exp)\
2 7u83 954 
    {\
7 7u83 955 
	c_class *x566_ = CHECK_TAG((c_class_exp), 22);\
956 
	(type_) = DEREF_type(x566_ + 1);\
957 
	(id_) = DEREF_id(x566_ + 2);\
958 
	(args_) = DEREF_list(x566_ + 3);\
959 
	(virt_) = DEREF_exp(x566_ + 4);\
960 
	(extra_) = DEREF_unsigned(x566_ + 5);\
961 
	(destroyer_)(x566_, (unsigned)6);\
2 7u83 962 
    }
963 
 
964 
 
965 
/* Operations for field call of union EXP */
966 
 
7 7u83 967 
#define exp_call_tag			((unsigned)23)
968 
#define IS_exp_call(P)			(CHECK_NULL(P)->ag_tag == 23)
2 7u83 969 
 
7 7u83 970 
#define exp_call_ptr(P)			(CHECK_TAG((P), 23) + 2)
971 
#define exp_call_arg(P)			(CHECK_TAG((P), 23) + 3)
972 
#define exp_call_base(P)		(CHECK_TAG((P), 23) + 4)
2 7u83 973 
 
7 7u83 974 
#define MAKE_exp_call(type_, ptr_, arg_, base_, c_class_exp)\
2 7u83 975 
    {\
7 7u83 976 
	c_class *x567_ = GEN_c_class(5, TYPEID_exp);\
977 
	x567_->ag_tag = 23;\
978 
	COPY_type(x567_ + 1, (type_));\
979 
	COPY_exp(x567_ + 2, (ptr_));\
980 
	COPY_exp(x567_ + 3, (arg_));\
981 
	COPY_graph(x567_ + 4, (base_));\
982 
	(c_class_exp) = x567_;\
2 7u83 983 
    }
984 
 
7 7u83 985 
#define DECONS_exp_call(type_, ptr_, arg_, base_, c_class_exp)\
2 7u83 986 
    {\
7 7u83 987 
	c_class *x568_ = CHECK_TAG((c_class_exp), 23);\
988 
	(type_) = DEREF_type(x568_ + 1);\
989 
	(ptr_) = DEREF_exp(x568_ + 2);\
990 
	(arg_) = DEREF_exp(x568_ + 3);\
991 
	(base_) = DEREF_graph(x568_ + 4);\
2 7u83 992 
    }
993 
 
7 7u83 994 
#define DESTROY_exp_call(destroyer_, type_, ptr_, arg_, base_, c_class_exp)\
2 7u83 995 
    {\
7 7u83 996 
	c_class *x569_ = CHECK_TAG((c_class_exp), 23);\
997 
	(type_) = DEREF_type(x569_ + 1);\
998 
	(ptr_) = DEREF_exp(x569_ + 2);\
999 
	(arg_) = DEREF_exp(x569_ + 3);\
1000 
	(base_) = DEREF_graph(x569_ + 4);\
1001 
	(destroyer_)(x569_, (unsigned)5);\
2 7u83 1002 
    }
1003 
 
1004 
 
1005 
/* Operations for field set negate_etc of union EXP */
1006 
 
7 7u83 1007 
#define exp_negate_etc_tag		((unsigned)28)
1008 
#define IS_exp_negate_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 24) < (unsigned)4)
2 7u83 1009 
 
7 7u83 1010 
#define exp_negate_etc_arg(P)		(CHECK_TAG_ETC((P), 24, 28) + 2)
2 7u83 1011 
 
7 7u83 1012 
#define MAKE_exp_negate_etc(tag, type_, arg_, c_class_exp)\
2 7u83 1013 
    {\
7 7u83 1014 
	c_class *x570_ = GEN_c_class(3, TYPEID_exp);\
1015 
	x570_->ag_tag = (tag);\
1016 
	COPY_type(x570_ + 1, (type_));\
1017 
	COPY_exp(x570_ + 2, (arg_));\
1018 
	(c_class_exp) = CHECK_TAG_ETC(x570_, 24, 28);\
2 7u83 1019 
    }
1020 
 
7 7u83 1021 
#define MODIFY_exp_negate_etc(tag, c_class_exp)\
2 7u83 1022 
    {\
7 7u83 1023 
	c_class *x571_ = CHECK_TAG_ETC ((c_class_exp), 24, 28);\
1024 
	x571_->ag_tag = (tag);\
1025 
	(void) CHECK_TAG_ETC (x571_, 24, 28);\
2 7u83 1026 
    }
1027 
 
7 7u83 1028 
#define DECONS_exp_negate_etc(type_, arg_, c_class_exp)\
2 7u83 1029 
    {\
7 7u83 1030 
	c_class *x572_ = CHECK_TAG_ETC((c_class_exp), 24, 28);\
1031 
	(type_) = DEREF_type(x572_ + 1);\
1032 
	(arg_) = DEREF_exp(x572_ + 2);\
2 7u83 1033 
    }
1034 
 
7 7u83 1035 
#define DESTROY_exp_negate_etc(destroyer_, type_, arg_, c_class_exp)\
2 7u83 1036 
    {\
7 7u83 1037 
	c_class *x573_ = CHECK_TAG_ETC((c_class_exp), 24, 28);\
1038 
	(type_) = DEREF_type(x573_ + 1);\
1039 
	(arg_) = DEREF_exp(x573_ + 2);\
1040 
	(destroyer_)(x573_, (unsigned)3);\
2 7u83 1041 
    }
1042 
 
1043 
 
1044 
/* Operations for field negate of union EXP */
1045 
 
7 7u83 1046 
#define exp_negate_tag			((unsigned)24)
1047 
#define IS_exp_negate(P)		(CHECK_NULL(P)->ag_tag == 24)
2 7u83 1048 
 
7 7u83 1049 
#define exp_negate_arg(P)		(CHECK_TAG((P), 24) + 2)
2 7u83 1050 
 
7 7u83 1051 
#define MAKE_exp_negate(type_, arg_, c_class_exp)\
2 7u83 1052 
    {\
7 7u83 1053 
	c_class *x574_ = GEN_c_class(3, TYPEID_exp);\
1054 
	x574_->ag_tag = 24;\
1055 
	COPY_type(x574_ + 1, (type_));\
1056 
	COPY_exp(x574_ + 2, (arg_));\
1057 
	(c_class_exp) = x574_;\
2 7u83 1058 
    }
1059 
 
7 7u83 1060 
#define DECONS_exp_negate(type_, arg_, c_class_exp)\
2 7u83 1061 
    {\
7 7u83 1062 
	c_class *x575_ = CHECK_TAG((c_class_exp), 24);\
1063 
	(type_) = DEREF_type(x575_ + 1);\
1064 
	(arg_) = DEREF_exp(x575_ + 2);\
2 7u83 1065 
    }
1066 
 
7 7u83 1067 
#define DESTROY_exp_negate(destroyer_, type_, arg_, c_class_exp)\
2 7u83 1068 
    {\
7 7u83 1069 
	c_class *x576_ = CHECK_TAG((c_class_exp), 24);\
1070 
	(type_) = DEREF_type(x576_ + 1);\
1071 
	(arg_) = DEREF_exp(x576_ + 2);\
1072 
	(destroyer_)(x576_, (unsigned)3);\
2 7u83 1073 
    }
1074 
 
1075 
 
1076 
/* Operations for field compl of union EXP */
1077 
 
7 7u83 1078 
#define exp_compl_tag			((unsigned)25)
1079 
#define IS_exp_compl(P)			(CHECK_NULL(P)->ag_tag == 25)
2 7u83 1080 
 
7 7u83 1081 
#define exp_compl_arg(P)		(CHECK_TAG((P), 25) + 2)
2 7u83 1082 
 
7 7u83 1083 
#define MAKE_exp_compl(type_, arg_, c_class_exp)\
2 7u83 1084 
    {\
7 7u83 1085 
	c_class *x577_ = GEN_c_class(3, TYPEID_exp);\
1086 
	x577_->ag_tag = 25;\
1087 
	COPY_type(x577_ + 1, (type_));\
1088 
	COPY_exp(x577_ + 2, (arg_));\
1089 
	(c_class_exp) = x577_;\
2 7u83 1090 
    }
1091 
 
7 7u83 1092 
#define DECONS_exp_compl(type_, arg_, c_class_exp)\
2 7u83 1093 
    {\
7 7u83 1094 
	c_class *x578_ = CHECK_TAG((c_class_exp), 25);\
1095 
	(type_) = DEREF_type(x578_ + 1);\
1096 
	(arg_) = DEREF_exp(x578_ + 2);\
2 7u83 1097 
    }
1098 
 
7 7u83 1099 
#define DESTROY_exp_compl(destroyer_, type_, arg_, c_class_exp)\
2 7u83 1100 
    {\
7 7u83 1101 
	c_class *x579_ = CHECK_TAG((c_class_exp), 25);\
1102 
	(type_) = DEREF_type(x579_ + 1);\
1103 
	(arg_) = DEREF_exp(x579_ + 2);\
1104 
	(destroyer_)(x579_, (unsigned)3);\
2 7u83 1105 
    }
1106 
 
1107 
 
1108 
/* Operations for field not of union EXP */
1109 
 
7 7u83 1110 
#define exp_not_tag			((unsigned)26)
1111 
#define IS_exp_not(P)			(CHECK_NULL(P)->ag_tag == 26)
2 7u83 1112 
 
7 7u83 1113 
#define exp_not_arg(P)			(CHECK_TAG((P), 26) + 2)
2 7u83 1114 
 
7 7u83 1115 
#define MAKE_exp_not(type_, arg_, c_class_exp)\
2 7u83 1116 
    {\
7 7u83 1117 
	c_class *x580_ = GEN_c_class(3, TYPEID_exp);\
1118 
	x580_->ag_tag = 26;\
1119 
	COPY_type(x580_ + 1, (type_));\
1120 
	COPY_exp(x580_ + 2, (arg_));\
1121 
	(c_class_exp) = x580_;\
2 7u83 1122 
    }
1123 
 
7 7u83 1124 
#define DECONS_exp_not(type_, arg_, c_class_exp)\
2 7u83 1125 
    {\
7 7u83 1126 
	c_class *x581_ = CHECK_TAG((c_class_exp), 26);\
1127 
	(type_) = DEREF_type(x581_ + 1);\
1128 
	(arg_) = DEREF_exp(x581_ + 2);\
2 7u83 1129 
    }
1130 
 
7 7u83 1131 
#define DESTROY_exp_not(destroyer_, type_, arg_, c_class_exp)\
2 7u83 1132 
    {\
7 7u83 1133 
	c_class *x582_ = CHECK_TAG((c_class_exp), 26);\
1134 
	(type_) = DEREF_type(x582_ + 1);\
1135 
	(arg_) = DEREF_exp(x582_ + 2);\
1136 
	(destroyer_)(x582_, (unsigned)3);\
2 7u83 1137 
    }
1138 
 
1139 
 
1140 
/* Operations for field abs of union EXP */
1141 
 
7 7u83 1142 
#define exp_abs_tag			((unsigned)27)
1143 
#define IS_exp_abs(P)			(CHECK_NULL(P)->ag_tag == 27)
2 7u83 1144 
 
7 7u83 1145 
#define exp_abs_arg(P)			(CHECK_TAG((P), 27) + 2)
2 7u83 1146 
 
7 7u83 1147 
#define MAKE_exp_abs(type_, arg_, c_class_exp)\
2 7u83 1148 
    {\
7 7u83 1149 
	c_class *x583_ = GEN_c_class(3, TYPEID_exp);\
1150 
	x583_->ag_tag = 27;\
1151 
	COPY_type(x583_ + 1, (type_));\
1152 
	COPY_exp(x583_ + 2, (arg_));\
1153 
	(c_class_exp) = x583_;\
2 7u83 1154 
    }
1155 
 
7 7u83 1156 
#define DECONS_exp_abs(type_, arg_, c_class_exp)\
2 7u83 1157 
    {\
7 7u83 1158 
	c_class *x584_ = CHECK_TAG((c_class_exp), 27);\
1159 
	(type_) = DEREF_type(x584_ + 1);\
1160 
	(arg_) = DEREF_exp(x584_ + 2);\
2 7u83 1161 
    }
1162 
 
7 7u83 1163 
#define DESTROY_exp_abs(destroyer_, type_, arg_, c_class_exp)\
2 7u83 1164 
    {\
7 7u83 1165 
	c_class *x585_ = CHECK_TAG((c_class_exp), 27);\
1166 
	(type_) = DEREF_type(x585_ + 1);\
1167 
	(arg_) = DEREF_exp(x585_ + 2);\
1168 
	(destroyer_)(x585_, (unsigned)3);\
2 7u83 1169 
    }
1170 
 
1171 
 
1172 
/* Operations for field set plus_etc of union EXP */
1173 
 
7 7u83 1174 
#define exp_plus_etc_tag		((unsigned)42)
1175 
#define IS_exp_plus_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 28) < (unsigned)14)
2 7u83 1176 
 
7 7u83 1177 
#define exp_plus_etc_arg1(P)		(CHECK_TAG_ETC((P), 28, 42) + 2)
1178 
#define exp_plus_etc_arg2(P)		(CHECK_TAG_ETC((P), 28, 42) + 3)
2 7u83 1179 
 
7 7u83 1180 
#define MAKE_exp_plus_etc(tag, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1181 
    {\
7 7u83 1182 
	c_class *x586_ = GEN_c_class(4, TYPEID_exp);\
1183 
	x586_->ag_tag = (tag);\
1184 
	COPY_type(x586_ + 1, (type_));\
1185 
	COPY_exp(x586_ + 2, (arg1_));\
1186 
	COPY_exp(x586_ + 3, (arg2_));\
1187 
	(c_class_exp) = CHECK_TAG_ETC(x586_, 28, 42);\
2 7u83 1188 
    }
1189 
 
7 7u83 1190 
#define MODIFY_exp_plus_etc(tag, c_class_exp)\
2 7u83 1191 
    {\
7 7u83 1192 
	c_class *x587_ = CHECK_TAG_ETC ((c_class_exp), 28, 42);\
1193 
	x587_->ag_tag = (tag);\
1194 
	(void) CHECK_TAG_ETC (x587_, 28, 42);\
2 7u83 1195 
    }
1196 
 
7 7u83 1197 
#define DECONS_exp_plus_etc(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1198 
    {\
7 7u83 1199 
	c_class *x588_ = CHECK_TAG_ETC((c_class_exp), 28, 42);\
1200 
	(type_) = DEREF_type(x588_ + 1);\
1201 
	(arg1_) = DEREF_exp(x588_ + 2);\
1202 
	(arg2_) = DEREF_exp(x588_ + 3);\
2 7u83 1203 
    }
1204 
 
7 7u83 1205 
#define DESTROY_exp_plus_etc(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1206 
    {\
7 7u83 1207 
	c_class *x589_ = CHECK_TAG_ETC((c_class_exp), 28, 42);\
1208 
	(type_) = DEREF_type(x589_ + 1);\
1209 
	(arg1_) = DEREF_exp(x589_ + 2);\
1210 
	(arg2_) = DEREF_exp(x589_ + 3);\
1211 
	(destroyer_)(x589_, (unsigned)4);\
2 7u83 1212 
    }
1213 
 
1214 
 
1215 
/* Operations for field plus of union EXP */
1216 
 
7 7u83 1217 
#define exp_plus_tag			((unsigned)28)
1218 
#define IS_exp_plus(P)			(CHECK_NULL(P)->ag_tag == 28)
2 7u83 1219 
 
7 7u83 1220 
#define exp_plus_arg1(P)		(CHECK_TAG((P), 28) + 2)
1221 
#define exp_plus_arg2(P)		(CHECK_TAG((P), 28) + 3)
2 7u83 1222 
 
7 7u83 1223 
#define MAKE_exp_plus(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1224 
    {\
7 7u83 1225 
	c_class *x590_ = GEN_c_class(4, TYPEID_exp);\
1226 
	x590_->ag_tag = 28;\
1227 
	COPY_type(x590_ + 1, (type_));\
1228 
	COPY_exp(x590_ + 2, (arg1_));\
1229 
	COPY_exp(x590_ + 3, (arg2_));\
1230 
	(c_class_exp) = x590_;\
2 7u83 1231 
    }
1232 
 
7 7u83 1233 
#define DECONS_exp_plus(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1234 
    {\
7 7u83 1235 
	c_class *x591_ = CHECK_TAG((c_class_exp), 28);\
1236 
	(type_) = DEREF_type(x591_ + 1);\
1237 
	(arg1_) = DEREF_exp(x591_ + 2);\
1238 
	(arg2_) = DEREF_exp(x591_ + 3);\
2 7u83 1239 
    }
1240 
 
7 7u83 1241 
#define DESTROY_exp_plus(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1242 
    {\
7 7u83 1243 
	c_class *x592_ = CHECK_TAG((c_class_exp), 28);\
1244 
	(type_) = DEREF_type(x592_ + 1);\
1245 
	(arg1_) = DEREF_exp(x592_ + 2);\
1246 
	(arg2_) = DEREF_exp(x592_ + 3);\
1247 
	(destroyer_)(x592_, (unsigned)4);\
2 7u83 1248 
    }
1249 
 
1250 
 
1251 
/* Operations for field minus of union EXP */
1252 
 
7 7u83 1253 
#define exp_minus_tag			((unsigned)29)
1254 
#define IS_exp_minus(P)			(CHECK_NULL(P)->ag_tag == 29)
2 7u83 1255 
 
7 7u83 1256 
#define exp_minus_arg1(P)		(CHECK_TAG((P), 29) + 2)
1257 
#define exp_minus_arg2(P)		(CHECK_TAG((P), 29) + 3)
2 7u83 1258 
 
7 7u83 1259 
#define MAKE_exp_minus(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1260 
    {\
7 7u83 1261 
	c_class *x593_ = GEN_c_class(4, TYPEID_exp);\
1262 
	x593_->ag_tag = 29;\
1263 
	COPY_type(x593_ + 1, (type_));\
1264 
	COPY_exp(x593_ + 2, (arg1_));\
1265 
	COPY_exp(x593_ + 3, (arg2_));\
1266 
	(c_class_exp) = x593_;\
2 7u83 1267 
    }
1268 
 
7 7u83 1269 
#define DECONS_exp_minus(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1270 
    {\
7 7u83 1271 
	c_class *x594_ = CHECK_TAG((c_class_exp), 29);\
1272 
	(type_) = DEREF_type(x594_ + 1);\
1273 
	(arg1_) = DEREF_exp(x594_ + 2);\
1274 
	(arg2_) = DEREF_exp(x594_ + 3);\
2 7u83 1275 
    }
1276 
 
7 7u83 1277 
#define DESTROY_exp_minus(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1278 
    {\
7 7u83 1279 
	c_class *x595_ = CHECK_TAG((c_class_exp), 29);\
1280 
	(type_) = DEREF_type(x595_ + 1);\
1281 
	(arg1_) = DEREF_exp(x595_ + 2);\
1282 
	(arg2_) = DEREF_exp(x595_ + 3);\
1283 
	(destroyer_)(x595_, (unsigned)4);\
2 7u83 1284 
    }
1285 
 
1286 
 
1287 
/* Operations for field mult of union EXP */
1288 
 
7 7u83 1289 
#define exp_mult_tag			((unsigned)30)
1290 
#define IS_exp_mult(P)			(CHECK_NULL(P)->ag_tag == 30)
2 7u83 1291 
 
7 7u83 1292 
#define exp_mult_arg1(P)		(CHECK_TAG((P), 30) + 2)
1293 
#define exp_mult_arg2(P)		(CHECK_TAG((P), 30) + 3)
2 7u83 1294 
 
7 7u83 1295 
#define MAKE_exp_mult(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1296 
    {\
7 7u83 1297 
	c_class *x596_ = GEN_c_class(4, TYPEID_exp);\
1298 
	x596_->ag_tag = 30;\
1299 
	COPY_type(x596_ + 1, (type_));\
1300 
	COPY_exp(x596_ + 2, (arg1_));\
1301 
	COPY_exp(x596_ + 3, (arg2_));\
1302 
	(c_class_exp) = x596_;\
2 7u83 1303 
    }
1304 
 
7 7u83 1305 
#define DECONS_exp_mult(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1306 
    {\
7 7u83 1307 
	c_class *x597_ = CHECK_TAG((c_class_exp), 30);\
1308 
	(type_) = DEREF_type(x597_ + 1);\
1309 
	(arg1_) = DEREF_exp(x597_ + 2);\
1310 
	(arg2_) = DEREF_exp(x597_ + 3);\
2 7u83 1311 
    }
1312 
 
7 7u83 1313 
#define DESTROY_exp_mult(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1314 
    {\
7 7u83 1315 
	c_class *x598_ = CHECK_TAG((c_class_exp), 30);\
1316 
	(type_) = DEREF_type(x598_ + 1);\
1317 
	(arg1_) = DEREF_exp(x598_ + 2);\
1318 
	(arg2_) = DEREF_exp(x598_ + 3);\
1319 
	(destroyer_)(x598_, (unsigned)4);\
2 7u83 1320 
    }
1321 
 
1322 
 
1323 
/* Operations for field div of union EXP */
1324 
 
7 7u83 1325 
#define exp_div_tag			((unsigned)31)
1326 
#define IS_exp_div(P)			(CHECK_NULL(P)->ag_tag == 31)
2 7u83 1327 
 
7 7u83 1328 
#define exp_div_arg1(P)			(CHECK_TAG((P), 31) + 2)
1329 
#define exp_div_arg2(P)			(CHECK_TAG((P), 31) + 3)
2 7u83 1330 
 
7 7u83 1331 
#define MAKE_exp_div(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1332 
    {\
7 7u83 1333 
	c_class *x599_ = GEN_c_class(4, TYPEID_exp);\
1334 
	x599_->ag_tag = 31;\
1335 
	COPY_type(x599_ + 1, (type_));\
1336 
	COPY_exp(x599_ + 2, (arg1_));\
1337 
	COPY_exp(x599_ + 3, (arg2_));\
1338 
	(c_class_exp) = x599_;\
2 7u83 1339 
    }
1340 
 
7 7u83 1341 
#define DECONS_exp_div(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1342 
    {\
7 7u83 1343 
	c_class *x600_ = CHECK_TAG((c_class_exp), 31);\
1344 
	(type_) = DEREF_type(x600_ + 1);\
1345 
	(arg1_) = DEREF_exp(x600_ + 2);\
1346 
	(arg2_) = DEREF_exp(x600_ + 3);\
2 7u83 1347 
    }
1348 
 
7 7u83 1349 
#define DESTROY_exp_div(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1350 
    {\
7 7u83 1351 
	c_class *x601_ = CHECK_TAG((c_class_exp), 31);\
1352 
	(type_) = DEREF_type(x601_ + 1);\
1353 
	(arg1_) = DEREF_exp(x601_ + 2);\
1354 
	(arg2_) = DEREF_exp(x601_ + 3);\
1355 
	(destroyer_)(x601_, (unsigned)4);\
2 7u83 1356 
    }
1357 
 
1358 
 
1359 
/* Operations for field rem of union EXP */
1360 
 
7 7u83 1361 
#define exp_rem_tag			((unsigned)32)
1362 
#define IS_exp_rem(P)			(CHECK_NULL(P)->ag_tag == 32)
2 7u83 1363 
 
7 7u83 1364 
#define exp_rem_arg1(P)			(CHECK_TAG((P), 32) + 2)
1365 
#define exp_rem_arg2(P)			(CHECK_TAG((P), 32) + 3)
2 7u83 1366 
 
7 7u83 1367 
#define MAKE_exp_rem(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1368 
    {\
7 7u83 1369 
	c_class *x602_ = GEN_c_class(4, TYPEID_exp);\
1370 
	x602_->ag_tag = 32;\
1371 
	COPY_type(x602_ + 1, (type_));\
1372 
	COPY_exp(x602_ + 2, (arg1_));\
1373 
	COPY_exp(x602_ + 3, (arg2_));\
1374 
	(c_class_exp) = x602_;\
2 7u83 1375 
    }
1376 
 
7 7u83 1377 
#define DECONS_exp_rem(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1378 
    {\
7 7u83 1379 
	c_class *x603_ = CHECK_TAG((c_class_exp), 32);\
1380 
	(type_) = DEREF_type(x603_ + 1);\
1381 
	(arg1_) = DEREF_exp(x603_ + 2);\
1382 
	(arg2_) = DEREF_exp(x603_ + 3);\
2 7u83 1383 
    }
1384 
 
7 7u83 1385 
#define DESTROY_exp_rem(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1386 
    {\
7 7u83 1387 
	c_class *x604_ = CHECK_TAG((c_class_exp), 32);\
1388 
	(type_) = DEREF_type(x604_ + 1);\
1389 
	(arg1_) = DEREF_exp(x604_ + 2);\
1390 
	(arg2_) = DEREF_exp(x604_ + 3);\
1391 
	(destroyer_)(x604_, (unsigned)4);\
2 7u83 1392 
    }
1393 
 
1394 
 
1395 
/* Operations for field and of union EXP */
1396 
 
7 7u83 1397 
#define exp_and_tag			((unsigned)33)
1398 
#define IS_exp_and(P)			(CHECK_NULL(P)->ag_tag == 33)
2 7u83 1399 
 
7 7u83 1400 
#define exp_and_arg1(P)			(CHECK_TAG((P), 33) + 2)
1401 
#define exp_and_arg2(P)			(CHECK_TAG((P), 33) + 3)
2 7u83 1402 
 
7 7u83 1403 
#define MAKE_exp_and(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1404 
    {\
7 7u83 1405 
	c_class *x605_ = GEN_c_class(4, TYPEID_exp);\
1406 
	x605_->ag_tag = 33;\
1407 
	COPY_type(x605_ + 1, (type_));\
1408 
	COPY_exp(x605_ + 2, (arg1_));\
1409 
	COPY_exp(x605_ + 3, (arg2_));\
1410 
	(c_class_exp) = x605_;\
2 7u83 1411 
    }
1412 
 
7 7u83 1413 
#define DECONS_exp_and(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1414 
    {\
7 7u83 1415 
	c_class *x606_ = CHECK_TAG((c_class_exp), 33);\
1416 
	(type_) = DEREF_type(x606_ + 1);\
1417 
	(arg1_) = DEREF_exp(x606_ + 2);\
1418 
	(arg2_) = DEREF_exp(x606_ + 3);\
2 7u83 1419 
    }
1420 
 
7 7u83 1421 
#define DESTROY_exp_and(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1422 
    {\
7 7u83 1423 
	c_class *x607_ = CHECK_TAG((c_class_exp), 33);\
1424 
	(type_) = DEREF_type(x607_ + 1);\
1425 
	(arg1_) = DEREF_exp(x607_ + 2);\
1426 
	(arg2_) = DEREF_exp(x607_ + 3);\
1427 
	(destroyer_)(x607_, (unsigned)4);\
2 7u83 1428 
    }
1429 
 
1430 
 
1431 
/* Operations for field or of union EXP */
1432 
 
7 7u83 1433 
#define exp_or_tag			((unsigned)34)
1434 
#define IS_exp_or(P)			(CHECK_NULL(P)->ag_tag == 34)
2 7u83 1435 
 
7 7u83 1436 
#define exp_or_arg1(P)			(CHECK_TAG((P), 34) + 2)
1437 
#define exp_or_arg2(P)			(CHECK_TAG((P), 34) + 3)
2 7u83 1438 
 
7 7u83 1439 
#define MAKE_exp_or(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1440 
    {\
7 7u83 1441 
	c_class *x608_ = GEN_c_class(4, TYPEID_exp);\
1442 
	x608_->ag_tag = 34;\
1443 
	COPY_type(x608_ + 1, (type_));\
1444 
	COPY_exp(x608_ + 2, (arg1_));\
1445 
	COPY_exp(x608_ + 3, (arg2_));\
1446 
	(c_class_exp) = x608_;\
2 7u83 1447 
    }
1448 
 
7 7u83 1449 
#define DECONS_exp_or(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1450 
    {\
7 7u83 1451 
	c_class *x609_ = CHECK_TAG((c_class_exp), 34);\
1452 
	(type_) = DEREF_type(x609_ + 1);\
1453 
	(arg1_) = DEREF_exp(x609_ + 2);\
1454 
	(arg2_) = DEREF_exp(x609_ + 3);\
2 7u83 1455 
    }
1456 
 
7 7u83 1457 
#define DESTROY_exp_or(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1458 
    {\
7 7u83 1459 
	c_class *x610_ = CHECK_TAG((c_class_exp), 34);\
1460 
	(type_) = DEREF_type(x610_ + 1);\
1461 
	(arg1_) = DEREF_exp(x610_ + 2);\
1462 
	(arg2_) = DEREF_exp(x610_ + 3);\
1463 
	(destroyer_)(x610_, (unsigned)4);\
2 7u83 1464 
    }
1465 
 
1466 
 
1467 
/* Operations for field xor of union EXP */
1468 
 
7 7u83 1469 
#define exp_xor_tag			((unsigned)35)
1470 
#define IS_exp_xor(P)			(CHECK_NULL(P)->ag_tag == 35)
2 7u83 1471 
 
7 7u83 1472 
#define exp_xor_arg1(P)			(CHECK_TAG((P), 35) + 2)
1473 
#define exp_xor_arg2(P)			(CHECK_TAG((P), 35) + 3)
2 7u83 1474 
 
7 7u83 1475 
#define MAKE_exp_xor(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1476 
    {\
7 7u83 1477 
	c_class *x611_ = GEN_c_class(4, TYPEID_exp);\
1478 
	x611_->ag_tag = 35;\
1479 
	COPY_type(x611_ + 1, (type_));\
1480 
	COPY_exp(x611_ + 2, (arg1_));\
1481 
	COPY_exp(x611_ + 3, (arg2_));\
1482 
	(c_class_exp) = x611_;\
2 7u83 1483 
    }
1484 
 
7 7u83 1485 
#define DECONS_exp_xor(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1486 
    {\
7 7u83 1487 
	c_class *x612_ = CHECK_TAG((c_class_exp), 35);\
1488 
	(type_) = DEREF_type(x612_ + 1);\
1489 
	(arg1_) = DEREF_exp(x612_ + 2);\
1490 
	(arg2_) = DEREF_exp(x612_ + 3);\
2 7u83 1491 
    }
1492 
 
7 7u83 1493 
#define DESTROY_exp_xor(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1494 
    {\
7 7u83 1495 
	c_class *x613_ = CHECK_TAG((c_class_exp), 35);\
1496 
	(type_) = DEREF_type(x613_ + 1);\
1497 
	(arg1_) = DEREF_exp(x613_ + 2);\
1498 
	(arg2_) = DEREF_exp(x613_ + 3);\
1499 
	(destroyer_)(x613_, (unsigned)4);\
2 7u83 1500 
    }
1501 
 
1502 
 
1503 
/* Operations for field log_and of union EXP */
1504 
 
7 7u83 1505 
#define exp_log_and_tag			((unsigned)36)
1506 
#define IS_exp_log_and(P)		(CHECK_NULL(P)->ag_tag == 36)
2 7u83 1507 
 
7 7u83 1508 
#define exp_log_and_arg1(P)		(CHECK_TAG((P), 36) + 2)
1509 
#define exp_log_and_arg2(P)		(CHECK_TAG((P), 36) + 3)
2 7u83 1510 
 
7 7u83 1511 
#define MAKE_exp_log_and(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1512 
    {\
7 7u83 1513 
	c_class *x614_ = GEN_c_class(4, TYPEID_exp);\
1514 
	x614_->ag_tag = 36;\
1515 
	COPY_type(x614_ + 1, (type_));\
1516 
	COPY_exp(x614_ + 2, (arg1_));\
1517 
	COPY_exp(x614_ + 3, (arg2_));\
1518 
	(c_class_exp) = x614_;\
2 7u83 1519 
    }
1520 
 
7 7u83 1521 
#define DECONS_exp_log_and(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1522 
    {\
7 7u83 1523 
	c_class *x615_ = CHECK_TAG((c_class_exp), 36);\
1524 
	(type_) = DEREF_type(x615_ + 1);\
1525 
	(arg1_) = DEREF_exp(x615_ + 2);\
1526 
	(arg2_) = DEREF_exp(x615_ + 3);\
2 7u83 1527 
    }
1528 
 
7 7u83 1529 
#define DESTROY_exp_log_and(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1530 
    {\
7 7u83 1531 
	c_class *x616_ = CHECK_TAG((c_class_exp), 36);\
1532 
	(type_) = DEREF_type(x616_ + 1);\
1533 
	(arg1_) = DEREF_exp(x616_ + 2);\
1534 
	(arg2_) = DEREF_exp(x616_ + 3);\
1535 
	(destroyer_)(x616_, (unsigned)4);\
2 7u83 1536 
    }
1537 
 
1538 
 
1539 
/* Operations for field log_or of union EXP */
1540 
 
7 7u83 1541 
#define exp_log_or_tag			((unsigned)37)
1542 
#define IS_exp_log_or(P)		(CHECK_NULL(P)->ag_tag == 37)
2 7u83 1543 
 
7 7u83 1544 
#define exp_log_or_arg1(P)		(CHECK_TAG((P), 37) + 2)
1545 
#define exp_log_or_arg2(P)		(CHECK_TAG((P), 37) + 3)
2 7u83 1546 
 
7 7u83 1547 
#define MAKE_exp_log_or(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1548 
    {\
7 7u83 1549 
	c_class *x617_ = GEN_c_class(4, TYPEID_exp);\
1550 
	x617_->ag_tag = 37;\
1551 
	COPY_type(x617_ + 1, (type_));\
1552 
	COPY_exp(x617_ + 2, (arg1_));\
1553 
	COPY_exp(x617_ + 3, (arg2_));\
1554 
	(c_class_exp) = x617_;\
2 7u83 1555 
    }
1556 
 
7 7u83 1557 
#define DECONS_exp_log_or(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1558 
    {\
7 7u83 1559 
	c_class *x618_ = CHECK_TAG((c_class_exp), 37);\
1560 
	(type_) = DEREF_type(x618_ + 1);\
1561 
	(arg1_) = DEREF_exp(x618_ + 2);\
1562 
	(arg2_) = DEREF_exp(x618_ + 3);\
2 7u83 1563 
    }
1564 
 
7 7u83 1565 
#define DESTROY_exp_log_or(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1566 
    {\
7 7u83 1567 
	c_class *x619_ = CHECK_TAG((c_class_exp), 37);\
1568 
	(type_) = DEREF_type(x619_ + 1);\
1569 
	(arg1_) = DEREF_exp(x619_ + 2);\
1570 
	(arg2_) = DEREF_exp(x619_ + 3);\
1571 
	(destroyer_)(x619_, (unsigned)4);\
2 7u83 1572 
    }
1573 
 
1574 
 
1575 
/* Operations for field lshift of union EXP */
1576 
 
7 7u83 1577 
#define exp_lshift_tag			((unsigned)38)
1578 
#define IS_exp_lshift(P)		(CHECK_NULL(P)->ag_tag == 38)
2 7u83 1579 
 
7 7u83 1580 
#define exp_lshift_arg1(P)		(CHECK_TAG((P), 38) + 2)
1581 
#define exp_lshift_arg2(P)		(CHECK_TAG((P), 38) + 3)
2 7u83 1582 
 
7 7u83 1583 
#define MAKE_exp_lshift(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1584 
    {\
7 7u83 1585 
	c_class *x620_ = GEN_c_class(4, TYPEID_exp);\
1586 
	x620_->ag_tag = 38;\
1587 
	COPY_type(x620_ + 1, (type_));\
1588 
	COPY_exp(x620_ + 2, (arg1_));\
1589 
	COPY_exp(x620_ + 3, (arg2_));\
1590 
	(c_class_exp) = x620_;\
2 7u83 1591 
    }
1592 
 
7 7u83 1593 
#define DECONS_exp_lshift(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1594 
    {\
7 7u83 1595 
	c_class *x621_ = CHECK_TAG((c_class_exp), 38);\
1596 
	(type_) = DEREF_type(x621_ + 1);\
1597 
	(arg1_) = DEREF_exp(x621_ + 2);\
1598 
	(arg2_) = DEREF_exp(x621_ + 3);\
2 7u83 1599 
    }
1600 
 
7 7u83 1601 
#define DESTROY_exp_lshift(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1602 
    {\
7 7u83 1603 
	c_class *x622_ = CHECK_TAG((c_class_exp), 38);\
1604 
	(type_) = DEREF_type(x622_ + 1);\
1605 
	(arg1_) = DEREF_exp(x622_ + 2);\
1606 
	(arg2_) = DEREF_exp(x622_ + 3);\
1607 
	(destroyer_)(x622_, (unsigned)4);\
2 7u83 1608 
    }
1609 
 
1610 
 
1611 
/* Operations for field rshift of union EXP */
1612 
 
7 7u83 1613 
#define exp_rshift_tag			((unsigned)39)
1614 
#define IS_exp_rshift(P)		(CHECK_NULL(P)->ag_tag == 39)
2 7u83 1615 
 
7 7u83 1616 
#define exp_rshift_arg1(P)		(CHECK_TAG((P), 39) + 2)
1617 
#define exp_rshift_arg2(P)		(CHECK_TAG((P), 39) + 3)
2 7u83 1618 
 
7 7u83 1619 
#define MAKE_exp_rshift(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1620 
    {\
7 7u83 1621 
	c_class *x623_ = GEN_c_class(4, TYPEID_exp);\
1622 
	x623_->ag_tag = 39;\
1623 
	COPY_type(x623_ + 1, (type_));\
1624 
	COPY_exp(x623_ + 2, (arg1_));\
1625 
	COPY_exp(x623_ + 3, (arg2_));\
1626 
	(c_class_exp) = x623_;\
2 7u83 1627 
    }
1628 
 
7 7u83 1629 
#define DECONS_exp_rshift(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1630 
    {\
7 7u83 1631 
	c_class *x624_ = CHECK_TAG((c_class_exp), 39);\
1632 
	(type_) = DEREF_type(x624_ + 1);\
1633 
	(arg1_) = DEREF_exp(x624_ + 2);\
1634 
	(arg2_) = DEREF_exp(x624_ + 3);\
2 7u83 1635 
    }
1636 
 
7 7u83 1637 
#define DESTROY_exp_rshift(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1638 
    {\
7 7u83 1639 
	c_class *x625_ = CHECK_TAG((c_class_exp), 39);\
1640 
	(type_) = DEREF_type(x625_ + 1);\
1641 
	(arg1_) = DEREF_exp(x625_ + 2);\
1642 
	(arg2_) = DEREF_exp(x625_ + 3);\
1643 
	(destroyer_)(x625_, (unsigned)4);\
2 7u83 1644 
    }
1645 
 
1646 
 
1647 
/* Operations for field max of union EXP */
1648 
 
7 7u83 1649 
#define exp_max_tag			((unsigned)40)
1650 
#define IS_exp_max(P)			(CHECK_NULL(P)->ag_tag == 40)
2 7u83 1651 
 
7 7u83 1652 
#define exp_max_arg1(P)			(CHECK_TAG((P), 40) + 2)
1653 
#define exp_max_arg2(P)			(CHECK_TAG((P), 40) + 3)
2 7u83 1654 
 
7 7u83 1655 
#define MAKE_exp_max(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1656 
    {\
7 7u83 1657 
	c_class *x626_ = GEN_c_class(4, TYPEID_exp);\
1658 
	x626_->ag_tag = 40;\
1659 
	COPY_type(x626_ + 1, (type_));\
1660 
	COPY_exp(x626_ + 2, (arg1_));\
1661 
	COPY_exp(x626_ + 3, (arg2_));\
1662 
	(c_class_exp) = x626_;\
2 7u83 1663 
    }
1664 
 
7 7u83 1665 
#define DECONS_exp_max(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1666 
    {\
7 7u83 1667 
	c_class *x627_ = CHECK_TAG((c_class_exp), 40);\
1668 
	(type_) = DEREF_type(x627_ + 1);\
1669 
	(arg1_) = DEREF_exp(x627_ + 2);\
1670 
	(arg2_) = DEREF_exp(x627_ + 3);\
2 7u83 1671 
    }
1672 
 
7 7u83 1673 
#define DESTROY_exp_max(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1674 
    {\
7 7u83 1675 
	c_class *x628_ = CHECK_TAG((c_class_exp), 40);\
1676 
	(type_) = DEREF_type(x628_ + 1);\
1677 
	(arg1_) = DEREF_exp(x628_ + 2);\
1678 
	(arg2_) = DEREF_exp(x628_ + 3);\
1679 
	(destroyer_)(x628_, (unsigned)4);\
2 7u83 1680 
    }
1681 
 
1682 
 
1683 
/* Operations for field min of union EXP */
1684 
 
7 7u83 1685 
#define exp_min_tag			((unsigned)41)
1686 
#define IS_exp_min(P)			(CHECK_NULL(P)->ag_tag == 41)
2 7u83 1687 
 
7 7u83 1688 
#define exp_min_arg1(P)			(CHECK_TAG((P), 41) + 2)
1689 
#define exp_min_arg2(P)			(CHECK_TAG((P), 41) + 3)
2 7u83 1690 
 
7 7u83 1691 
#define MAKE_exp_min(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1692 
    {\
7 7u83 1693 
	c_class *x629_ = GEN_c_class(4, TYPEID_exp);\
1694 
	x629_->ag_tag = 41;\
1695 
	COPY_type(x629_ + 1, (type_));\
1696 
	COPY_exp(x629_ + 2, (arg1_));\
1697 
	COPY_exp(x629_ + 3, (arg2_));\
1698 
	(c_class_exp) = x629_;\
2 7u83 1699 
    }
1700 
 
7 7u83 1701 
#define DECONS_exp_min(type_, arg1_, arg2_, c_class_exp)\
2 7u83 1702 
    {\
7 7u83 1703 
	c_class *x630_ = CHECK_TAG((c_class_exp), 41);\
1704 
	(type_) = DEREF_type(x630_ + 1);\
1705 
	(arg1_) = DEREF_exp(x630_ + 2);\
1706 
	(arg2_) = DEREF_exp(x630_ + 3);\
2 7u83 1707 
    }
1708 
 
7 7u83 1709 
#define DESTROY_exp_min(destroyer_, type_, arg1_, arg2_, c_class_exp)\
2 7u83 1710 
    {\
7 7u83 1711 
	c_class *x631_ = CHECK_TAG((c_class_exp), 41);\
1712 
	(type_) = DEREF_type(x631_ + 1);\
1713 
	(arg1_) = DEREF_exp(x631_ + 2);\
1714 
	(arg2_) = DEREF_exp(x631_ + 3);\
1715 
	(destroyer_)(x631_, (unsigned)4);\
2 7u83 1716 
    }
1717 
 
1718 
 
1719 
/* Operations for field test of union EXP */
1720 
 
7 7u83 1721 
#define exp_test_tag			((unsigned)42)
1722 
#define IS_exp_test(P)			(CHECK_NULL(P)->ag_tag == 42)
2 7u83 1723 
 
7 7u83 1724 
#define exp_test_tst(P)			(CHECK_TAG((P), 42) + 2)
1725 
#define exp_test_arg(P)			(CHECK_TAG((P), 42) + 3)
2 7u83 1726 
 
7 7u83 1727 
#define MAKE_exp_test(type_, tst_, arg_, c_class_exp)\
2 7u83 1728 
    {\
7 7u83 1729 
	c_class *x632_ = GEN_c_class(4, TYPEID_exp);\
1730 
	x632_->ag_tag = 42;\
1731 
	COPY_type(x632_ + 1, (type_));\
1732 
	COPY_ntest(x632_ + 2, (tst_));\
1733 
	COPY_exp(x632_ + 3, (arg_));\
1734 
	(c_class_exp) = x632_;\
2 7u83 1735 
    }
1736 
 
7 7u83 1737 
#define DECONS_exp_test(type_, tst_, arg_, c_class_exp)\
2 7u83 1738 
    {\
7 7u83 1739 
	c_class *x633_ = CHECK_TAG((c_class_exp), 42);\
1740 
	(type_) = DEREF_type(x633_ + 1);\
1741 
	(tst_) = DEREF_ntest(x633_ + 2);\
1742 
	(arg_) = DEREF_exp(x633_ + 3);\
2 7u83 1743 
    }
1744 
 
7 7u83 1745 
#define DESTROY_exp_test(destroyer_, type_, tst_, arg_, c_class_exp)\
2 7u83 1746 
    {\
7 7u83 1747 
	c_class *x634_ = CHECK_TAG((c_class_exp), 42);\
1748 
	(type_) = DEREF_type(x634_ + 1);\
1749 
	(tst_) = DEREF_ntest(x634_ + 2);\
1750 
	(arg_) = DEREF_exp(x634_ + 3);\
1751 
	(destroyer_)(x634_, (unsigned)4);\
2 7u83 1752 
    }
1753 
 
1754 
 
1755 
/* Operations for field compare of union EXP */
1756 
 
7 7u83 1757 
#define exp_compare_tag			((unsigned)43)
1758 
#define IS_exp_compare(P)		(CHECK_NULL(P)->ag_tag == 43)
2 7u83 1759 
 
7 7u83 1760 
#define exp_compare_tst(P)		(CHECK_TAG((P), 43) + 2)
1761 
#define exp_compare_arg1(P)		(CHECK_TAG((P), 43) + 3)
1762 
#define exp_compare_arg2(P)		(CHECK_TAG((P), 43) + 4)
2 7u83 1763 
 
7 7u83 1764 
#define MAKE_exp_compare(type_, tst_, arg1_, arg2_, c_class_exp)\
2 7u83 1765 
    {\
7 7u83 1766 
	c_class *x635_ = GEN_c_class(5, TYPEID_exp);\
1767 
	x635_->ag_tag = 43;\
1768 
	COPY_type(x635_ + 1, (type_));\
1769 
	COPY_ntest(x635_ + 2, (tst_));\
1770 
	COPY_exp(x635_ + 3, (arg1_));\
1771 
	COPY_exp(x635_ + 4, (arg2_));\
1772 
	(c_class_exp) = x635_;\
2 7u83 1773 
    }
1774 
 
7 7u83 1775 
#define DECONS_exp_compare(type_, tst_, arg1_, arg2_, c_class_exp)\
2 7u83 1776 
    {\
7 7u83 1777 
	c_class *x636_ = CHECK_TAG((c_class_exp), 43);\
1778 
	(type_) = DEREF_type(x636_ + 1);\
1779 
	(tst_) = DEREF_ntest(x636_ + 2);\
1780 
	(arg1_) = DEREF_exp(x636_ + 3);\
1781 
	(arg2_) = DEREF_exp(x636_ + 4);\
2 7u83 1782 
    }
1783 
 
7 7u83 1784 
#define DESTROY_exp_compare(destroyer_, type_, tst_, arg1_, arg2_, c_class_exp)\
2 7u83 1785 
    {\
7 7u83 1786 
	c_class *x637_ = CHECK_TAG((c_class_exp), 43);\
1787 
	(type_) = DEREF_type(x637_ + 1);\
1788 
	(tst_) = DEREF_ntest(x637_ + 2);\
1789 
	(arg1_) = DEREF_exp(x637_ + 3);\
1790 
	(arg2_) = DEREF_exp(x637_ + 4);\
1791 
	(destroyer_)(x637_, (unsigned)5);\
2 7u83 1792 
    }
1793 
 
1794 
 
1795 
/* Operations for field cast of union EXP */
1796 
 
7 7u83 1797 
#define exp_cast_tag			((unsigned)44)
1798 
#define IS_exp_cast(P)			(CHECK_NULL(P)->ag_tag == 44)
2 7u83 1799 
 
7 7u83 1800 
#define exp_cast_conv(P)		(CHECK_TAG((P), 44) + 2)
1801 
#define exp_cast_arg(P)			(CHECK_TAG((P), 44) + 3)
2 7u83 1802 
 
7 7u83 1803 
#define MAKE_exp_cast(type_, conv_, arg_, c_class_exp)\
2 7u83 1804 
    {\
7 7u83 1805 
	c_class *x638_ = GEN_c_class(4, TYPEID_exp);\
1806 
	x638_->ag_tag = 44;\
1807 
	COPY_type(x638_ + 1, (type_));\
1808 
	COPY_unsigned(x638_ + 2, (conv_));\
1809 
	COPY_exp(x638_ + 3, (arg_));\
1810 
	(c_class_exp) = x638_;\
2 7u83 1811 
    }
1812 
 
7 7u83 1813 
#define DECONS_exp_cast(type_, conv_, arg_, c_class_exp)\
2 7u83 1814 
    {\
7 7u83 1815 
	c_class *x639_ = CHECK_TAG((c_class_exp), 44);\
1816 
	(type_) = DEREF_type(x639_ + 1);\
1817 
	(conv_) = DEREF_unsigned(x639_ + 2);\
1818 
	(arg_) = DEREF_exp(x639_ + 3);\
2 7u83 1819 
    }
1820 
 
7 7u83 1821 
#define DESTROY_exp_cast(destroyer_, type_, conv_, arg_, c_class_exp)\
2 7u83 1822 
    {\
7 7u83 1823 
	c_class *x640_ = CHECK_TAG((c_class_exp), 44);\
1824 
	(type_) = DEREF_type(x640_ + 1);\
1825 
	(conv_) = DEREF_unsigned(x640_ + 2);\
1826 
	(arg_) = DEREF_exp(x640_ + 3);\
1827 
	(destroyer_)(x640_, (unsigned)4);\
2 7u83 1828 
    }
1829 
 
1830 
 
1831 
/* Operations for field base_cast of union EXP */
1832 
 
7 7u83 1833 
#define exp_base_cast_tag		((unsigned)45)
1834 
#define IS_exp_base_cast(P)		(CHECK_NULL(P)->ag_tag == 45)
2 7u83 1835 
 
7 7u83 1836 
#define exp_base_cast_conv(P)		(CHECK_TAG((P), 45) + 2)
1837 
#define exp_base_cast_arg(P)		(CHECK_TAG((P), 45) + 3)
1838 
#define exp_base_cast_off(P)		(CHECK_TAG((P), 45) + 4)
2 7u83 1839 
 
7 7u83 1840 
#define MAKE_exp_base_cast(type_, conv_, arg_, off_, c_class_exp)\
2 7u83 1841 
    {\
7 7u83 1842 
	c_class *x641_ = GEN_c_class(5, TYPEID_exp);\
1843 
	x641_->ag_tag = 45;\
1844 
	COPY_type(x641_ + 1, (type_));\
1845 
	COPY_unsigned(x641_ + 2, (conv_));\
1846 
	COPY_exp(x641_ + 3, (arg_));\
1847 
	COPY_off(x641_ + 4, (off_));\
1848 
	(c_class_exp) = x641_;\
2 7u83 1849 
    }
1850 
 
7 7u83 1851 
#define DECONS_exp_base_cast(type_, conv_, arg_, off_, c_class_exp)\
2 7u83 1852 
    {\
7 7u83 1853 
	c_class *x642_ = CHECK_TAG((c_class_exp), 45);\
1854 
	(type_) = DEREF_type(x642_ + 1);\
1855 
	(conv_) = DEREF_unsigned(x642_ + 2);\
1856 
	(arg_) = DEREF_exp(x642_ + 3);\
1857 
	(off_) = DEREF_off(x642_ + 4);\
2 7u83 1858 
    }
1859 
 
7 7u83 1860 
#define DESTROY_exp_base_cast(destroyer_, type_, conv_, arg_, off_, c_class_exp)\
2 7u83 1861 
    {\
7 7u83 1862 
	c_class *x643_ = CHECK_TAG((c_class_exp), 45);\
1863 
	(type_) = DEREF_type(x643_ + 1);\
1864 
	(conv_) = DEREF_unsigned(x643_ + 2);\
1865 
	(arg_) = DEREF_exp(x643_ + 3);\
1866 
	(off_) = DEREF_off(x643_ + 4);\
1867 
	(destroyer_)(x643_, (unsigned)5);\
2 7u83 1868 
    }
1869 
 
1870 
 
1871 
/* Operations for field dyn_cast of union EXP */
1872 
 
7 7u83 1873 
#define exp_dyn_cast_tag		((unsigned)46)
1874 
#define IS_exp_dyn_cast(P)		(CHECK_NULL(P)->ag_tag == 46)
2 7u83 1875 
 
7 7u83 1876 
#define exp_dyn_cast_arg(P)		(CHECK_TAG((P), 46) + 2)
1877 
#define exp_dyn_cast_except(P)		(CHECK_TAG((P), 46) + 3)
2 7u83 1878 
 
7 7u83 1879 
#define MAKE_exp_dyn_cast(type_, arg_, except_, c_class_exp)\
2 7u83 1880 
    {\
7 7u83 1881 
	c_class *x644_ = GEN_c_class(4, TYPEID_exp);\
1882 
	x644_->ag_tag = 46;\
1883 
	COPY_type(x644_ + 1, (type_));\
1884 
	COPY_exp(x644_ + 2, (arg_));\
1885 
	COPY_exp(x644_ + 3, (except_));\
1886 
	(c_class_exp) = x644_;\
2 7u83 1887 
    }
1888 
 
7 7u83 1889 
#define DECONS_exp_dyn_cast(type_, arg_, except_, c_class_exp)\
2 7u83 1890 
    {\
7 7u83 1891 
	c_class *x645_ = CHECK_TAG((c_class_exp), 46);\
1892 
	(type_) = DEREF_type(x645_ + 1);\
1893 
	(arg_) = DEREF_exp(x645_ + 2);\
1894 
	(except_) = DEREF_exp(x645_ + 3);\
2 7u83 1895 
    }
1896 
 
7 7u83 1897 
#define DESTROY_exp_dyn_cast(destroyer_, type_, arg_, except_, c_class_exp)\
2 7u83 1898 
    {\
7 7u83 1899 
	c_class *x646_ = CHECK_TAG((c_class_exp), 46);\
1900 
	(type_) = DEREF_type(x646_ + 1);\
1901 
	(arg_) = DEREF_exp(x646_ + 2);\
1902 
	(except_) = DEREF_exp(x646_ + 3);\
1903 
	(destroyer_)(x646_, (unsigned)4);\
2 7u83 1904 
    }
1905 
 
1906 
 
1907 
/* Operations for field add_ptr of union EXP */
1908 
 
7 7u83 1909 
#define exp_add_ptr_tag			((unsigned)47)
1910 
#define IS_exp_add_ptr(P)		(CHECK_NULL(P)->ag_tag == 47)
2 7u83 1911 
 
7 7u83 1912 
#define exp_add_ptr_ptr(P)		(CHECK_TAG((P), 47) + 2)
1913 
#define exp_add_ptr_off(P)		(CHECK_TAG((P), 47) + 3)
1914 
#define exp_add_ptr_virt(P)		(CHECK_TAG((P), 47) + 4)
2 7u83 1915 
 
7 7u83 1916 
#define MAKE_exp_add_ptr(type_, ptr_, off_, virt_, c_class_exp)\
2 7u83 1917 
    {\
7 7u83 1918 
	c_class *x647_ = GEN_c_class(5, TYPEID_exp);\
1919 
	x647_->ag_tag = 47;\
1920 
	COPY_type(x647_ + 1, (type_));\
1921 
	COPY_exp(x647_ + 2, (ptr_));\
1922 
	COPY_off(x647_ + 3, (off_));\
1923 
	COPY_int(x647_ + 4, (virt_));\
1924 
	(c_class_exp) = x647_;\
2 7u83 1925 
    }
1926 
 
7 7u83 1927 
#define DECONS_exp_add_ptr(type_, ptr_, off_, virt_, c_class_exp)\
2 7u83 1928 
    {\
7 7u83 1929 
	c_class *x648_ = CHECK_TAG((c_class_exp), 47);\
1930 
	(type_) = DEREF_type(x648_ + 1);\
1931 
	(ptr_) = DEREF_exp(x648_ + 2);\
1932 
	(off_) = DEREF_off(x648_ + 3);\
1933 
	(virt_) = DEREF_int(x648_ + 4);\
2 7u83 1934 
    }
1935 
 
7 7u83 1936 
#define DESTROY_exp_add_ptr(destroyer_, type_, ptr_, off_, virt_, c_class_exp)\
2 7u83 1937 
    {\
7 7u83 1938 
	c_class *x649_ = CHECK_TAG((c_class_exp), 47);\
1939 
	(type_) = DEREF_type(x649_ + 1);\
1940 
	(ptr_) = DEREF_exp(x649_ + 2);\
1941 
	(off_) = DEREF_off(x649_ + 3);\
1942 
	(virt_) = DEREF_int(x649_ + 4);\
1943 
	(destroyer_)(x649_, (unsigned)5);\
2 7u83 1944 
    }
1945 
 
1946 
 
1947 
/* Operations for field offset_size of union EXP */
1948 
 
7 7u83 1949 
#define exp_offset_size_tag		((unsigned)48)
1950 
#define IS_exp_offset_size(P)		(CHECK_NULL(P)->ag_tag == 48)
2 7u83 1951 
 
7 7u83 1952 
#define exp_offset_size_off(P)		(CHECK_TAG((P), 48) + 2)
1953 
#define exp_offset_size_step(P)		(CHECK_TAG((P), 48) + 3)
1954 
#define exp_offset_size_pad(P)		(CHECK_TAG((P), 48) + 4)
2 7u83 1955 
 
7 7u83 1956 
#define MAKE_exp_offset_size(type_, off_, step_, pad_, c_class_exp)\
2 7u83 1957 
    {\
7 7u83 1958 
	c_class *x650_ = GEN_c_class(5, TYPEID_exp);\
1959 
	x650_->ag_tag = 48;\
1960 
	COPY_type(x650_ + 1, (type_));\
1961 
	COPY_off(x650_ + 2, (off_));\
1962 
	COPY_type(x650_ + 3, (step_));\
1963 
	COPY_int(x650_ + 4, (pad_));\
1964 
	(c_class_exp) = x650_;\
2 7u83 1965 
    }
1966 
 
7 7u83 1967 
#define DECONS_exp_offset_size(type_, off_, step_, pad_, c_class_exp)\
2 7u83 1968 
    {\
7 7u83 1969 
	c_class *x651_ = CHECK_TAG((c_class_exp), 48);\
1970 
	(type_) = DEREF_type(x651_ + 1);\
1971 
	(off_) = DEREF_off(x651_ + 2);\
1972 
	(step_) = DEREF_type(x651_ + 3);\
1973 
	(pad_) = DEREF_int(x651_ + 4);\
2 7u83 1974 
    }
1975 
 
7 7u83 1976 
#define DESTROY_exp_offset_size(destroyer_, type_, off_, step_, pad_, c_class_exp)\
2 7u83 1977 
    {\
7 7u83 1978 
	c_class *x652_ = CHECK_TAG((c_class_exp), 48);\
1979 
	(type_) = DEREF_type(x652_ + 1);\
1980 
	(off_) = DEREF_off(x652_ + 2);\
1981 
	(step_) = DEREF_type(x652_ + 3);\
1982 
	(pad_) = DEREF_int(x652_ + 4);\
1983 
	(destroyer_)(x652_, (unsigned)5);\
2 7u83 1984 
    }
1985 
 
1986 
 
1987 
/* Operations for field constr of union EXP */
1988 
 
7 7u83 1989 
#define exp_constr_tag			((unsigned)49)
1990 
#define IS_exp_constr(P)		(CHECK_NULL(P)->ag_tag == 49)
2 7u83 1991 
 
7 7u83 1992 
#define exp_constr_call(P)		(CHECK_TAG((P), 49) + 2)
1993 
#define exp_constr_obj(P)		(CHECK_TAG((P), 49) + 3)
1994 
#define exp_constr_alt(P)		(CHECK_TAG((P), 49) + 4)
1995 
#define exp_constr_info(P)		(CHECK_TAG((P), 49) + 5)
2 7u83 1996 
 
7 7u83 1997 
#define MAKE_exp_constr(type_, call_, obj_, alt_, info_, c_class_exp)\
2 7u83 1998 
    {\
7 7u83 1999 
	c_class *x653_ = GEN_c_class(6, TYPEID_exp);\
2000 
	x653_->ag_tag = 49;\
2001 
	COPY_type(x653_ + 1, (type_));\
2002 
	COPY_exp(x653_ + 2, (call_));\
2003 
	COPY_exp(x653_ + 3, (obj_));\
2004 
	COPY_exp(x653_ + 4, (alt_));\
2005 
	COPY_int(x653_ + 5, (info_));\
2006 
	(c_class_exp) = x653_;\
2 7u83 2007 
    }
2008 
 
7 7u83 2009 
#define DECONS_exp_constr(type_, call_, obj_, alt_, info_, c_class_exp)\
2 7u83 2010 
    {\
7 7u83 2011 
	c_class *x654_ = CHECK_TAG((c_class_exp), 49);\
2012 
	(type_) = DEREF_type(x654_ + 1);\
2013 
	(call_) = DEREF_exp(x654_ + 2);\
2014 
	(obj_) = DEREF_exp(x654_ + 3);\
2015 
	(alt_) = DEREF_exp(x654_ + 4);\
2016 
	(info_) = DEREF_int(x654_ + 5);\
2 7u83 2017 
    }
2018 
 
7 7u83 2019 
#define DESTROY_exp_constr(destroyer_, type_, call_, obj_, alt_, info_, c_class_exp)\
2 7u83 2020 
    {\
7 7u83 2021 
	c_class *x655_ = CHECK_TAG((c_class_exp), 49);\
2022 
	(type_) = DEREF_type(x655_ + 1);\
2023 
	(call_) = DEREF_exp(x655_ + 2);\
2024 
	(obj_) = DEREF_exp(x655_ + 3);\
2025 
	(alt_) = DEREF_exp(x655_ + 4);\
2026 
	(info_) = DEREF_int(x655_ + 5);\
2027 
	(destroyer_)(x655_, (unsigned)6);\
2 7u83 2028 
    }
2029 
 
2030 
 
2031 
/* Operations for field destr of union EXP */
2032 
 
7 7u83 2033 
#define exp_destr_tag			((unsigned)50)
2034 
#define IS_exp_destr(P)			(CHECK_NULL(P)->ag_tag == 50)
2 7u83 2035 
 
7 7u83 2036 
#define exp_destr_call(P)		(CHECK_TAG((P), 50) + 2)
2037 
#define exp_destr_obj(P)		(CHECK_TAG((P), 50) + 3)
2038 
#define exp_destr_count(P)		(CHECK_TAG((P), 50) + 4)
2 7u83 2039 
 
7 7u83 2040 
#define MAKE_exp_destr(type_, call_, obj_, c_class_exp)\
2 7u83 2041 
    {\
7 7u83 2042 
	c_class *x656_ = GEN_c_class(5, TYPEID_exp);\
2043 
	x656_->ag_tag = 50;\
2044 
	COPY_type(x656_ + 1, (type_));\
2045 
	COPY_exp(x656_ + 2, (call_));\
2046 
	COPY_exp(x656_ + 3, (obj_));\
2047 
	COPY_exp(x656_ + 4, NULL_exp);\
2048 
	(c_class_exp) = x656_;\
2 7u83 2049 
    }
2050 
 
7 7u83 2051 
#define DECONS_exp_destr(type_, call_, obj_, count_, c_class_exp)\
2 7u83 2052 
    {\
7 7u83 2053 
	c_class *x657_ = CHECK_TAG((c_class_exp), 50);\
2054 
	(type_) = DEREF_type(x657_ + 1);\
2055 
	(call_) = DEREF_exp(x657_ + 2);\
2056 
	(obj_) = DEREF_exp(x657_ + 3);\
2057 
	(count_) = DEREF_exp(x657_ + 4);\
2 7u83 2058 
    }
2059 
 
7 7u83 2060 
#define DESTROY_exp_destr(destroyer_, type_, call_, obj_, count_, c_class_exp)\
2 7u83 2061 
    {\
7 7u83 2062 
	c_class *x658_ = CHECK_TAG((c_class_exp), 50);\
2063 
	(type_) = DEREF_type(x658_ + 1);\
2064 
	(call_) = DEREF_exp(x658_ + 2);\
2065 
	(obj_) = DEREF_exp(x658_ + 3);\
2066 
	(count_) = DEREF_exp(x658_ + 4);\
2067 
	(destroyer_)(x658_, (unsigned)5);\
2 7u83 2068 
    }
2069 
 
2070 
 
2071 
/* Operations for field alloc of union EXP */
2072 
 
7 7u83 2073 
#define exp_alloc_tag			((unsigned)51)
2074 
#define IS_exp_alloc(P)			(CHECK_NULL(P)->ag_tag == 51)
2 7u83 2075 
 
7 7u83 2076 
#define exp_alloc_call(P)		(CHECK_TAG((P), 51) + 2)
2077 
#define exp_alloc_init(P)		(CHECK_TAG((P), 51) + 3)
2078 
#define exp_alloc_garbage(P)		(CHECK_TAG((P), 51) + 4)
2079 
#define exp_alloc_size(P)		(CHECK_TAG((P), 51) + 5)
2 7u83 2080 
 
7 7u83 2081 
#define MAKE_exp_alloc(type_, call_, init_, garbage_, size_, c_class_exp)\
2 7u83 2082 
    {\
7 7u83 2083 
	c_class *x659_ = GEN_c_class(6, TYPEID_exp);\
2084 
	x659_->ag_tag = 51;\
2085 
	COPY_type(x659_ + 1, (type_));\
2086 
	COPY_exp(x659_ + 2, (call_));\
2087 
	COPY_exp(x659_ + 3, (init_));\
2088 
	COPY_exp(x659_ + 4, (garbage_));\
2089 
	COPY_exp(x659_ + 5, (size_));\
2090 
	(c_class_exp) = x659_;\
2 7u83 2091 
    }
2092 
 
7 7u83 2093 
#define DECONS_exp_alloc(type_, call_, init_, garbage_, size_, c_class_exp)\
2 7u83 2094 
    {\
7 7u83 2095 
	c_class *x660_ = CHECK_TAG((c_class_exp), 51);\
2096 
	(type_) = DEREF_type(x660_ + 1);\
2097 
	(call_) = DEREF_exp(x660_ + 2);\
2098 
	(init_) = DEREF_exp(x660_ + 3);\
2099 
	(garbage_) = DEREF_exp(x660_ + 4);\
2100 
	(size_) = DEREF_exp(x660_ + 5);\
2 7u83 2101 
    }
2102 
 
7 7u83 2103 
#define DESTROY_exp_alloc(destroyer_, type_, call_, init_, garbage_, size_, c_class_exp)\
2 7u83 2104 
    {\
7 7u83 2105 
	c_class *x661_ = CHECK_TAG((c_class_exp), 51);\
2106 
	(type_) = DEREF_type(x661_ + 1);\
2107 
	(call_) = DEREF_exp(x661_ + 2);\
2108 
	(init_) = DEREF_exp(x661_ + 3);\
2109 
	(garbage_) = DEREF_exp(x661_ + 4);\
2110 
	(size_) = DEREF_exp(x661_ + 5);\
2111 
	(destroyer_)(x661_, (unsigned)6);\
2 7u83 2112 
    }
2113 
 
2114 
 
2115 
/* Operations for field dealloc of union EXP */
2116 
 
7 7u83 2117 
#define exp_dealloc_tag			((unsigned)52)
2118 
#define IS_exp_dealloc(P)		(CHECK_NULL(P)->ag_tag == 52)
2 7u83 2119 
 
7 7u83 2120 
#define exp_dealloc_term(P)		(CHECK_TAG((P), 52) + 2)
2121 
#define exp_dealloc_call(P)		(CHECK_TAG((P), 52) + 3)
2122 
#define exp_dealloc_arg(P)		(CHECK_TAG((P), 52) + 4)
2123 
#define exp_dealloc_size(P)		(CHECK_TAG((P), 52) + 5)
2 7u83 2124 
 
7 7u83 2125 
#define MAKE_exp_dealloc(type_, term_, call_, arg_, size_, c_class_exp)\
2 7u83 2126 
    {\
7 7u83 2127 
	c_class *x662_ = GEN_c_class(6, TYPEID_exp);\
2128 
	x662_->ag_tag = 52;\
2129 
	COPY_type(x662_ + 1, (type_));\
2130 
	COPY_exp(x662_ + 2, (term_));\
2131 
	COPY_exp(x662_ + 3, (call_));\
2132 
	COPY_exp(x662_ + 4, (arg_));\
2133 
	COPY_exp(x662_ + 5, (size_));\
2134 
	(c_class_exp) = x662_;\
2 7u83 2135 
    }
2136 
 
7 7u83 2137 
#define DECONS_exp_dealloc(type_, term_, call_, arg_, size_, c_class_exp)\
2 7u83 2138 
    {\
7 7u83 2139 
	c_class *x663_ = CHECK_TAG((c_class_exp), 52);\
2140 
	(type_) = DEREF_type(x663_ + 1);\
2141 
	(term_) = DEREF_exp(x663_ + 2);\
2142 
	(call_) = DEREF_exp(x663_ + 3);\
2143 
	(arg_) = DEREF_exp(x663_ + 4);\
2144 
	(size_) = DEREF_exp(x663_ + 5);\
2 7u83 2145 
    }
2146 
 
7 7u83 2147 
#define DESTROY_exp_dealloc(destroyer_, type_, term_, call_, arg_, size_, c_class_exp)\
2 7u83 2148 
    {\
7 7u83 2149 
	c_class *x664_ = CHECK_TAG((c_class_exp), 52);\
2150 
	(type_) = DEREF_type(x664_ + 1);\
2151 
	(term_) = DEREF_exp(x664_ + 2);\
2152 
	(call_) = DEREF_exp(x664_ + 3);\
2153 
	(arg_) = DEREF_exp(x664_ + 4);\
2154 
	(size_) = DEREF_exp(x664_ + 5);\
2155 
	(destroyer_)(x664_, (unsigned)6);\
2 7u83 2156 
    }
2157 
 
2158 
 
2159 
/* Operations for field rtti of union EXP */
2160 
 
7 7u83 2161 
#define exp_rtti_tag			((unsigned)53)
2162 
#define IS_exp_rtti(P)			(CHECK_NULL(P)->ag_tag == 53)
2 7u83 2163 
 
7 7u83 2164 
#define exp_rtti_arg(P)			(CHECK_TAG((P), 53) + 2)
2165 
#define exp_rtti_except(P)		(CHECK_TAG((P), 53) + 3)
2166 
#define exp_rtti_op(P)			(CHECK_TAG((P), 53) + 4)
2 7u83 2167 
 
7 7u83 2168 
#define MAKE_exp_rtti(type_, arg_, except_, op_, c_class_exp)\
2 7u83 2169 
    {\
7 7u83 2170 
	c_class *x665_ = GEN_c_class(5, TYPEID_exp);\
2171 
	x665_->ag_tag = 53;\
2172 
	COPY_type(x665_ + 1, (type_));\
2173 
	COPY_exp(x665_ + 2, (arg_));\
2174 
	COPY_exp(x665_ + 3, (except_));\
2175 
	COPY_int(x665_ + 4, (op_));\
2176 
	(c_class_exp) = x665_;\
2 7u83 2177 
    }
2178 
 
7 7u83 2179 
#define DECONS_exp_rtti(type_, arg_, except_, op_, c_class_exp)\
2 7u83 2180 
    {\
7 7u83 2181 
	c_class *x666_ = CHECK_TAG((c_class_exp), 53);\
2182 
	(type_) = DEREF_type(x666_ + 1);\
2183 
	(arg_) = DEREF_exp(x666_ + 2);\
2184 
	(except_) = DEREF_exp(x666_ + 3);\
2185 
	(op_) = DEREF_int(x666_ + 4);\
2 7u83 2186 
    }
2187 
 
7 7u83 2188 
#define DESTROY_exp_rtti(destroyer_, type_, arg_, except_, op_, c_class_exp)\
2 7u83 2189 
    {\
7 7u83 2190 
	c_class *x667_ = CHECK_TAG((c_class_exp), 53);\
2191 
	(type_) = DEREF_type(x667_ + 1);\
2192 
	(arg_) = DEREF_exp(x667_ + 2);\
2193 
	(except_) = DEREF_exp(x667_ + 3);\
2194 
	(op_) = DEREF_int(x667_ + 4);\
2195 
	(destroyer_)(x667_, (unsigned)5);\
2 7u83 2196 
    }
2197 
 
2198 
 
2199 
/* Operations for field rtti_type of union EXP */
2200 
 
7 7u83 2201 
#define exp_rtti_type_tag		((unsigned)54)
2202 
#define IS_exp_rtti_type(P)		(CHECK_NULL(P)->ag_tag == 54)
2 7u83 2203 
 
7 7u83 2204 
#define exp_rtti_type_arg(P)		(CHECK_TAG((P), 54) + 2)
2205 
#define exp_rtti_type_op(P)		(CHECK_TAG((P), 54) + 3)
2 7u83 2206 
 
7 7u83 2207 
#define MAKE_exp_rtti_type(type_, arg_, op_, c_class_exp)\
2 7u83 2208 
    {\
7 7u83 2209 
	c_class *x668_ = GEN_c_class(4, TYPEID_exp);\
2210 
	x668_->ag_tag = 54;\
2211 
	COPY_type(x668_ + 1, (type_));\
2212 
	COPY_type(x668_ + 2, (arg_));\
2213 
	COPY_int(x668_ + 3, (op_));\
2214 
	(c_class_exp) = x668_;\
2 7u83 2215 
    }
2216 
 
7 7u83 2217 
#define DECONS_exp_rtti_type(type_, arg_, op_, c_class_exp)\
2 7u83 2218 
    {\
7 7u83 2219 
	c_class *x669_ = CHECK_TAG((c_class_exp), 54);\
2220 
	(type_) = DEREF_type(x669_ + 1);\
2221 
	(arg_) = DEREF_type(x669_ + 2);\
2222 
	(op_) = DEREF_int(x669_ + 3);\
2 7u83 2223 
    }
2224 
 
7 7u83 2225 
#define DESTROY_exp_rtti_type(destroyer_, type_, arg_, op_, c_class_exp)\
2 7u83 2226 
    {\
7 7u83 2227 
	c_class *x670_ = CHECK_TAG((c_class_exp), 54);\
2228 
	(type_) = DEREF_type(x670_ + 1);\
2229 
	(arg_) = DEREF_type(x670_ + 2);\
2230 
	(op_) = DEREF_int(x670_ + 3);\
2231 
	(destroyer_)(x670_, (unsigned)4);\
2 7u83 2232 
    }
2233 
 
2234 
 
2235 
/* Operations for field rtti_no of union EXP */
2236 
 
7 7u83 2237 
#define exp_rtti_no_tag			((unsigned)55)
2238 
#define IS_exp_rtti_no(P)		(CHECK_NULL(P)->ag_tag == 55)
2 7u83 2239 
 
7 7u83 2240 
#define exp_rtti_no_arg(P)		(CHECK_TAG((P), 55) + 2)
2 7u83 2241 
 
7 7u83 2242 
#define MAKE_exp_rtti_no(type_, arg_, c_class_exp)\
2 7u83 2243 
    {\
7 7u83 2244 
	c_class *x671_ = GEN_c_class(3, TYPEID_exp);\
2245 
	x671_->ag_tag = 55;\
2246 
	COPY_type(x671_ + 1, (type_));\
2247 
	COPY_type(x671_ + 2, (arg_));\
2248 
	(c_class_exp) = x671_;\
2 7u83 2249 
    }
2250 
 
7 7u83 2251 
#define DECONS_exp_rtti_no(type_, arg_, c_class_exp)\
2 7u83 2252 
    {\
7 7u83 2253 
	c_class *x672_ = CHECK_TAG((c_class_exp), 55);\
2254 
	(type_) = DEREF_type(x672_ + 1);\
2255 
	(arg_) = DEREF_type(x672_ + 2);\
2 7u83 2256 
    }
2257 
 
7 7u83 2258 
#define DESTROY_exp_rtti_no(destroyer_, type_, arg_, c_class_exp)\
2 7u83 2259 
    {\
7 7u83 2260 
	c_class *x673_ = CHECK_TAG((c_class_exp), 55);\
2261 
	(type_) = DEREF_type(x673_ + 1);\
2262 
	(arg_) = DEREF_type(x673_ + 2);\
2263 
	(destroyer_)(x673_, (unsigned)3);\
2 7u83 2264 
    }
2265 
 
2266 
 
2267 
/* Operations for field dynamic of union EXP */
2268 
 
7 7u83 2269 
#define exp_dynamic_tag			((unsigned)56)
2270 
#define IS_exp_dynamic(P)		(CHECK_NULL(P)->ag_tag == 56)
2 7u83 2271 
 
7 7u83 2272 
#define exp_dynamic_arg(P)		(CHECK_TAG((P), 56) + 2)
2 7u83 2273 
 
7 7u83 2274 
#define MAKE_exp_dynamic(type_, arg_, c_class_exp)\
2 7u83 2275 
    {\
7 7u83 2276 
	c_class *x674_ = GEN_c_class(3, TYPEID_exp);\
2277 
	x674_->ag_tag = 56;\
2278 
	COPY_type(x674_ + 1, (type_));\
2279 
	COPY_exp(x674_ + 2, (arg_));\
2280 
	(c_class_exp) = x674_;\
2 7u83 2281 
    }
2282 
 
7 7u83 2283 
#define DECONS_exp_dynamic(type_, arg_, c_class_exp)\
2 7u83 2284 
    {\
7 7u83 2285 
	c_class *x675_ = CHECK_TAG((c_class_exp), 56);\
2286 
	(type_) = DEREF_type(x675_ + 1);\
2287 
	(arg_) = DEREF_exp(x675_ + 2);\
2 7u83 2288 
    }
2289 
 
7 7u83 2290 
#define DESTROY_exp_dynamic(destroyer_, type_, arg_, c_class_exp)\
2 7u83 2291 
    {\
7 7u83 2292 
	c_class *x676_ = CHECK_TAG((c_class_exp), 56);\
2293 
	(type_) = DEREF_type(x676_ + 1);\
2294 
	(arg_) = DEREF_exp(x676_ + 2);\
2295 
	(destroyer_)(x676_, (unsigned)3);\
2 7u83 2296 
    }
2297 
 
2298 
 
2299 
/* Operations for field aggregate of union EXP */
2300 
 
7 7u83 2301 
#define exp_aggregate_tag		((unsigned)57)
2302 
#define IS_exp_aggregate(P)		(CHECK_NULL(P)->ag_tag == 57)
2 7u83 2303 
 
7 7u83 2304 
#define exp_aggregate_args(P)		(CHECK_TAG((P), 57) + 2)
2305 
#define exp_aggregate_offs(P)		(CHECK_TAG((P), 57) + 3)
2 7u83 2306 
 
7 7u83 2307 
#define MAKE_exp_aggregate(type_, args_, offs_, c_class_exp)\
2 7u83 2308 
    {\
7 7u83 2309 
	c_class *x677_ = GEN_c_class(4, TYPEID_exp);\
2310 
	x677_->ag_tag = 57;\
2311 
	COPY_type(x677_ + 1, (type_));\
2312 
	COPY_list(x677_ + 2, (args_));\
2313 
	COPY_list(x677_ + 3, (offs_));\
2314 
	(c_class_exp) = x677_;\
2 7u83 2315 
    }
2316 
 
7 7u83 2317 
#define DECONS_exp_aggregate(type_, args_, offs_, c_class_exp)\
2 7u83 2318 
    {\
7 7u83 2319 
	c_class *x678_ = CHECK_TAG((c_class_exp), 57);\
2320 
	(type_) = DEREF_type(x678_ + 1);\
2321 
	(args_) = DEREF_list(x678_ + 2);\
2322 
	(offs_) = DEREF_list(x678_ + 3);\
2 7u83 2323 
    }
2324 
 
7 7u83 2325 
#define DESTROY_exp_aggregate(destroyer_, type_, args_, offs_, c_class_exp)\
2 7u83 2326 
    {\
7 7u83 2327 
	c_class *x679_ = CHECK_TAG((c_class_exp), 57);\
2328 
	(type_) = DEREF_type(x679_ + 1);\
2329 
	(args_) = DEREF_list(x679_ + 2);\
2330 
	(offs_) = DEREF_list(x679_ + 3);\
2331 
	(destroyer_)(x679_, (unsigned)4);\
2 7u83 2332 
    }
2333 
 
2334 
 
2335 
/* Operations for field initialiser of union EXP */
2336 
 
7 7u83 2337 
#define exp_initialiser_tag		((unsigned)58)
2338 
#define IS_exp_initialiser(P)		(CHECK_NULL(P)->ag_tag == 58)
2 7u83 2339 
 
7 7u83 2340 
#define exp_initialiser_args(P)		(CHECK_TAG((P), 58) + 2)
2341 
#define exp_initialiser_offs(P)		(CHECK_TAG((P), 58) + 3)
2342 
#define exp_initialiser_kind(P)		(CHECK_TAG((P), 58) + 4)
2343 
#define exp_initialiser_virt(P)		(CHECK_TAG((P), 58) + 5)
2344 
#define exp_initialiser_base(P)		(CHECK_TAG((P), 58) + 6)
2 7u83 2345 
 
7 7u83 2346 
#define MAKE_exp_initialiser(type_, args_, offs_, kind_, virt_, base_, c_class_exp)\
2 7u83 2347 
    {\
7 7u83 2348 
	c_class *x680_ = GEN_c_class(7, TYPEID_exp);\
2349 
	x680_->ag_tag = 58;\
2350 
	COPY_type(x680_ + 1, (type_));\
2351 
	COPY_list(x680_ + 2, (args_));\
2352 
	COPY_list(x680_ + 3, (offs_));\
2353 
	COPY_int(x680_ + 4, (kind_));\
2354 
	COPY_unsigned(x680_ + 5, (virt_));\
2355 
	COPY_unsigned(x680_ + 6, (base_));\
2356 
	(c_class_exp) = x680_;\
2 7u83 2357 
    }
2358 
 
7 7u83 2359 
#define DECONS_exp_initialiser(type_, args_, offs_, kind_, virt_, base_, c_class_exp)\
2 7u83 2360 
    {\
7 7u83 2361 
	c_class *x681_ = CHECK_TAG((c_class_exp), 58);\
2362 
	(type_) = DEREF_type(x681_ + 1);\
2363 
	(args_) = DEREF_list(x681_ + 2);\
2364 
	(offs_) = DEREF_list(x681_ + 3);\
2365 
	(kind_) = DEREF_int(x681_ + 4);\
2366 
	(virt_) = DEREF_unsigned(x681_ + 5);\
2367 
	(base_) = DEREF_unsigned(x681_ + 6);\
2 7u83 2368 
    }
2369 
 
7 7u83 2370 
#define DESTROY_exp_initialiser(destroyer_, type_, args_, offs_, kind_, virt_, base_, c_class_exp)\
2 7u83 2371 
    {\
7 7u83 2372 
	c_class *x682_ = CHECK_TAG((c_class_exp), 58);\
2373 
	(type_) = DEREF_type(x682_ + 1);\
2374 
	(args_) = DEREF_list(x682_ + 2);\
2375 
	(offs_) = DEREF_list(x682_ + 3);\
2376 
	(kind_) = DEREF_int(x682_ + 4);\
2377 
	(virt_) = DEREF_unsigned(x682_ + 5);\
2378 
	(base_) = DEREF_unsigned(x682_ + 6);\
2379 
	(destroyer_)(x682_, (unsigned)7);\
2 7u83 2380 
    }
2381 
 
2382 
 
2383 
/* Operations for field nof of union EXP */
2384 
 
7 7u83 2385 
#define exp_nof_tag			((unsigned)59)
2386 
#define IS_exp_nof(P)			(CHECK_NULL(P)->ag_tag == 59)
2 7u83 2387 
 
7 7u83 2388 
#define exp_nof_start(P)		(CHECK_TAG((P), 59) + 2)
2389 
#define exp_nof_size(P)			(CHECK_TAG((P), 59) + 3)
2390 
#define exp_nof_pad(P)			(CHECK_TAG((P), 59) + 4)
2391 
#define exp_nof_end(P)			(CHECK_TAG((P), 59) + 5)
2 7u83 2392 
 
7 7u83 2393 
#define MAKE_exp_nof(type_, start_, size_, pad_, end_, c_class_exp)\
2 7u83 2394 
    {\
7 7u83 2395 
	c_class *x683_ = GEN_c_class(6, TYPEID_exp);\
2396 
	x683_->ag_tag = 59;\
2397 
	COPY_type(x683_ + 1, (type_));\
2398 
	COPY_exp(x683_ + 2, (start_));\
2399 
	COPY_nat(x683_ + 3, (size_));\
2400 
	COPY_exp(x683_ + 4, (pad_));\
2401 
	COPY_exp(x683_ + 5, (end_));\
2402 
	(c_class_exp) = x683_;\
2 7u83 2403 
    }
2404 
 
7 7u83 2405 
#define DECONS_exp_nof(type_, start_, size_, pad_, end_, c_class_exp)\
2 7u83 2406 
    {\
7 7u83 2407 
	c_class *x684_ = CHECK_TAG((c_class_exp), 59);\
2408 
	(type_) = DEREF_type(x684_ + 1);\
2409 
	(start_) = DEREF_exp(x684_ + 2);\
2410 
	(size_) = DEREF_nat(x684_ + 3);\
2411 
	(pad_) = DEREF_exp(x684_ + 4);\
2412 
	(end_) = DEREF_exp(x684_ + 5);\
2 7u83 2413 
    }
2414 
 
7 7u83 2415 
#define DESTROY_exp_nof(destroyer_, type_, start_, size_, pad_, end_, c_class_exp)\
2 7u83 2416 
    {\
7 7u83 2417 
	c_class *x685_ = CHECK_TAG((c_class_exp), 59);\
2418 
	(type_) = DEREF_type(x685_ + 1);\
2419 
	(start_) = DEREF_exp(x685_ + 2);\
2420 
	(size_) = DEREF_nat(x685_ + 3);\
2421 
	(pad_) = DEREF_exp(x685_ + 4);\
2422 
	(end_) = DEREF_exp(x685_ + 5);\
2423 
	(destroyer_)(x685_, (unsigned)6);\
2 7u83 2424 
    }
2425 
 
2426 
 
2427 
/* Operations for field comma of union EXP */
2428 
 
7 7u83 2429 
#define exp_comma_tag			((unsigned)60)
2430 
#define IS_exp_comma(P)			(CHECK_NULL(P)->ag_tag == 60)
2 7u83 2431 
 
7 7u83 2432 
#define exp_comma_args(P)		(CHECK_TAG((P), 60) + 2)
2 7u83 2433 
 
7 7u83 2434 
#define MAKE_exp_comma(type_, args_, c_class_exp)\
2 7u83 2435 
    {\
7 7u83 2436 
	c_class *x686_ = GEN_c_class(3, TYPEID_exp);\
2437 
	x686_->ag_tag = 60;\
2438 
	COPY_type(x686_ + 1, (type_));\
2439 
	COPY_list(x686_ + 2, (args_));\
2440 
	(c_class_exp) = x686_;\
2 7u83 2441 
    }
2442 
 
7 7u83 2443 
#define DECONS_exp_comma(type_, args_, c_class_exp)\
2 7u83 2444 
    {\
7 7u83 2445 
	c_class *x687_ = CHECK_TAG((c_class_exp), 60);\
2446 
	(type_) = DEREF_type(x687_ + 1);\
2447 
	(args_) = DEREF_list(x687_ + 2);\
2 7u83 2448 
    }
2449 
 
7 7u83 2450 
#define DESTROY_exp_comma(destroyer_, type_, args_, c_class_exp)\
2 7u83 2451 
    {\
7 7u83 2452 
	c_class *x688_ = CHECK_TAG((c_class_exp), 60);\
2453 
	(type_) = DEREF_type(x688_ + 1);\
2454 
	(args_) = DEREF_list(x688_ + 2);\
2455 
	(destroyer_)(x688_, (unsigned)3);\
2 7u83 2456 
    }
2457 
 
2458 
 
2459 
/* Operations for field set set_etc of union EXP */
2460 
 
7 7u83 2461 
#define exp_set_etc_tag			((unsigned)63)
2462 
#define IS_exp_set_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 61) < (unsigned)2)
2 7u83 2463 
 
7 7u83 2464 
#define exp_set_etc_arg(P)		(CHECK_TAG_ETC((P), 61, 63) + 2)
2 7u83 2465 
 
7 7u83 2466 
#define MAKE_exp_set_etc(tag, type_, arg_, c_class_exp)\
2 7u83 2467 
    {\
7 7u83 2468 
	c_class *x689_ = GEN_c_class(3, TYPEID_exp);\
2469 
	x689_->ag_tag = (tag);\
2470 
	COPY_type(x689_ + 1, (type_));\
2471 
	COPY_exp(x689_ + 2, (arg_));\
2472 
	(c_class_exp) = CHECK_TAG_ETC(x689_, 61, 63);\
2 7u83 2473 
    }
2474 
 
7 7u83 2475 
#define MODIFY_exp_set_etc(tag, c_class_exp)\
2 7u83 2476 
    {\
7 7u83 2477 
	c_class *x690_ = CHECK_TAG_ETC ((c_class_exp), 61, 63);\
2478 
	x690_->ag_tag = (tag);\
2479 
	(void) CHECK_TAG_ETC (x690_, 61, 63);\
2 7u83 2480 
    }
2481 
 
7 7u83 2482 
#define DECONS_exp_set_etc(type_, arg_, c_class_exp)\
2 7u83 2483 
    {\
7 7u83 2484 
	c_class *x691_ = CHECK_TAG_ETC((c_class_exp), 61, 63);\
2485 
	(type_) = DEREF_type(x691_ + 1);\
2486 
	(arg_) = DEREF_exp(x691_ + 2);\
2 7u83 2487 
    }
2488 
 
7 7u83 2489 
#define DESTROY_exp_set_etc(destroyer_, type_, arg_, c_class_exp)\
2 7u83 2490 
    {\
7 7u83 2491 
	c_class *x692_ = CHECK_TAG_ETC((c_class_exp), 61, 63);\
2492 
	(type_) = DEREF_type(x692_ + 1);\
2493 
	(arg_) = DEREF_exp(x692_ + 2);\
2494 
	(destroyer_)(x692_, (unsigned)3);\
2 7u83 2495 
    }
2496 
 
2497 
 
2498 
/* Operations for field set of union EXP */
2499 
 
7 7u83 2500 
#define exp_set_tag			((unsigned)61)
2501 
#define IS_exp_set(P)			(CHECK_NULL(P)->ag_tag == 61)
2 7u83 2502 
 
7 7u83 2503 
#define exp_set_arg(P)			(CHECK_TAG((P), 61) + 2)
2 7u83 2504 
 
7 7u83 2505 
#define MAKE_exp_set(type_, arg_, c_class_exp)\
2 7u83 2506 
    {\
7 7u83 2507 
	c_class *x693_ = GEN_c_class(3, TYPEID_exp);\
2508 
	x693_->ag_tag = 61;\
2509 
	COPY_type(x693_ + 1, (type_));\
2510 
	COPY_exp(x693_ + 2, (arg_));\
2511 
	(c_class_exp) = x693_;\
2 7u83 2512 
    }
2513 
 
7 7u83 2514 
#define DECONS_exp_set(type_, arg_, c_class_exp)\
2 7u83 2515 
    {\
7 7u83 2516 
	c_class *x694_ = CHECK_TAG((c_class_exp), 61);\
2517 
	(type_) = DEREF_type(x694_ + 1);\
2518 
	(arg_) = DEREF_exp(x694_ + 2);\
2 7u83 2519 
    }
2520 
 
7 7u83 2521 
#define DESTROY_exp_set(destroyer_, type_, arg_, c_class_exp)\
2 7u83 2522 
    {\
7 7u83 2523 
	c_class *x695_ = CHECK_TAG((c_class_exp), 61);\
2524 
	(type_) = DEREF_type(x695_ + 1);\
2525 
	(arg_) = DEREF_exp(x695_ + 2);\
2526 
	(destroyer_)(x695_, (unsigned)3);\
2 7u83 2527 
    }
2528 
 
2529 
 
2530 
/* Operations for field unused of union EXP */
2531 
 
7 7u83 2532 
#define exp_unused_tag			((unsigned)62)
2533 
#define IS_exp_unused(P)		(CHECK_NULL(P)->ag_tag == 62)
2 7u83 2534 
 
7 7u83 2535 
#define exp_unused_arg(P)		(CHECK_TAG((P), 62) + 2)
2 7u83 2536 
 
7 7u83 2537 
#define MAKE_exp_unused(type_, arg_, c_class_exp)\
2 7u83 2538 
    {\
7 7u83 2539 
	c_class *x696_ = GEN_c_class(3, TYPEID_exp);\
2540 
	x696_->ag_tag = 62;\
2541 
	COPY_type(x696_ + 1, (type_));\
2542 
	COPY_exp(x696_ + 2, (arg_));\
2543 
	(c_class_exp) = x696_;\
2 7u83 2544 
    }
2545 
 
7 7u83 2546 
#define DECONS_exp_unused(type_, arg_, c_class_exp)\
2 7u83 2547 
    {\
7 7u83 2548 
	c_class *x697_ = CHECK_TAG((c_class_exp), 62);\
2549 
	(type_) = DEREF_type(x697_ + 1);\
2550 
	(arg_) = DEREF_exp(x697_ + 2);\
2 7u83 2551 
    }
2552 
 
7 7u83 2553 
#define DESTROY_exp_unused(destroyer_, type_, arg_, c_class_exp)\
2 7u83 2554 
    {\
7 7u83 2555 
	c_class *x698_ = CHECK_TAG((c_class_exp), 62);\
2556 
	(type_) = DEREF_type(x698_ + 1);\
2557 
	(arg_) = DEREF_exp(x698_ + 2);\
2558 
	(destroyer_)(x698_, (unsigned)3);\
2 7u83 2559 
    }
2560 
 
2561 
 
2562 
/* Operations for field set reach_etc of union EXP */
2563 
 
7 7u83 2564 
#define exp_reach_etc_tag		((unsigned)65)
2565 
#define IS_exp_reach_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 63) < (unsigned)2)
2 7u83 2566 
 
7 7u83 2567 
#define exp_reach_etc_parent(P)		(CHECK_TAG_ETC((P), 63, 65) + 2)
2568 
#define exp_reach_etc_body(P)		(CHECK_TAG_ETC((P), 63, 65) + 3)
2 7u83 2569 
 
7 7u83 2570 
#define MAKE_exp_reach_etc(tag, type_, body_, c_class_exp)\
2 7u83 2571 
    {\
7 7u83 2572 
	c_class *x699_ = GEN_c_class(4, TYPEID_exp);\
2573 
	x699_->ag_tag = (tag);\
2574 
	COPY_type(x699_ + 1, (type_));\
2575 
	COPY_exp(x699_ + 2, NULL_exp);\
2576 
	COPY_exp(x699_ + 3, (body_));\
2577 
	(c_class_exp) = CHECK_TAG_ETC(x699_, 63, 65);\
2 7u83 2578 
    }
2579 
 
7 7u83 2580 
#define MODIFY_exp_reach_etc(tag, c_class_exp)\
2 7u83 2581 
    {\
7 7u83 2582 
	c_class *x700_ = CHECK_TAG_ETC ((c_class_exp), 63, 65);\
2583 
	x700_->ag_tag = (tag);\
2584 
	(void) CHECK_TAG_ETC (x700_, 63, 65);\
2 7u83 2585 
    }
2586 
 
7 7u83 2587 
#define DECONS_exp_reach_etc(type_, parent_, body_, c_class_exp)\
2 7u83 2588 
    {\
7 7u83 2589 
	c_class *x701_ = CHECK_TAG_ETC((c_class_exp), 63, 65);\
2590 
	(type_) = DEREF_type(x701_ + 1);\
2591 
	(parent_) = DEREF_exp(x701_ + 2);\
2592 
	(body_) = DEREF_exp(x701_ + 3);\
2 7u83 2593 
    }
2594 
 
7 7u83 2595 
#define DESTROY_exp_reach_etc(destroyer_, type_, parent_, body_, c_class_exp)\
2 7u83 2596 
    {\
7 7u83 2597 
	c_class *x702_ = CHECK_TAG_ETC((c_class_exp), 63, 65);\
2598 
	(type_) = DEREF_type(x702_ + 1);\
2599 
	(parent_) = DEREF_exp(x702_ + 2);\
2600 
	(body_) = DEREF_exp(x702_ + 3);\
2601 
	(destroyer_)(x702_, (unsigned)4);\
2 7u83 2602 
    }
2603 
 
2604 
 
2605 
/* Operations for field reach of union EXP */
2606 
 
7 7u83 2607 
#define exp_reach_tag			((unsigned)63)
2608 
#define IS_exp_reach(P)			(CHECK_NULL(P)->ag_tag == 63)
2 7u83 2609 
 
7 7u83 2610 
#define exp_reach_parent(P)		(CHECK_TAG((P), 63) + 2)
2611 
#define exp_reach_body(P)		(CHECK_TAG((P), 63) + 3)
2 7u83 2612 
 
7 7u83 2613 
#define MAKE_exp_reach(type_, body_, c_class_exp)\
2 7u83 2614 
    {\
7 7u83 2615 
	c_class *x703_ = GEN_c_class(4, TYPEID_exp);\
2616 
	x703_->ag_tag = 63;\
2617 
	COPY_type(x703_ + 1, (type_));\
2618 
	COPY_exp(x703_ + 2, NULL_exp);\
2619 
	COPY_exp(x703_ + 3, (body_));\
2620 
	(c_class_exp) = x703_;\
2 7u83 2621 
    }
2622 
 
7 7u83 2623 
#define DECONS_exp_reach(type_, parent_, body_, c_class_exp)\
2 7u83 2624 
    {\
7 7u83 2625 
	c_class *x704_ = CHECK_TAG((c_class_exp), 63);\
2626 
	(type_) = DEREF_type(x704_ + 1);\
2627 
	(parent_) = DEREF_exp(x704_ + 2);\
2628 
	(body_) = DEREF_exp(x704_ + 3);\
2 7u83 2629 
    }
2630 
 
7 7u83 2631 
#define DESTROY_exp_reach(destroyer_, type_, parent_, body_, c_class_exp)\
2 7u83 2632 
    {\
7 7u83 2633 
	c_class *x705_ = CHECK_TAG((c_class_exp), 63);\
2634 
	(type_) = DEREF_type(x705_ + 1);\
2635 
	(parent_) = DEREF_exp(x705_ + 2);\
2636 
	(body_) = DEREF_exp(x705_ + 3);\
2637 
	(destroyer_)(x705_, (unsigned)4);\
2 7u83 2638 
    }
2639 
 
2640 
 
2641 
/* Operations for field unreach of union EXP */
2642 
 
7 7u83 2643 
#define exp_unreach_tag			((unsigned)64)
2644 
#define IS_exp_unreach(P)		(CHECK_NULL(P)->ag_tag == 64)
2 7u83 2645 
 
7 7u83 2646 
#define exp_unreach_parent(P)		(CHECK_TAG((P), 64) + 2)
2647 
#define exp_unreach_body(P)		(CHECK_TAG((P), 64) + 3)
2 7u83 2648 
 
7 7u83 2649 
#define MAKE_exp_unreach(type_, body_, c_class_exp)\
2 7u83 2650 
    {\
7 7u83 2651 
	c_class *x706_ = GEN_c_class(4, TYPEID_exp);\
2652 
	x706_->ag_tag = 64;\
2653 
	COPY_type(x706_ + 1, (type_));\
2654 
	COPY_exp(x706_ + 2, NULL_exp);\
2655 
	COPY_exp(x706_ + 3, (body_));\
2656 
	(c_class_exp) = x706_;\
2 7u83 2657 
    }
2658 
 
7 7u83 2659 
#define DECONS_exp_unreach(type_, parent_, body_, c_class_exp)\
2 7u83 2660 
    {\
7 7u83 2661 
	c_class *x707_ = CHECK_TAG((c_class_exp), 64);\
2662 
	(type_) = DEREF_type(x707_ + 1);\
2663 
	(parent_) = DEREF_exp(x707_ + 2);\
2664 
	(body_) = DEREF_exp(x707_ + 3);\
2 7u83 2665 
    }
2666 
 
7 7u83 2667 
#define DESTROY_exp_unreach(destroyer_, type_, parent_, body_, c_class_exp)\
2 7u83 2668 
    {\
7 7u83 2669 
	c_class *x708_ = CHECK_TAG((c_class_exp), 64);\
2670 
	(type_) = DEREF_type(x708_ + 1);\
2671 
	(parent_) = DEREF_exp(x708_ + 2);\
2672 
	(body_) = DEREF_exp(x708_ + 3);\
2673 
	(destroyer_)(x708_, (unsigned)4);\
2 7u83 2674 
    }
2675 
 
2676 
 
2677 
/* Operations for field sequence of union EXP */
2678 
 
7 7u83 2679 
#define exp_sequence_tag		((unsigned)65)
2680 
#define IS_exp_sequence(P)		(CHECK_NULL(P)->ag_tag == 65)
2 7u83 2681 
 
7 7u83 2682 
#define exp_sequence_parent(P)		(CHECK_TAG((P), 65) + 2)
2683 
#define exp_sequence_first(P)		(CHECK_TAG((P), 65) + 3)
2684 
#define exp_sequence_last(P)		(CHECK_TAG((P), 65) + 4)
2685 
#define exp_sequence_decl(P)		(CHECK_TAG((P), 65) + 5)
2686 
#define exp_sequence_block(P)		(CHECK_TAG((P), 65) + 6)
2 7u83 2687 
 
7 7u83 2688 
#define MAKE_exp_sequence(type_, first_, last_, decl_, block_, c_class_exp)\
2 7u83 2689 
    {\
7 7u83 2690 
	c_class *x709_ = GEN_c_class(7, TYPEID_exp);\
2691 
	x709_->ag_tag = 65;\
2692 
	COPY_type(x709_ + 1, (type_));\
2693 
	COPY_exp(x709_ + 2, NULL_exp);\
2694 
	COPY_list(x709_ + 3, (first_));\
2695 
	COPY_list(x709_ + 4, (last_));\
2696 
	COPY_nspace(x709_ + 5, (decl_));\
2697 
	COPY_int(x709_ + 6, (block_));\
2698 
	(c_class_exp) = x709_;\
2 7u83 2699 
    }
2700 
 
7 7u83 2701 
#define DECONS_exp_sequence(type_, parent_, first_, last_, decl_, block_, c_class_exp)\
2 7u83 2702 
    {\
7 7u83 2703 
	c_class *x710_ = CHECK_TAG((c_class_exp), 65);\
2704 
	(type_) = DEREF_type(x710_ + 1);\
2705 
	(parent_) = DEREF_exp(x710_ + 2);\
2706 
	(first_) = DEREF_list(x710_ + 3);\
2707 
	(last_) = DEREF_list(x710_ + 4);\
2708 
	(decl_) = DEREF_nspace(x710_ + 5);\
2709 
	(block_) = DEREF_int(x710_ + 6);\
2 7u83 2710 
    }
2711 
 
7 7u83 2712 
#define DESTROY_exp_sequence(destroyer_, type_, parent_, first_, last_, decl_, block_, c_class_exp)\
2 7u83 2713 
    {\
7 7u83 2714 
	c_class *x711_ = CHECK_TAG((c_class_exp), 65);\
2715 
	(type_) = DEREF_type(x711_ + 1);\
2716 
	(parent_) = DEREF_exp(x711_ + 2);\
2717 
	(first_) = DEREF_list(x711_ + 3);\
2718 
	(last_) = DEREF_list(x711_ + 4);\
2719 
	(decl_) = DEREF_nspace(x711_ + 5);\
2720 
	(block_) = DEREF_int(x711_ + 6);\
2721 
	(destroyer_)(x711_, (unsigned)7);\
2 7u83 2722 
    }
2723 
 
2724 
 
2725 
/* Operations for field solve_stmt of union EXP */
2726 
 
7 7u83 2727 
#define exp_solve_stmt_tag		((unsigned)66)
2728 
#define IS_exp_solve_stmt(P)		(CHECK_NULL(P)->ag_tag == 66)
2 7u83 2729 
 
7 7u83 2730 
#define exp_solve_stmt_parent(P)	(CHECK_TAG((P), 66) + 2)
2731 
#define exp_solve_stmt_body(P)		(CHECK_TAG((P), 66) + 3)
2732 
#define exp_solve_stmt_labels(P)	(CHECK_TAG((P), 66) + 4)
2733 
#define exp_solve_stmt_vars(P)		(CHECK_TAG((P), 66) + 5)
2 7u83 2734 
 
7 7u83 2735 
#define MAKE_exp_solve_stmt(type_, body_, c_class_exp)\
2 7u83 2736 
    {\
7 7u83 2737 
	c_class *x712_ = GEN_c_class(6, TYPEID_exp);\
2738 
	x712_->ag_tag = 66;\
2739 
	COPY_type(x712_ + 1, (type_));\
2740 
	COPY_exp(x712_ + 2, NULL_exp);\
2741 
	COPY_exp(x712_ + 3, (body_));\
2742 
	COPY_list(x712_ + 4, NULL_list ( IDENTIFIER ));\
2743 
	COPY_list(x712_ + 5, NULL_list ( IDENTIFIER ));\
2744 
	(c_class_exp) = x712_;\
2 7u83 2745 
    }
2746 
 
7 7u83 2747 
#define DECONS_exp_solve_stmt(type_, parent_, body_, labels_, vars_, c_class_exp)\
2 7u83 2748 
    {\
7 7u83 2749 
	c_class *x713_ = CHECK_TAG((c_class_exp), 66);\
2750 
	(type_) = DEREF_type(x713_ + 1);\
2751 
	(parent_) = DEREF_exp(x713_ + 2);\
2752 
	(body_) = DEREF_exp(x713_ + 3);\
2753 
	(labels_) = DEREF_list(x713_ + 4);\
2754 
	(vars_) = DEREF_list(x713_ + 5);\
2 7u83 2755 
    }
2756 
 
7 7u83 2757 
#define DESTROY_exp_solve_stmt(destroyer_, type_, parent_, body_, labels_, vars_, c_class_exp)\
2 7u83 2758 
    {\
7 7u83 2759 
	c_class *x714_ = CHECK_TAG((c_class_exp), 66);\
2760 
	(type_) = DEREF_type(x714_ + 1);\
2761 
	(parent_) = DEREF_exp(x714_ + 2);\
2762 
	(body_) = DEREF_exp(x714_ + 3);\
2763 
	(labels_) = DEREF_list(x714_ + 4);\
2764 
	(vars_) = DEREF_list(x714_ + 5);\
2765 
	(destroyer_)(x714_, (unsigned)6);\
2 7u83 2766 
    }
2767 
 
2768 
 
2769 
/* Operations for field decl_stmt of union EXP */
2770 
 
7 7u83 2771 
#define exp_decl_stmt_tag		((unsigned)67)
2772 
#define IS_exp_decl_stmt(P)		(CHECK_NULL(P)->ag_tag == 67)
2 7u83 2773 
 
7 7u83 2774 
#define exp_decl_stmt_parent(P)		(CHECK_TAG((P), 67) + 2)
2775 
#define exp_decl_stmt_id(P)		(CHECK_TAG((P), 67) + 3)
2776 
#define exp_decl_stmt_body(P)		(CHECK_TAG((P), 67) + 4)
2 7u83 2777 
 
7 7u83 2778 
#define MAKE_exp_decl_stmt(type_, id_, body_, c_class_exp)\
2 7u83 2779 
    {\
7 7u83 2780 
	c_class *x715_ = GEN_c_class(5, TYPEID_exp);\
2781 
	x715_->ag_tag = 67;\
2782 
	COPY_type(x715_ + 1, (type_));\
2783 
	COPY_exp(x715_ + 2, NULL_exp);\
2784 
	COPY_id(x715_ + 3, (id_));\
2785 
	COPY_exp(x715_ + 4, (body_));\
2786 
	(c_class_exp) = x715_;\
2 7u83 2787 
    }
2788 
 
7 7u83 2789 
#define DECONS_exp_decl_stmt(type_, parent_, id_, body_, c_class_exp)\
2 7u83 2790 
    {\
7 7u83 2791 
	c_class *x716_ = CHECK_TAG((c_class_exp), 67);\
2792 
	(type_) = DEREF_type(x716_ + 1);\
2793 
	(parent_) = DEREF_exp(x716_ + 2);\
2794 
	(id_) = DEREF_id(x716_ + 3);\
2795 
	(body_) = DEREF_exp(x716_ + 4);\
2 7u83 2796 
    }
2797 
 
7 7u83 2798 
#define DESTROY_exp_decl_stmt(destroyer_, type_, parent_, id_, body_, c_class_exp)\
2 7u83 2799 
    {\
7 7u83 2800 
	c_class *x717_ = CHECK_TAG((c_class_exp), 67);\
2801 
	(type_) = DEREF_type(x717_ + 1);\
2802 
	(parent_) = DEREF_exp(x717_ + 2);\
2803 
	(id_) = DEREF_id(x717_ + 3);\
2804 
	(body_) = DEREF_exp(x717_ + 4);\
2805 
	(destroyer_)(x717_, (unsigned)5);\
2 7u83 2806 
    }
2807 
 
2808 
 
2809 
/* Operations for field if_stmt of union EXP */
2810 
 
7 7u83 2811 
#define exp_if_stmt_tag			((unsigned)68)
2812 
#define IS_exp_if_stmt(P)		(CHECK_NULL(P)->ag_tag == 68)
2 7u83 2813 
 
7 7u83 2814 
#define exp_if_stmt_parent(P)		(CHECK_TAG((P), 68) + 2)
2815 
#define exp_if_stmt_cond(P)		(CHECK_TAG((P), 68) + 3)
2816 
#define exp_if_stmt_true_code(P)	(CHECK_TAG((P), 68) + 4)
2817 
#define exp_if_stmt_false_code(P)	(CHECK_TAG((P), 68) + 5)
2818 
#define exp_if_stmt_label(P)		(CHECK_TAG((P), 68) + 6)
2 7u83 2819 
 
7 7u83 2820 
#define MAKE_exp_if_stmt(type_, cond_, true_code_, false_code_, label_, c_class_exp)\
2 7u83 2821 
    {\
7 7u83 2822 
	c_class *x718_ = GEN_c_class(7, TYPEID_exp);\
2823 
	x718_->ag_tag = 68;\
2824 
	COPY_type(x718_ + 1, (type_));\
2825 
	COPY_exp(x718_ + 2, NULL_exp);\
2826 
	COPY_exp(x718_ + 3, (cond_));\
2827 
	COPY_exp(x718_ + 4, (true_code_));\
2828 
	COPY_exp(x718_ + 5, (false_code_));\
2829 
	COPY_id(x718_ + 6, (label_));\
2830 
	(c_class_exp) = x718_;\
2 7u83 2831 
    }
2832 
 
7 7u83 2833 
#define DECONS_exp_if_stmt(type_, parent_, cond_, true_code_, false_code_, label_, c_class_exp)\
2 7u83 2834 
    {\
7 7u83 2835 
	c_class *x719_ = CHECK_TAG((c_class_exp), 68);\
2836 
	(type_) = DEREF_type(x719_ + 1);\
2837 
	(parent_) = DEREF_exp(x719_ + 2);\
2838 
	(cond_) = DEREF_exp(x719_ + 3);\
2839 
	(true_code_) = DEREF_exp(x719_ + 4);\
2840 
	(false_code_) = DEREF_exp(x719_ + 5);\
2841 
	(label_) = DEREF_id(x719_ + 6);\
2 7u83 2842 
    }
2843 
 
7 7u83 2844 
#define DESTROY_exp_if_stmt(destroyer_, type_, parent_, cond_, true_code_, false_code_, label_, c_class_exp)\
2 7u83 2845 
    {\
7 7u83 2846 
	c_class *x720_ = CHECK_TAG((c_class_exp), 68);\
2847 
	(type_) = DEREF_type(x720_ + 1);\
2848 
	(parent_) = DEREF_exp(x720_ + 2);\
2849 
	(cond_) = DEREF_exp(x720_ + 3);\
2850 
	(true_code_) = DEREF_exp(x720_ + 4);\
2851 
	(false_code_) = DEREF_exp(x720_ + 5);\
2852 
	(label_) = DEREF_id(x720_ + 6);\
2853 
	(destroyer_)(x720_, (unsigned)7);\
2 7u83 2854 
    }
2855 
 
2856 
 
2857 
/* Operations for field while_stmt of union EXP */
2858 
 
7 7u83 2859 
#define exp_while_stmt_tag		((unsigned)69)
2860 
#define IS_exp_while_stmt(P)		(CHECK_NULL(P)->ag_tag == 69)
2 7u83 2861 
 
7 7u83 2862 
#define exp_while_stmt_parent(P)	(CHECK_TAG((P), 69) + 2)
2863 
#define exp_while_stmt_cond(P)		(CHECK_TAG((P), 69) + 3)
2864 
#define exp_while_stmt_body(P)		(CHECK_TAG((P), 69) + 4)
2865 
#define exp_while_stmt_break_lab(P)	(CHECK_TAG((P), 69) + 5)
2866 
#define exp_while_stmt_cont_lab(P)	(CHECK_TAG((P), 69) + 6)
2867 
#define exp_while_stmt_loop_lab(P)	(CHECK_TAG((P), 69) + 7)
2868 
#define exp_while_stmt_cond_id(P)	(CHECK_TAG((P), 69) + 8)
2 7u83 2869 
 
7 7u83 2870 
#define MAKE_exp_while_stmt(type_, cond_, break_lab_, cont_lab_, loop_lab_, c_class_exp)\
2 7u83 2871 
    {\
7 7u83 2872 
	c_class *x721_ = GEN_c_class(9, TYPEID_exp);\
2873 
	x721_->ag_tag = 69;\
2874 
	COPY_type(x721_ + 1, (type_));\
2875 
	COPY_exp(x721_ + 2, NULL_exp);\
2876 
	COPY_exp(x721_ + 3, (cond_));\
2877 
	COPY_exp(x721_ + 4, NULL_exp);\
2878 
	COPY_id(x721_ + 5, (break_lab_));\
2879 
	COPY_id(x721_ + 6, (cont_lab_));\
2880 
	COPY_id(x721_ + 7, (loop_lab_));\
2881 
	COPY_list(x721_ + 8, NULL_list ( IDENTIFIER ));\
2882 
	(c_class_exp) = x721_;\
2 7u83 2883 
    }
2884 
 
7 7u83 2885 
#define DECONS_exp_while_stmt(type_, parent_, cond_, body_, break_lab_, cont_lab_, loop_lab_, cond_id_, c_class_exp)\
2 7u83 2886 
    {\
7 7u83 2887 
	c_class *x722_ = CHECK_TAG((c_class_exp), 69);\
2888 
	(type_) = DEREF_type(x722_ + 1);\
2889 
	(parent_) = DEREF_exp(x722_ + 2);\
2890 
	(cond_) = DEREF_exp(x722_ + 3);\
2891 
	(body_) = DEREF_exp(x722_ + 4);\
2892 
	(break_lab_) = DEREF_id(x722_ + 5);\
2893 
	(cont_lab_) = DEREF_id(x722_ + 6);\
2894 
	(loop_lab_) = DEREF_id(x722_ + 7);\
2895 
	(cond_id_) = DEREF_list(x722_ + 8);\
2 7u83 2896 
    }
2897 
 
7 7u83 2898 
#define DESTROY_exp_while_stmt(destroyer_, type_, parent_, cond_, body_, break_lab_, cont_lab_, loop_lab_, cond_id_, c_class_exp)\
2 7u83 2899 
    {\
7 7u83 2900 
	c_class *x723_ = CHECK_TAG((c_class_exp), 69);\
2901 
	(type_) = DEREF_type(x723_ + 1);\
2902 
	(parent_) = DEREF_exp(x723_ + 2);\
2903 
	(cond_) = DEREF_exp(x723_ + 3);\
2904 
	(body_) = DEREF_exp(x723_ + 4);\
2905 
	(break_lab_) = DEREF_id(x723_ + 5);\
2906 
	(cont_lab_) = DEREF_id(x723_ + 6);\
2907 
	(loop_lab_) = DEREF_id(x723_ + 7);\
2908 
	(cond_id_) = DEREF_list(x723_ + 8);\
2909 
	(destroyer_)(x723_, (unsigned)9);\
2 7u83 2910 
    }
2911 
 
2912 
 
2913 
/* Operations for field do_stmt of union EXP */
2914 
 
7 7u83 2915 
#define exp_do_stmt_tag			((unsigned)70)
2916 
#define IS_exp_do_stmt(P)		(CHECK_NULL(P)->ag_tag == 70)
2 7u83 2917 
 
7 7u83 2918 
#define exp_do_stmt_parent(P)		(CHECK_TAG((P), 70) + 2)
2919 
#define exp_do_stmt_cond(P)		(CHECK_TAG((P), 70) + 3)
2920 
#define exp_do_stmt_body(P)		(CHECK_TAG((P), 70) + 4)
2921 
#define exp_do_stmt_break_lab(P)	(CHECK_TAG((P), 70) + 5)
2922 
#define exp_do_stmt_cont_lab(P)		(CHECK_TAG((P), 70) + 6)
2923 
#define exp_do_stmt_loop_lab(P)		(CHECK_TAG((P), 70) + 7)
2 7u83 2924 
 
7 7u83 2925 
#define MAKE_exp_do_stmt(type_, cond_, break_lab_, cont_lab_, loop_lab_, c_class_exp)\
2 7u83 2926 
    {\
7 7u83 2927 
	c_class *x724_ = GEN_c_class(8, TYPEID_exp);\
2928 
	x724_->ag_tag = 70;\
2929 
	COPY_type(x724_ + 1, (type_));\
2930 
	COPY_exp(x724_ + 2, NULL_exp);\
2931 
	COPY_exp(x724_ + 3, (cond_));\
2932 
	COPY_exp(x724_ + 4, NULL_exp);\
2933 
	COPY_id(x724_ + 5, (break_lab_));\
2934 
	COPY_id(x724_ + 6, (cont_lab_));\
2935 
	COPY_id(x724_ + 7, (loop_lab_));\
2936 
	(c_class_exp) = x724_;\
2 7u83 2937 
    }
2938 
 
7 7u83 2939 
#define DECONS_exp_do_stmt(type_, parent_, cond_, body_, break_lab_, cont_lab_, loop_lab_, c_class_exp)\
2 7u83 2940 
    {\
7 7u83 2941 
	c_class *x725_ = CHECK_TAG((c_class_exp), 70);\
2942 
	(type_) = DEREF_type(x725_ + 1);\
2943 
	(parent_) = DEREF_exp(x725_ + 2);\
2944 
	(cond_) = DEREF_exp(x725_ + 3);\
2945 
	(body_) = DEREF_exp(x725_ + 4);\
2946 
	(break_lab_) = DEREF_id(x725_ + 5);\
2947 
	(cont_lab_) = DEREF_id(x725_ + 6);\
2948 
	(loop_lab_) = DEREF_id(x725_ + 7);\
2 7u83 2949 
    }
2950 
 
7 7u83 2951 
#define DESTROY_exp_do_stmt(destroyer_, type_, parent_, cond_, body_, break_lab_, cont_lab_, loop_lab_, c_class_exp)\
2 7u83 2952 
    {\
7 7u83 2953 
	c_class *x726_ = CHECK_TAG((c_class_exp), 70);\
2954 
	(type_) = DEREF_type(x726_ + 1);\
2955 
	(parent_) = DEREF_exp(x726_ + 2);\
2956 
	(cond_) = DEREF_exp(x726_ + 3);\
2957 
	(body_) = DEREF_exp(x726_ + 4);\
2958 
	(break_lab_) = DEREF_id(x726_ + 5);\
2959 
	(cont_lab_) = DEREF_id(x726_ + 6);\
2960 
	(loop_lab_) = DEREF_id(x726_ + 7);\
2961 
	(destroyer_)(x726_, (unsigned)8);\
2 7u83 2962 
    }
2963 
 
2964 
 
2965 
/* Operations for field switch_stmt of union EXP */
2966 
 
7 7u83 2967 
#define exp_switch_stmt_tag		((unsigned)71)
2968 
#define IS_exp_switch_stmt(P)		(CHECK_NULL(P)->ag_tag == 71)
2 7u83 2969 
 
7 7u83 2970 
#define exp_switch_stmt_parent(P)	(CHECK_TAG((P), 71) + 2)
2971 
#define exp_switch_stmt_control(P)	(CHECK_TAG((P), 71) + 3)
2972 
#define exp_switch_stmt_body(P)		(CHECK_TAG((P), 71) + 4)
2973 
#define exp_switch_stmt_cases(P)	(CHECK_TAG((P), 71) + 5)
2974 
#define exp_switch_stmt_case_labs(P)	(CHECK_TAG((P), 71) + 6)
2975 
#define exp_switch_stmt_default_lab(P)	(CHECK_TAG((P), 71) + 7)
2976 
#define exp_switch_stmt_exhaust(P)	(CHECK_TAG((P), 71) + 8)
2977 
#define exp_switch_stmt_break_lab(P)	(CHECK_TAG((P), 71) + 9)
2 7u83 2978 
 
7 7u83 2979 
#define MAKE_exp_switch_stmt(type_, control_, body_, exhaust_, break_lab_, c_class_exp)\
2 7u83 2980 
    {\
7 7u83 2981 
	c_class *x727_ = GEN_c_class(10, TYPEID_exp);\
2982 
	x727_->ag_tag = 71;\
2983 
	COPY_type(x727_ + 1, (type_));\
2984 
	COPY_exp(x727_ + 2, NULL_exp);\
2985 
	COPY_exp(x727_ + 3, (control_));\
2986 
	COPY_exp(x727_ + 4, (body_));\
2987 
	COPY_list(x727_ + 5, NULL_list ( NAT ));\
2988 
	COPY_list(x727_ + 6, NULL_list ( IDENTIFIER ));\
2989 
	COPY_id(x727_ + 7, NULL_id);\
2990 
	COPY_int(x727_ + 8, (exhaust_));\
2991 
	COPY_id(x727_ + 9, (break_lab_));\
2992 
	(c_class_exp) = x727_;\
2 7u83 2993 
    }
2994 
 
7 7u83 2995 
#define DECONS_exp_switch_stmt(type_, parent_, control_, body_, cases_, case_labs_, default_lab_, exhaust_, break_lab_, c_class_exp)\
2 7u83 2996 
    {\
7 7u83 2997 
	c_class *x728_ = CHECK_TAG((c_class_exp), 71);\
2998 
	(type_) = DEREF_type(x728_ + 1);\
2999 
	(parent_) = DEREF_exp(x728_ + 2);\
3000 
	(control_) = DEREF_exp(x728_ + 3);\
3001 
	(body_) = DEREF_exp(x728_ + 4);\
3002 
	(cases_) = DEREF_list(x728_ + 5);\
3003 
	(case_labs_) = DEREF_list(x728_ + 6);\
3004 
	(default_lab_) = DEREF_id(x728_ + 7);\
3005 
	(exhaust_) = DEREF_int(x728_ + 8);\
3006 
	(break_lab_) = DEREF_id(x728_ + 9);\
2 7u83 3007 
    }
3008 
 
7 7u83 3009 
#define DESTROY_exp_switch_stmt(destroyer_, type_, parent_, control_, body_, cases_, case_labs_, default_lab_, exhaust_, break_lab_, c_class_exp)\
2 7u83 3010 
    {\
7 7u83 3011 
	c_class *x729_ = CHECK_TAG((c_class_exp), 71);\
3012 
	(type_) = DEREF_type(x729_ + 1);\
3013 
	(parent_) = DEREF_exp(x729_ + 2);\
3014 
	(control_) = DEREF_exp(x729_ + 3);\
3015 
	(body_) = DEREF_exp(x729_ + 4);\
3016 
	(cases_) = DEREF_list(x729_ + 5);\
3017 
	(case_labs_) = DEREF_list(x729_ + 6);\
3018 
	(default_lab_) = DEREF_id(x729_ + 7);\
3019 
	(exhaust_) = DEREF_int(x729_ + 8);\
3020 
	(break_lab_) = DEREF_id(x729_ + 9);\
3021 
	(destroyer_)(x729_, (unsigned)10);\
2 7u83 3022 
    }
3023 
 
3024 
 
3025 
/* Operations for field hash_if of union EXP */
3026 
 
7 7u83 3027 
#define exp_hash_if_tag			((unsigned)72)
3028 
#define IS_exp_hash_if(P)		(CHECK_NULL(P)->ag_tag == 72)
2 7u83 3029 
 
7 7u83 3030 
#define exp_hash_if_parent(P)		(CHECK_TAG((P), 72) + 2)
3031 
#define exp_hash_if_cond(P)		(CHECK_TAG((P), 72) + 3)
3032 
#define exp_hash_if_true_code(P)	(CHECK_TAG((P), 72) + 4)
3033 
#define exp_hash_if_false_code(P)	(CHECK_TAG((P), 72) + 5)
3034 
#define exp_hash_if_last(P)		(CHECK_TAG((P), 72) + 6)
2 7u83 3035 
 
7 7u83 3036 
#define MAKE_exp_hash_if(type_, cond_, true_code_, false_code_, c_class_exp)\
2 7u83 3037 
    {\
7 7u83 3038 
	c_class *x730_ = GEN_c_class(7, TYPEID_exp);\
3039 
	x730_->ag_tag = 72;\
3040 
	COPY_type(x730_ + 1, (type_));\
3041 
	COPY_exp(x730_ + 2, NULL_exp);\
3042 
	COPY_exp(x730_ + 3, (cond_));\
3043 
	COPY_exp(x730_ + 4, (true_code_));\
3044 
	COPY_exp(x730_ + 5, (false_code_));\
3045 
	COPY_exp(x730_ + 6, NULL_exp);\
3046 
	(c_class_exp) = x730_;\
2 7u83 3047 
    }
3048 
 
7 7u83 3049 
#define DECONS_exp_hash_if(type_, parent_, cond_, true_code_, false_code_, last_, c_class_exp)\
2 7u83 3050 
    {\
7 7u83 3051 
	c_class *x731_ = CHECK_TAG((c_class_exp), 72);\
3052 
	(type_) = DEREF_type(x731_ + 1);\
3053 
	(parent_) = DEREF_exp(x731_ + 2);\
3054 
	(cond_) = DEREF_exp(x731_ + 3);\
3055 
	(true_code_) = DEREF_exp(x731_ + 4);\
3056 
	(false_code_) = DEREF_exp(x731_ + 5);\
3057 
	(last_) = DEREF_exp(x731_ + 6);\
2 7u83 3058 
    }
3059 
 
7 7u83 3060 
#define DESTROY_exp_hash_if(destroyer_, type_, parent_, cond_, true_code_, false_code_, last_, c_class_exp)\
2 7u83 3061 
    {\
7 7u83 3062 
	c_class *x732_ = CHECK_TAG((c_class_exp), 72);\
3063 
	(type_) = DEREF_type(x732_ + 1);\
3064 
	(parent_) = DEREF_exp(x732_ + 2);\
3065 
	(cond_) = DEREF_exp(x732_ + 3);\
3066 
	(true_code_) = DEREF_exp(x732_ + 4);\
3067 
	(false_code_) = DEREF_exp(x732_ + 5);\
3068 
	(last_) = DEREF_exp(x732_ + 6);\
3069 
	(destroyer_)(x732_, (unsigned)7);\
2 7u83 3070 
    }
3071 
 
3072 
 
3073 
/* Operations for field return_stmt of union EXP */
3074 
 
7 7u83 3075 
#define exp_return_stmt_tag		((unsigned)73)
3076 
#define IS_exp_return_stmt(P)		(CHECK_NULL(P)->ag_tag == 73)
2 7u83 3077 
 
7 7u83 3078 
#define exp_return_stmt_parent(P)	(CHECK_TAG((P), 73) + 2)
3079 
#define exp_return_stmt_value(P)	(CHECK_TAG((P), 73) + 3)
2 7u83 3080 
 
7 7u83 3081 
#define MAKE_exp_return_stmt(type_, value_, c_class_exp)\
2 7u83 3082 
    {\
7 7u83 3083 
	c_class *x733_ = GEN_c_class(4, TYPEID_exp);\
3084 
	x733_->ag_tag = 73;\
3085 
	COPY_type(x733_ + 1, (type_));\
3086 
	COPY_exp(x733_ + 2, NULL_exp);\
3087 
	COPY_exp(x733_ + 3, (value_));\
3088 
	(c_class_exp) = x733_;\
2 7u83 3089 
    }
3090 
 
7 7u83 3091 
#define DECONS_exp_return_stmt(type_, parent_, value_, c_class_exp)\
2 7u83 3092 
    {\
7 7u83 3093 
	c_class *x734_ = CHECK_TAG((c_class_exp), 73);\
3094 
	(type_) = DEREF_type(x734_ + 1);\
3095 
	(parent_) = DEREF_exp(x734_ + 2);\
3096 
	(value_) = DEREF_exp(x734_ + 3);\
2 7u83 3097 
    }
3098 
 
7 7u83 3099 
#define DESTROY_exp_return_stmt(destroyer_, type_, parent_, value_, c_class_exp)\
2 7u83 3100 
    {\
7 7u83 3101 
	c_class *x735_ = CHECK_TAG((c_class_exp), 73);\
3102 
	(type_) = DEREF_type(x735_ + 1);\
3103 
	(parent_) = DEREF_exp(x735_ + 2);\
3104 
	(value_) = DEREF_exp(x735_ + 3);\
3105 
	(destroyer_)(x735_, (unsigned)4);\
2 7u83 3106 
    }
3107 
 
3108 
 
3109 
/* Operations for field goto_stmt of union EXP */
3110 
 
7 7u83 3111 
#define exp_goto_stmt_tag		((unsigned)74)
3112 
#define IS_exp_goto_stmt(P)		(CHECK_NULL(P)->ag_tag == 74)
2 7u83 3113 
 
7 7u83 3114 
#define exp_goto_stmt_parent(P)		(CHECK_TAG((P), 74) + 2)
3115 
#define exp_goto_stmt_label(P)		(CHECK_TAG((P), 74) + 3)
3116 
#define exp_goto_stmt_join(P)		(CHECK_TAG((P), 74) + 4)
3117 
#define exp_goto_stmt_next(P)		(CHECK_TAG((P), 74) + 5)
2 7u83 3118 
 
7 7u83 3119 
#define MAKE_exp_goto_stmt(type_, label_, join_, next_, c_class_exp)\
2 7u83 3120 
    {\
7 7u83 3121 
	c_class *x736_ = GEN_c_class(6, TYPEID_exp);\
3122 
	x736_->ag_tag = 74;\
3123 
	COPY_type(x736_ + 1, (type_));\
3124 
	COPY_exp(x736_ + 2, NULL_exp);\
3125 
	COPY_id(x736_ + 3, (label_));\
3126 
	COPY_exp(x736_ + 4, (join_));\
3127 
	COPY_exp(x736_ + 5, (next_));\
3128 
	(c_class_exp) = x736_;\
2 7u83 3129 
    }
3130 
 
7 7u83 3131 
#define DECONS_exp_goto_stmt(type_, parent_, label_, join_, next_, c_class_exp)\
2 7u83 3132 
    {\
7 7u83 3133 
	c_class *x737_ = CHECK_TAG((c_class_exp), 74);\
3134 
	(type_) = DEREF_type(x737_ + 1);\
3135 
	(parent_) = DEREF_exp(x737_ + 2);\
3136 
	(label_) = DEREF_id(x737_ + 3);\
3137 
	(join_) = DEREF_exp(x737_ + 4);\
3138 
	(next_) = DEREF_exp(x737_ + 5);\
2 7u83 3139 
    }
3140 
 
7 7u83 3141 
#define DESTROY_exp_goto_stmt(destroyer_, type_, parent_, label_, join_, next_, c_class_exp)\
2 7u83 3142 
    {\
7 7u83 3143 
	c_class *x738_ = CHECK_TAG((c_class_exp), 74);\
3144 
	(type_) = DEREF_type(x738_ + 1);\
3145 
	(parent_) = DEREF_exp(x738_ + 2);\
3146 
	(label_) = DEREF_id(x738_ + 3);\
3147 
	(join_) = DEREF_exp(x738_ + 4);\
3148 
	(next_) = DEREF_exp(x738_ + 5);\
3149 
	(destroyer_)(x738_, (unsigned)6);\
2 7u83 3150 
    }
3151 
 
3152 
 
3153 
/* Operations for field label_stmt of union EXP */
3154 
 
7 7u83 3155 
#define exp_label_stmt_tag		((unsigned)75)
3156 
#define IS_exp_label_stmt(P)		(CHECK_NULL(P)->ag_tag == 75)
2 7u83 3157 
 
7 7u83 3158 
#define exp_label_stmt_parent(P)	(CHECK_TAG((P), 75) + 2)
3159 
#define exp_label_stmt_label(P)		(CHECK_TAG((P), 75) + 3)
3160 
#define exp_label_stmt_body(P)		(CHECK_TAG((P), 75) + 4)
3161 
#define exp_label_stmt_next(P)		(CHECK_TAG((P), 75) + 5)
2 7u83 3162 
 
7 7u83 3163 
#define MAKE_exp_label_stmt(type_, label_, body_, c_class_exp)\
2 7u83 3164 
    {\
7 7u83 3165 
	c_class *x739_ = GEN_c_class(6, TYPEID_exp);\
3166 
	x739_->ag_tag = 75;\
3167 
	COPY_type(x739_ + 1, (type_));\
3168 
	COPY_exp(x739_ + 2, NULL_exp);\
3169 
	COPY_id(x739_ + 3, (label_));\
3170 
	COPY_exp(x739_ + 4, (body_));\
3171 
	COPY_id(x739_ + 5, NULL_id);\
3172 
	(c_class_exp) = x739_;\
2 7u83 3173 
    }
3174 
 
7 7u83 3175 
#define DECONS_exp_label_stmt(type_, parent_, label_, body_, next_, c_class_exp)\
2 7u83 3176 
    {\
7 7u83 3177 
	c_class *x740_ = CHECK_TAG((c_class_exp), 75);\
3178 
	(type_) = DEREF_type(x740_ + 1);\
3179 
	(parent_) = DEREF_exp(x740_ + 2);\
3180 
	(label_) = DEREF_id(x740_ + 3);\
3181 
	(body_) = DEREF_exp(x740_ + 4);\
3182 
	(next_) = DEREF_id(x740_ + 5);\
2 7u83 3183 
    }
3184 
 
7 7u83 3185 
#define DESTROY_exp_label_stmt(destroyer_, type_, parent_, label_, body_, next_, c_class_exp)\
2 7u83 3186 
    {\
7 7u83 3187 
	c_class *x741_ = CHECK_TAG((c_class_exp), 75);\
3188 
	(type_) = DEREF_type(x741_ + 1);\
3189 
	(parent_) = DEREF_exp(x741_ + 2);\
3190 
	(label_) = DEREF_id(x741_ + 3);\
3191 
	(body_) = DEREF_exp(x741_ + 4);\
3192 
	(next_) = DEREF_id(x741_ + 5);\
3193 
	(destroyer_)(x741_, (unsigned)6);\
2 7u83 3194 
    }
3195 
 
3196 
 
3197 
/* Operations for field try_block of union EXP */
3198 
 
7 7u83 3199 
#define exp_try_block_tag		((unsigned)76)
3200 
#define IS_exp_try_block(P)		(CHECK_NULL(P)->ag_tag == 76)
2 7u83 3201 
 
7 7u83 3202 
#define exp_try_block_parent(P)		(CHECK_TAG((P), 76) + 2)
3203 
#define exp_try_block_body(P)		(CHECK_TAG((P), 76) + 3)
3204 
#define exp_try_block_func(P)		(CHECK_TAG((P), 76) + 4)
3205 
#define exp_try_block_handlers(P)	(CHECK_TAG((P), 76) + 5)
3206 
#define exp_try_block_htypes(P)		(CHECK_TAG((P), 76) + 6)
3207 
#define exp_try_block_ellipsis(P)	(CHECK_TAG((P), 76) + 7)
3208 
#define exp_try_block_ttypes(P)		(CHECK_TAG((P), 76) + 8)
3209 
#define exp_try_block_tlocs(P)		(CHECK_TAG((P), 76) + 9)
3210 
#define exp_try_block_no(P)		(CHECK_TAG((P), 76) + 10)
2 7u83 3211 
 
7 7u83 3212 
#define MAKE_exp_try_block(type_, body_, func_, c_class_exp)\
2 7u83 3213 
    {\
7 7u83 3214 
	c_class *x742_ = GEN_c_class(11, TYPEID_exp);\
3215 
	x742_->ag_tag = 76;\
3216 
	COPY_type(x742_ + 1, (type_));\
3217 
	COPY_exp(x742_ + 2, NULL_exp);\
3218 
	COPY_exp(x742_ + 3, (body_));\
3219 
	COPY_int(x742_ + 4, (func_));\
3220 
	COPY_list(x742_ + 5, NULL_list ( EXP ));\
3221 
	COPY_list(x742_ + 6, NULL_list ( TYPE ));\
3222 
	COPY_exp(x742_ + 7, NULL_exp);\
3223 
	COPY_list(x742_ + 8, NULL_list ( TYPE ));\
3224 
	COPY_list(x742_ + 9, NULL_list ( LOCATION ));\
3225 
	COPY_ulong(x742_ + 10, LINK_NONE);\
3226 
	(c_class_exp) = x742_;\
2 7u83 3227 
    }
3228 
 
7 7u83 3229 
#define DECONS_exp_try_block(type_, parent_, body_, func_, handlers_, htypes_, ellipsis_, ttypes_, tlocs_, no_, c_class_exp)\
2 7u83 3230 
    {\
7 7u83 3231 
	c_class *x743_ = CHECK_TAG((c_class_exp), 76);\
3232 
	(type_) = DEREF_type(x743_ + 1);\
3233 
	(parent_) = DEREF_exp(x743_ + 2);\
3234 
	(body_) = DEREF_exp(x743_ + 3);\
3235 
	(func_) = DEREF_int(x743_ + 4);\
3236 
	(handlers_) = DEREF_list(x743_ + 5);\
3237 
	(htypes_) = DEREF_list(x743_ + 6);\
3238 
	(ellipsis_) = DEREF_exp(x743_ + 7);\
3239 
	(ttypes_) = DEREF_list(x743_ + 8);\
3240 
	(tlocs_) = DEREF_list(x743_ + 9);\
3241 
	(no_) = DEREF_ulong(x743_ + 10);\
2 7u83 3242 
    }
3243 
 
7 7u83 3244 
#define DESTROY_exp_try_block(destroyer_, type_, parent_, body_, func_, handlers_, htypes_, ellipsis_, ttypes_, tlocs_, no_, c_class_exp)\
2 7u83 3245 
    {\
7 7u83 3246 
	c_class *x744_ = CHECK_TAG((c_class_exp), 76);\
3247 
	(type_) = DEREF_type(x744_ + 1);\
3248 
	(parent_) = DEREF_exp(x744_ + 2);\
3249 
	(body_) = DEREF_exp(x744_ + 3);\
3250 
	(func_) = DEREF_int(x744_ + 4);\
3251 
	(handlers_) = DEREF_list(x744_ + 5);\
3252 
	(htypes_) = DEREF_list(x744_ + 6);\
3253 
	(ellipsis_) = DEREF_exp(x744_ + 7);\
3254 
	(ttypes_) = DEREF_list(x744_ + 8);\
3255 
	(tlocs_) = DEREF_list(x744_ + 9);\
3256 
	(no_) = DEREF_ulong(x744_ + 10);\
3257 
	(destroyer_)(x744_, (unsigned)11);\
2 7u83 3258 
    }
3259 
 
3260 
 
3261 
/* Operations for field handler of union EXP */
3262 
 
7 7u83 3263 
#define exp_handler_tag			((unsigned)77)
3264 
#define IS_exp_handler(P)		(CHECK_NULL(P)->ag_tag == 77)
2 7u83 3265 
 
7 7u83 3266 
#define exp_handler_parent(P)		(CHECK_TAG((P), 77) + 2)
3267 
#define exp_handler_except(P)		(CHECK_TAG((P), 77) + 3)
3268 
#define exp_handler_body(P)		(CHECK_TAG((P), 77) + 4)
3269 
#define exp_handler_diag(P)		(CHECK_TAG((P), 77) + 5)
2 7u83 3270 
 
7 7u83 3271 
#define MAKE_exp_handler(type_, except_, body_, c_class_exp)\
2 7u83 3272 
    {\
7 7u83 3273 
	c_class *x745_ = GEN_c_class(6, TYPEID_exp);\
3274 
	x745_->ag_tag = 77;\
3275 
	COPY_type(x745_ + 1, (type_));\
3276 
	COPY_exp(x745_ + 2, NULL_exp);\
3277 
	COPY_id(x745_ + 3, (except_));\
3278 
	COPY_exp(x745_ + 4, (body_));\
3279 
	COPY_ulong(x745_ + 5, LINK_NONE);\
3280 
	(c_class_exp) = x745_;\
2 7u83 3281 
    }
3282 
 
7 7u83 3283 
#define DECONS_exp_handler(type_, parent_, except_, body_, diag_, c_class_exp)\
2 7u83 3284 
    {\
7 7u83 3285 
	c_class *x746_ = CHECK_TAG((c_class_exp), 77);\
3286 
	(type_) = DEREF_type(x746_ + 1);\
3287 
	(parent_) = DEREF_exp(x746_ + 2);\
3288 
	(except_) = DEREF_id(x746_ + 3);\
3289 
	(body_) = DEREF_exp(x746_ + 4);\
3290 
	(diag_) = DEREF_ulong(x746_ + 5);\
2 7u83 3291 
    }
3292 
 
7 7u83 3293 
#define DESTROY_exp_handler(destroyer_, type_, parent_, except_, body_, diag_, c_class_exp)\
2 7u83 3294 
    {\
7 7u83 3295 
	c_class *x747_ = CHECK_TAG((c_class_exp), 77);\
3296 
	(type_) = DEREF_type(x747_ + 1);\
3297 
	(parent_) = DEREF_exp(x747_ + 2);\
3298 
	(except_) = DEREF_id(x747_ + 3);\
3299 
	(body_) = DEREF_exp(x747_ + 4);\
3300 
	(diag_) = DEREF_ulong(x747_ + 5);\
3301 
	(destroyer_)(x747_, (unsigned)6);\
2 7u83 3302 
    }
3303 
 
3304 
 
3305 
/* Operations for field exception of union EXP */
3306 
 
7 7u83 3307 
#define exp_exception_tag		((unsigned)78)
3308 
#define IS_exp_exception(P)		(CHECK_NULL(P)->ag_tag == 78)
2 7u83 3309 
 
7 7u83 3310 
#define exp_exception_arg(P)		(CHECK_TAG((P), 78) + 2)
3311 
#define exp_exception_size(P)		(CHECK_TAG((P), 78) + 3)
3312 
#define exp_exception_destr(P)		(CHECK_TAG((P), 78) + 4)
3313 
#define exp_exception_expl(P)		(CHECK_TAG((P), 78) + 5)
2 7u83 3314 
 
7 7u83 3315 
#define MAKE_exp_exception(type_, arg_, size_, destr_, expl_, c_class_exp)\
2 7u83 3316 
    {\
7 7u83 3317 
	c_class *x748_ = GEN_c_class(6, TYPEID_exp);\
3318 
	x748_->ag_tag = 78;\
3319 
	COPY_type(x748_ + 1, (type_));\
3320 
	COPY_exp(x748_ + 2, (arg_));\
3321 
	COPY_exp(x748_ + 3, (size_));\
3322 
	COPY_exp(x748_ + 4, (destr_));\
3323 
	COPY_int(x748_ + 5, (expl_));\
3324 
	(c_class_exp) = x748_;\
2 7u83 3325 
    }
3326 
 
7 7u83 3327 
#define DECONS_exp_exception(type_, arg_, size_, destr_, expl_, c_class_exp)\
2 7u83 3328 
    {\
7 7u83 3329 
	c_class *x749_ = CHECK_TAG((c_class_exp), 78);\
3330 
	(type_) = DEREF_type(x749_ + 1);\
3331 
	(arg_) = DEREF_exp(x749_ + 2);\
3332 
	(size_) = DEREF_exp(x749_ + 3);\
3333 
	(destr_) = DEREF_exp(x749_ + 4);\
3334 
	(expl_) = DEREF_int(x749_ + 5);\
2 7u83 3335 
    }
3336 
 
7 7u83 3337 
#define DESTROY_exp_exception(destroyer_, type_, arg_, size_, destr_, expl_, c_class_exp)\
2 7u83 3338 
    {\
7 7u83 3339 
	c_class *x750_ = CHECK_TAG((c_class_exp), 78);\
3340 
	(type_) = DEREF_type(x750_ + 1);\
3341 
	(arg_) = DEREF_exp(x750_ + 2);\
3342 
	(size_) = DEREF_exp(x750_ + 3);\
3343 
	(destr_) = DEREF_exp(x750_ + 4);\
3344 
	(expl_) = DEREF_int(x750_ + 5);\
3345 
	(destroyer_)(x750_, (unsigned)6);\
2 7u83 3346 
    }
3347 
 
3348 
 
3349 
/* Operations for field thrown of union EXP */
3350 
 
7 7u83 3351 
#define exp_thrown_tag			((unsigned)79)
3352 
#define IS_exp_thrown(P)		(CHECK_NULL(P)->ag_tag == 79)
2 7u83 3353 
 
7 7u83 3354 
#define exp_thrown_done(P)		(CHECK_TAG((P), 79) + 2)
2 7u83 3355 
 
7 7u83 3356 
#define MAKE_exp_thrown(type_, done_, c_class_exp)\
2 7u83 3357 
    {\
7 7u83 3358 
	c_class *x751_ = GEN_c_class(3, TYPEID_exp);\
3359 
	x751_->ag_tag = 79;\
3360 
	COPY_type(x751_ + 1, (type_));\
3361 
	COPY_int(x751_ + 2, (done_));\
3362 
	(c_class_exp) = x751_;\
2 7u83 3363 
    }
3364 
 
7 7u83 3365 
#define DECONS_exp_thrown(type_, done_, c_class_exp)\
2 7u83 3366 
    {\
7 7u83 3367 
	c_class *x752_ = CHECK_TAG((c_class_exp), 79);\
3368 
	(type_) = DEREF_type(x752_ + 1);\
3369 
	(done_) = DEREF_int(x752_ + 2);\
2 7u83 3370 
    }
3371 
 
7 7u83 3372 
#define DESTROY_exp_thrown(destroyer_, type_, done_, c_class_exp)\
2 7u83 3373 
    {\
7 7u83 3374 
	c_class *x753_ = CHECK_TAG((c_class_exp), 79);\
3375 
	(type_) = DEREF_type(x753_ + 1);\
3376 
	(done_) = DEREF_int(x753_ + 2);\
3377 
	(destroyer_)(x753_, (unsigned)3);\
2 7u83 3378 
    }
3379 
 
3380 
 
3381 
/* Operations for field op of union EXP */
3382 
 
7 7u83 3383 
#define exp_op_tag			((unsigned)80)
3384 
#define IS_exp_op(P)			(CHECK_NULL(P)->ag_tag == 80)
2 7u83 3385 
 
7 7u83 3386 
#define exp_op_lex(P)			(CHECK_TAG((P), 80) + 2)
3387 
#define exp_op_arg1(P)			(CHECK_TAG((P), 80) + 3)
3388 
#define exp_op_arg2(P)			(CHECK_TAG((P), 80) + 4)
2 7u83 3389 
 
7 7u83 3390 
#define MAKE_exp_op(type_, lex_, arg1_, arg2_, c_class_exp)\
2 7u83 3391 
    {\
7 7u83 3392 
	c_class *x754_ = GEN_c_class(5, TYPEID_exp);\
3393 
	x754_->ag_tag = 80;\
3394 
	COPY_type(x754_ + 1, (type_));\
3395 
	COPY_int(x754_ + 2, (lex_));\
3396 
	COPY_exp(x754_ + 3, (arg1_));\
3397 
	COPY_exp(x754_ + 4, (arg2_));\
3398 
	(c_class_exp) = x754_;\
2 7u83 3399 
    }
3400 
 
7 7u83 3401 
#define DECONS_exp_op(type_, lex_, arg1_, arg2_, c_class_exp)\
2 7u83 3402 
    {\
7 7u83 3403 
	c_class *x755_ = CHECK_TAG((c_class_exp), 80);\
3404 
	(type_) = DEREF_type(x755_ + 1);\
3405 
	(lex_) = DEREF_int(x755_ + 2);\
3406 
	(arg1_) = DEREF_exp(x755_ + 3);\
3407 
	(arg2_) = DEREF_exp(x755_ + 4);\
2 7u83 3408 
    }
3409 
 
7 7u83 3410 
#define DESTROY_exp_op(destroyer_, type_, lex_, arg1_, arg2_, c_class_exp)\
2 7u83 3411 
    {\
7 7u83 3412 
	c_class *x756_ = CHECK_TAG((c_class_exp), 80);\
3413 
	(type_) = DEREF_type(x756_ + 1);\
3414 
	(lex_) = DEREF_int(x756_ + 2);\
3415 
	(arg1_) = DEREF_exp(x756_ + 3);\
3416 
	(arg2_) = DEREF_exp(x756_ + 4);\
3417 
	(destroyer_)(x756_, (unsigned)5);\
2 7u83 3418 
    }
3419 
 
3420 
 
3421 
/* Operations for field opn of union EXP */
3422 
 
7 7u83 3423 
#define exp_opn_tag			((unsigned)81)
3424 
#define IS_exp_opn(P)			(CHECK_NULL(P)->ag_tag == 81)
2 7u83 3425 
 
7 7u83 3426 
#define exp_opn_lex(P)			(CHECK_TAG((P), 81) + 2)
3427 
#define exp_opn_args(P)			(CHECK_TAG((P), 81) + 3)
2 7u83 3428 
 
7 7u83 3429 
#define MAKE_exp_opn(type_, lex_, args_, c_class_exp)\
2 7u83 3430 
    {\
7 7u83 3431 
	c_class *x757_ = GEN_c_class(4, TYPEID_exp);\
3432 
	x757_->ag_tag = 81;\
3433 
	COPY_type(x757_ + 1, (type_));\
3434 
	COPY_int(x757_ + 2, (lex_));\
3435 
	COPY_list(x757_ + 3, (args_));\
3436 
	(c_class_exp) = x757_;\
2 7u83 3437 
    }
3438 
 
7 7u83 3439 
#define DECONS_exp_opn(type_, lex_, args_, c_class_exp)\
2 7u83 3440 
    {\
7 7u83 3441 
	c_class *x758_ = CHECK_TAG((c_class_exp), 81);\
3442 
	(type_) = DEREF_type(x758_ + 1);\
3443 
	(lex_) = DEREF_int(x758_ + 2);\
3444 
	(args_) = DEREF_list(x758_ + 3);\
2 7u83 3445 
    }
3446 
 
7 7u83 3447 
#define DESTROY_exp_opn(destroyer_, type_, lex_, args_, c_class_exp)\
2 7u83 3448 
    {\
7 7u83 3449 
	c_class *x759_ = CHECK_TAG((c_class_exp), 81);\
3450 
	(type_) = DEREF_type(x759_ + 1);\
3451 
	(lex_) = DEREF_int(x759_ + 2);\
3452 
	(args_) = DEREF_list(x759_ + 3);\
3453 
	(destroyer_)(x759_, (unsigned)4);\
2 7u83 3454 
    }
3455 
 
3456 
 
3457 
/* Operations for field assembler of union EXP */
3458 
 
7 7u83 3459 
#define exp_assembler_tag		((unsigned)82)
3460 
#define IS_exp_assembler(P)		(CHECK_NULL(P)->ag_tag == 82)
2 7u83 3461 
 
7 7u83 3462 
#define exp_assembler_op(P)		(CHECK_TAG((P), 82) + 2)
3463 
#define exp_assembler_args(P)		(CHECK_TAG((P), 82) + 3)
2 7u83 3464 
 
7 7u83 3465 
#define MAKE_exp_assembler(type_, op_, args_, c_class_exp)\
2 7u83 3466 
    {\
7 7u83 3467 
	c_class *x760_ = GEN_c_class(4, TYPEID_exp);\
3468 
	x760_->ag_tag = 82;\
3469 
	COPY_type(x760_ + 1, (type_));\
3470 
	COPY_str(x760_ + 2, (op_));\
3471 
	COPY_list(x760_ + 3, (args_));\
3472 
	(c_class_exp) = x760_;\
2 7u83 3473 
    }
3474 
 
7 7u83 3475 
#define DECONS_exp_assembler(type_, op_, args_, c_class_exp)\
2 7u83 3476 
    {\
7 7u83 3477 
	c_class *x761_ = CHECK_TAG((c_class_exp), 82);\
3478 
	(type_) = DEREF_type(x761_ + 1);\
3479 
	(op_) = DEREF_str(x761_ + 2);\
3480 
	(args_) = DEREF_list(x761_ + 3);\
2 7u83 3481 
    }
3482 
 
7 7u83 3483 
#define DESTROY_exp_assembler(destroyer_, type_, op_, args_, c_class_exp)\
2 7u83 3484 
    {\
7 7u83 3485 
	c_class *x762_ = CHECK_TAG((c_class_exp), 82);\
3486 
	(type_) = DEREF_type(x762_ + 1);\
3487 
	(op_) = DEREF_str(x762_ + 2);\
3488 
	(args_) = DEREF_list(x762_ + 3);\
3489 
	(destroyer_)(x762_, (unsigned)4);\
2 7u83 3490 
    }
3491 
 
3492 
 
3493 
/* Operations for field uncompiled of union EXP */
3494 
 
7 7u83 3495 
#define exp_uncompiled_tag		((unsigned)83)
3496 
#define IS_exp_uncompiled(P)		(CHECK_NULL(P)->ag_tag == 83)
2 7u83 3497 
 
7 7u83 3498 
#define exp_uncompiled_start(P)		(CHECK_TAG((P), 83) + 2)
3499 
#define exp_uncompiled_defn(P)		(CHECK_TAG((P), 83) + 5)
2 7u83 3500 
 
7 7u83 3501 
#define MAKE_exp_uncompiled(type_, start_, defn_, c_class_exp)\
2 7u83 3502 
    {\
7 7u83 3503 
	c_class *x763_ = GEN_c_class(6, TYPEID_exp);\
3504 
	x763_->ag_tag = 83;\
3505 
	COPY_type(x763_ + 1, (type_));\
3506 
	COPY_ulong(x763_ + 2, (start_).line);\
3507 
	COPY_ulong(x763_ + 3, (start_).column);\
3508 
	COPY_ptr(x763_ + 4, (start_).posn);\
3509 
	COPY_pptok(x763_ + 5, (defn_));\
3510 
	(c_class_exp) = x763_;\
2 7u83 3511 
    }
3512 
 
7 7u83 3513 
#define DECONS_exp_uncompiled(type_, start_, defn_, c_class_exp)\
2 7u83 3514 
    {\
7 7u83 3515 
	c_class *x764_ = CHECK_TAG((c_class_exp), 83);\
3516 
	(type_) = DEREF_type(x764_ + 1);\
3517 
	(start_).line = DEREF_ulong(x764_ + 2);\
3518 
	(start_).column = DEREF_ulong(x764_ + 3);\
3519 
	(start_).posn = DEREF_ptr(x764_ + 4);\
3520 
	(defn_) = DEREF_pptok(x764_ + 5);\
2 7u83 3521 
    }
3522 
 
7 7u83 3523 
#define DESTROY_exp_uncompiled(destroyer_, type_, start_, defn_, c_class_exp)\
2 7u83 3524 
    {\
7 7u83 3525 
	c_class *x765_ = CHECK_TAG((c_class_exp), 83);\
3526 
	(type_) = DEREF_type(x765_ + 1);\
3527 
	(start_).line = DEREF_ulong(x765_ + 2);\
3528 
	(start_).column = DEREF_ulong(x765_ + 3);\
3529 
	(start_).posn = DEREF_ptr(x765_ + 4);\
3530 
	(defn_) = DEREF_pptok(x765_ + 5);\
3531 
	(destroyer_)(x765_, (unsigned)6);\
2 7u83 3532 
    }
3533 
 
3534 
 
3535 
/* Operations for field location of union EXP */
3536 
 
7 7u83 3537 
#define exp_location_tag		((unsigned)84)
3538 
#define IS_exp_location(P)		(CHECK_NULL(P)->ag_tag == 84)
2 7u83 3539 
 
7 7u83 3540 
#define exp_location_end(P)		(CHECK_TAG((P), 84) + 2)
3541 
#define exp_location_arg(P)		(CHECK_TAG((P), 84) + 5)
2 7u83 3542 
 
7 7u83 3543 
#define MAKE_exp_location(type_, end_, arg_, c_class_exp)\
2 7u83 3544 
    {\
7 7u83 3545 
	c_class *x766_ = GEN_c_class(6, TYPEID_exp);\
3546 
	x766_->ag_tag = 84;\
3547 
	COPY_type(x766_ + 1, (type_));\
3548 
	COPY_ulong(x766_ + 2, (end_).line);\
3549 
	COPY_ulong(x766_ + 3, (end_).column);\
3550 
	COPY_ptr(x766_ + 4, (end_).posn);\
3551 
	COPY_exp(x766_ + 5, (arg_));\
3552 
	(c_class_exp) = x766_;\
2 7u83 3553 
    }
3554 
 
7 7u83 3555 
#define DECONS_exp_location(type_, end_, arg_, c_class_exp)\
2 7u83 3556 
    {\
7 7u83 3557 
	c_class *x767_ = CHECK_TAG((c_class_exp), 84);\
3558 
	(type_) = DEREF_type(x767_ + 1);\
3559 
	(end_).line = DEREF_ulong(x767_ + 2);\
3560 
	(end_).column = DEREF_ulong(x767_ + 3);\
3561 
	(end_).posn = DEREF_ptr(x767_ + 4);\
3562 
	(arg_) = DEREF_exp(x767_ + 5);\
2 7u83 3563 
    }
3564 
 
7 7u83 3565 
#define DESTROY_exp_location(destroyer_, type_, end_, arg_, c_class_exp)\
2 7u83 3566 
    {\
7 7u83 3567 
	c_class *x768_ = CHECK_TAG((c_class_exp), 84);\
3568 
	(type_) = DEREF_type(x768_ + 1);\
3569 
	(end_).line = DEREF_ulong(x768_ + 2);\
3570 
	(end_).column = DEREF_ulong(x768_ + 3);\
3571 
	(end_).posn = DEREF_ptr(x768_ + 4);\
3572 
	(arg_) = DEREF_exp(x768_ + 5);\
3573 
	(destroyer_)(x768_, (unsigned)6);\
2 7u83 3574 
    }
3575 
 
3576 
 
3577 
/* Operations for field fail of union EXP */
3578 
 
7 7u83 3579 
#define exp_fail_tag			((unsigned)85)
3580 
#define IS_exp_fail(P)			(CHECK_NULL(P)->ag_tag == 85)
2 7u83 3581 
 
7 7u83 3582 
#define exp_fail_msg(P)			(CHECK_TAG((P), 85) + 2)
2 7u83 3583 
 
7 7u83 3584 
#define MAKE_exp_fail(type_, msg_, c_class_exp)\
2 7u83 3585 
    {\
7 7u83 3586 
	c_class *x769_ = GEN_c_class(3, TYPEID_exp);\
3587 
	x769_->ag_tag = 85;\
3588 
	COPY_type(x769_ + 1, (type_));\
3589 
	COPY_string(x769_ + 2, (msg_));\
3590 
	(c_class_exp) = x769_;\
2 7u83 3591 
    }
3592 
 
7 7u83 3593 
#define DECONS_exp_fail(type_, msg_, c_class_exp)\
2 7u83 3594 
    {\
7 7u83 3595 
	c_class *x770_ = CHECK_TAG((c_class_exp), 85);\
3596 
	(type_) = DEREF_type(x770_ + 1);\
3597 
	(msg_) = DEREF_string(x770_ + 2);\
2 7u83 3598 
    }
3599 
 
7 7u83 3600 
#define DESTROY_exp_fail(destroyer_, type_, msg_, c_class_exp)\
2 7u83 3601 
    {\
7 7u83 3602 
	c_class *x771_ = CHECK_TAG((c_class_exp), 85);\
3603 
	(type_) = DEREF_type(x771_ + 1);\
3604 
	(msg_) = DEREF_string(x771_ + 2);\
3605 
	(destroyer_)(x771_, (unsigned)3);\
2 7u83 3606 
    }
3607 
 
3608 
 
3609 
/* Operations for field token of union EXP */
3610 
 
7 7u83 3611 
#define exp_token_tag			((unsigned)86)
3612 
#define IS_exp_token(P)			(CHECK_NULL(P)->ag_tag == 86)
2 7u83 3613 
 
7 7u83 3614 
#define exp_token_parent(P)		(CHECK_TAG((P), 86) + 2)
3615 
#define exp_token_tok(P)		(CHECK_TAG((P), 86) + 3)
3616 
#define exp_token_args(P)		(CHECK_TAG((P), 86) + 4)
2 7u83 3617 
 
7 7u83 3618 
#define MAKE_exp_token(type_, tok_, args_, c_class_exp)\
2 7u83 3619 
    {\
7 7u83 3620 
	c_class *x772_ = GEN_c_class(5, TYPEID_exp);\
3621 
	x772_->ag_tag = 86;\
3622 
	COPY_type(x772_ + 1, (type_));\
3623 
	COPY_exp(x772_ + 2, NULL_exp);\
3624 
	COPY_id(x772_ + 3, (tok_));\
3625 
	COPY_list(x772_ + 4, (args_));\
3626 
	(c_class_exp) = x772_;\
2 7u83 3627 
    }
3628 
 
7 7u83 3629 
#define DECONS_exp_token(type_, parent_, tok_, args_, c_class_exp)\
2 7u83 3630 
    {\
7 7u83 3631 
	c_class *x773_ = CHECK_TAG((c_class_exp), 86);\
3632 
	(type_) = DEREF_type(x773_ + 1);\
3633 
	(parent_) = DEREF_exp(x773_ + 2);\
3634 
	(tok_) = DEREF_id(x773_ + 3);\
3635 
	(args_) = DEREF_list(x773_ + 4);\
2 7u83 3636 
    }
3637 
 
7 7u83 3638 
#define DESTROY_exp_token(destroyer_, type_, parent_, tok_, args_, c_class_exp)\
2 7u83 3639 
    {\
7 7u83 3640 
	c_class *x774_ = CHECK_TAG((c_class_exp), 86);\
3641 
	(type_) = DEREF_type(x774_ + 1);\
3642 
	(parent_) = DEREF_exp(x774_ + 2);\
3643 
	(tok_) = DEREF_id(x774_ + 3);\
3644 
	(args_) = DEREF_list(x774_ + 4);\
3645 
	(destroyer_)(x774_, (unsigned)5);\
2 7u83 3646 
    }
3647 
 
3648 
 
3649 
/* Operations for field dummy of union EXP */
3650 
 
7 7u83 3651 
#define exp_dummy_tag			((unsigned)87)
3652 
#define IS_exp_dummy(P)			(CHECK_NULL(P)->ag_tag == 87)
2 7u83 3653 
 
7 7u83 3654 
#define exp_dummy_value(P)		(CHECK_TAG((P), 87) + 2)
3655 
#define exp_dummy_no(P)			(CHECK_TAG((P), 87) + 3)
3656 
#define exp_dummy_off(P)		(CHECK_TAG((P), 87) + 4)
3657 
#define exp_dummy_virt(P)		(CHECK_TAG((P), 87) + 5)
3658 
#define exp_dummy_cont(P)		(CHECK_TAG((P), 87) + 6)
2 7u83 3659 
 
7 7u83 3660 
#define MAKE_exp_dummy(type_, value_, no_, off_, cont_, c_class_exp)\
2 7u83 3661 
    {\
7 7u83 3662 
	c_class *x775_ = GEN_c_class(7, TYPEID_exp);\
3663 
	x775_->ag_tag = 87;\
3664 
	COPY_type(x775_ + 1, (type_));\
3665 
	COPY_exp(x775_ + 2, (value_));\
3666 
	COPY_ulong(x775_ + 3, (no_));\
3667 
	COPY_off(x775_ + 4, (off_));\
3668 
	COPY_int(x775_ + 5, 0);\
3669 
	COPY_int(x775_ + 6, (cont_));\
3670 
	(c_class_exp) = x775_;\
2 7u83 3671 
    }
3672 
 
7 7u83 3673 
#define DECONS_exp_dummy(type_, value_, no_, off_, virt_, cont_, c_class_exp)\
2 7u83 3674 
    {\
7 7u83 3675 
	c_class *x776_ = CHECK_TAG((c_class_exp), 87);\
3676 
	(type_) = DEREF_type(x776_ + 1);\
3677 
	(value_) = DEREF_exp(x776_ + 2);\
3678 
	(no_) = DEREF_ulong(x776_ + 3);\
3679 
	(off_) = DEREF_off(x776_ + 4);\
3680 
	(virt_) = DEREF_int(x776_ + 5);\
3681 
	(cont_) = DEREF_int(x776_ + 6);\
2 7u83 3682 
    }
3683 
 
7 7u83 3684 
#define DESTROY_exp_dummy(destroyer_, type_, value_, no_, off_, virt_, cont_, c_class_exp)\
2 7u83 3685 
    {\
7 7u83 3686 
	c_class *x777_ = CHECK_TAG((c_class_exp), 87);\
3687 
	(type_) = DEREF_type(x777_ + 1);\
3688 
	(value_) = DEREF_exp(x777_ + 2);\
3689 
	(no_) = DEREF_ulong(x777_ + 3);\
3690 
	(off_) = DEREF_off(x777_ + 4);\
3691 
	(virt_) = DEREF_int(x777_ + 5);\
3692 
	(cont_) = DEREF_int(x777_ + 6);\
3693 
	(destroyer_)(x777_, (unsigned)7);\
2 7u83 3694 
    }
3695 
 
3696 
 
3697 
#endif