Subversion Repositories tendra.SVN

Rev

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

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