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 TYPE_OPS_H_INCLUDED
 35 
#ifndef TYPE_OPS_H_INCLUDED
36 
#define TYPE_OPS_H_INCLUDED
 36 
#define TYPE_OPS_H_INCLUDED
37 
 
 37 
 
38 
/* Operations for union TYPE */
 38 
/* Operations for union TYPE */
39 
 
 39 
 
40 
#define TAG_type( P )			( CHECK_NULL ( P )->ag_tag )
 40 
#define TAG_type(P)			(CHECK_NULL(P)->ag_tag)
41 
 
 41 
 
42 
 
 42 
 
43 
/* Operations for component qual of union TYPE */
 43 
/* Operations for component qual of union TYPE */
44 
 
 44 
 
45 
#define type_qual( P )			( CHECK_NULL ( P ) + 1 )
 45 
#define type_qual(P)			(CHECK_NULL(P) + 1)
46 
 
 46 
 
47 
 
 47 
 
48 
/* Operations for component name of union TYPE */
 48 
/* Operations for component name of union TYPE */
49 
 
 49 
 
50 
#define type_name( P )			( CHECK_NULL ( P ) + 2 )
 50 
#define type_name(P)			(CHECK_NULL(P) + 2)
51 
 
 51 
 
52 
 
 52 
 
53 
/* Operations for field pre of union TYPE */
 53 
/* Operations for field pre of union TYPE */
54 
 
 54 
 
55 
#define type_pre_tag			( ( unsigned ) 0 )
 55 
#define type_pre_tag			((unsigned)0)
56 
#define IS_type_pre( P )		( CHECK_NULL ( P )->ag_tag == 0 )
 56 
#define IS_type_pre(P)			(CHECK_NULL(P)->ag_tag == 0)
57 
 
 57 
 
58 
#define type_pre_rep( P )		( CHECK_TAG ( ( P ), 0 ) + 3 )
 58 
#define type_pre_rep(P)			(CHECK_TAG((P), 0) + 3)
59 
#define type_pre_nqual( P )		( CHECK_TAG ( ( P ), 0 ) + 4 )
 59 
#define type_pre_nqual(P)		(CHECK_TAG((P), 0) + 4)
60 
 
 60 
 
61 
#define MAKE_type_pre( qual_, rep_, nqual_, c_class_type )\
 61 
#define MAKE_type_pre(qual_, rep_, nqual_, c_class_type)\
62 
    {\
 62 
    {\
63 
	c_class *x226_ = GEN_c_class ( 5, TYPEID_type ) ;\
 63 
	c_class *x226_ = GEN_c_class(5, TYPEID_type);\
64 
	x226_->ag_tag = 0 ;\
 64 
	x226_->ag_tag = 0;\
65 
	COPY_cv ( x226_ + 1, ( qual_ ) ) ;\
 65 
	COPY_cv(x226_ + 1, (qual_));\
66 
	COPY_id ( x226_ + 2, NULL_id ) ;\
 66 
	COPY_id(x226_ + 2, NULL_id);\
67 
	COPY_btype ( x226_ + 3, ( rep_ ) ) ;\
 67 
	COPY_btype(x226_ + 3, (rep_));\
68 
	COPY_qual ( x226_ + 4, ( nqual_ ) ) ;\
 68 
	COPY_qual(x226_ + 4, (nqual_));\
69 
	( c_class_type ) = x226_ ;\
 69 
	(c_class_type) = x226_;\
70 
    }
 70 
    }
71 
 
 71 
 
72 
#define DECONS_type_pre( qual_, name_, rep_, nqual_, c_class_type )\
 72 
#define DECONS_type_pre(qual_, name_, rep_, nqual_, c_class_type)\
73 
    {\
 73 
    {\
74 
	c_class *x227_ = CHECK_TAG ( ( c_class_type ), 0 ) ;\
 74 
	c_class *x227_ = CHECK_TAG((c_class_type), 0);\
75 
	( qual_ ) = DEREF_cv ( x227_ + 1 ) ;\
 75 
	(qual_) = DEREF_cv(x227_ + 1);\
76 
	( name_ ) = DEREF_id ( x227_ + 2 ) ;\
 76 
	(name_) = DEREF_id(x227_ + 2);\
77 
	( rep_ ) = DEREF_btype ( x227_ + 3 ) ;\
 77 
	(rep_) = DEREF_btype(x227_ + 3);\
78 
	( nqual_ ) = DEREF_qual ( x227_ + 4 ) ;\
 78 
	(nqual_) = DEREF_qual(x227_ + 4);\
79 
    }
 79 
    }
80 
 
 80 
 
81 
#define DESTROY_type_pre( destroyer_, qual_, name_, rep_, nqual_, c_class_type )\
 81 
#define DESTROY_type_pre(destroyer_, qual_, name_, rep_, nqual_, c_class_type)\
82 
    {\
 82 
    {\
83 
	c_class *x228_ = CHECK_TAG ( ( c_class_type ), 0 ) ;\
 83 
	c_class *x228_ = CHECK_TAG((c_class_type), 0);\
84 
	( qual_ ) = DEREF_cv ( x228_ + 1 ) ;\
 84 
	(qual_) = DEREF_cv(x228_ + 1);\
85 
	( name_ ) = DEREF_id ( x228_ + 2 ) ;\
 85 
	(name_) = DEREF_id(x228_ + 2);\
86 
	( rep_ ) = DEREF_btype ( x228_ + 3 ) ;\
 86 
	(rep_) = DEREF_btype(x228_ + 3);\
87 
	( nqual_ ) = DEREF_qual ( x228_ + 4 ) ;\
 87 
	(nqual_) = DEREF_qual(x228_ + 4);\
88 
	( destroyer_ ) ( x228_, ( unsigned ) 5 ) ;\
 88 
	(destroyer_)(x228_, (unsigned)5);\
89 
    }
 89 
    }
90 
 
 90 
 
91 
 
 91 
 
92 
/* Operations for field integer of union TYPE */
 92 
/* Operations for field integer of union TYPE */
93 
 
 93 
 
94 
#define type_integer_tag		( ( unsigned ) 1 )
 94 
#define type_integer_tag		((unsigned)1)
95 
#define IS_type_integer( P )		( CHECK_NULL ( P )->ag_tag == 1 )
 95 
#define IS_type_integer(P)		(CHECK_NULL(P)->ag_tag == 1)
96 
 
 96 
 
97 
#define type_integer_rep( P )		( CHECK_TAG ( ( P ), 1 ) + 3 )
 97 
#define type_integer_rep(P)		(CHECK_TAG((P), 1) + 3)
98 
#define type_integer_sem( P )		( CHECK_TAG ( ( P ), 1 ) + 4 )
 98 
#define type_integer_sem(P)		(CHECK_TAG((P), 1) + 4)
99 
 
 99 
 
100 
#define MAKE_type_integer( qual_, rep_, sem_, c_class_type )\
 100 
#define MAKE_type_integer(qual_, rep_, sem_, c_class_type)\
101 
    {\
 101 
    {\
102 
	c_class *x229_ = GEN_c_class ( 5, TYPEID_type ) ;\
 102 
	c_class *x229_ = GEN_c_class(5, TYPEID_type);\
103 
	x229_->ag_tag = 1 ;\
 103 
	x229_->ag_tag = 1;\
104 
	COPY_cv ( x229_ + 1, ( qual_ ) ) ;\
 104 
	COPY_cv(x229_ + 1, (qual_));\
105 
	COPY_id ( x229_ + 2, NULL_id ) ;\
 105 
	COPY_id(x229_ + 2, NULL_id);\
106 
	COPY_itype ( x229_ + 3, ( rep_ ) ) ;\
 106 
	COPY_itype(x229_ + 3, (rep_));\
107 
	COPY_itype ( x229_ + 4, ( sem_ ) ) ;\
 107 
	COPY_itype(x229_ + 4, (sem_));\
108 
	( c_class_type ) = x229_ ;\
 108 
	(c_class_type) = x229_;\
109 
    }
 109 
    }
110 
 
 110 
 
111 
#define DECONS_type_integer( qual_, name_, rep_, sem_, c_class_type )\
 111 
#define DECONS_type_integer(qual_, name_, rep_, sem_, c_class_type)\
112 
    {\
 112 
    {\
113 
	c_class *x230_ = CHECK_TAG ( ( c_class_type ), 1 ) ;\
 113 
	c_class *x230_ = CHECK_TAG((c_class_type), 1);\
114 
	( qual_ ) = DEREF_cv ( x230_ + 1 ) ;\
 114 
	(qual_) = DEREF_cv(x230_ + 1);\
115 
	( name_ ) = DEREF_id ( x230_ + 2 ) ;\
 115 
	(name_) = DEREF_id(x230_ + 2);\
116 
	( rep_ ) = DEREF_itype ( x230_ + 3 ) ;\
 116 
	(rep_) = DEREF_itype(x230_ + 3);\
117 
	( sem_ ) = DEREF_itype ( x230_ + 4 ) ;\
 117 
	(sem_) = DEREF_itype(x230_ + 4);\
118 
    }
 118 
    }
119 
 
 119 
 
120 
#define DESTROY_type_integer( destroyer_, qual_, name_, rep_, sem_, c_class_type )\
 120 
#define DESTROY_type_integer(destroyer_, qual_, name_, rep_, sem_, c_class_type)\
121 
    {\
 121 
    {\
122 
	c_class *x231_ = CHECK_TAG ( ( c_class_type ), 1 ) ;\
 122 
	c_class *x231_ = CHECK_TAG((c_class_type), 1);\
123 
	( qual_ ) = DEREF_cv ( x231_ + 1 ) ;\
 123 
	(qual_) = DEREF_cv(x231_ + 1);\
124 
	( name_ ) = DEREF_id ( x231_ + 2 ) ;\
 124 
	(name_) = DEREF_id(x231_ + 2);\
125 
	( rep_ ) = DEREF_itype ( x231_ + 3 ) ;\
 125 
	(rep_) = DEREF_itype(x231_ + 3);\
126 
	( sem_ ) = DEREF_itype ( x231_ + 4 ) ;\
 126 
	(sem_) = DEREF_itype(x231_ + 4);\
127 
	( destroyer_ ) ( x231_, ( unsigned ) 5 ) ;\
 127 
	(destroyer_)(x231_, (unsigned)5);\
128 
    }
 128 
    }
129 
 
 129 
 
130 
 
 130 
 
131 
/* Operations for field floating of union TYPE */
 131 
/* Operations for field floating of union TYPE */
132 
 
 132 
 
133 
#define type_floating_tag		( ( unsigned ) 2 )
 133 
#define type_floating_tag		((unsigned)2)
134 
#define IS_type_floating( P )		( CHECK_NULL ( P )->ag_tag == 2 )
 134 
#define IS_type_floating(P)		(CHECK_NULL(P)->ag_tag == 2)
135 
 
 135 
 
136 
#define type_floating_rep( P )		( CHECK_TAG ( ( P ), 2 ) + 3 )
 136 
#define type_floating_rep(P)		(CHECK_TAG((P), 2) + 3)
137 
#define type_floating_sem( P )		( CHECK_TAG ( ( P ), 2 ) + 4 )
 137 
#define type_floating_sem(P)		(CHECK_TAG((P), 2) + 4)
138 
 
 138 
 
139 
#define MAKE_type_floating( qual_, rep_, sem_, c_class_type )\
 139 
#define MAKE_type_floating(qual_, rep_, sem_, c_class_type)\
140 
    {\
 140 
    {\
141 
	c_class *x232_ = GEN_c_class ( 5, TYPEID_type ) ;\
 141 
	c_class *x232_ = GEN_c_class(5, TYPEID_type);\
142 
	x232_->ag_tag = 2 ;\
 142 
	x232_->ag_tag = 2;\
143 
	COPY_cv ( x232_ + 1, ( qual_ ) ) ;\
 143 
	COPY_cv(x232_ + 1, (qual_));\
144 
	COPY_id ( x232_ + 2, NULL_id ) ;\
 144 
	COPY_id(x232_ + 2, NULL_id);\
145 
	COPY_ftype ( x232_ + 3, ( rep_ ) ) ;\
 145 
	COPY_ftype(x232_ + 3, (rep_));\
146 
	COPY_ftype ( x232_ + 4, ( sem_ ) ) ;\
 146 
	COPY_ftype(x232_ + 4, (sem_));\
147 
	( c_class_type ) = x232_ ;\
 147 
	(c_class_type) = x232_;\
148 
    }
 148 
    }
149 
 
 149 
 
150 
#define DECONS_type_floating( qual_, name_, rep_, sem_, c_class_type )\
 150 
#define DECONS_type_floating(qual_, name_, rep_, sem_, c_class_type)\
151 
    {\
 151 
    {\
152 
	c_class *x233_ = CHECK_TAG ( ( c_class_type ), 2 ) ;\
 152 
	c_class *x233_ = CHECK_TAG((c_class_type), 2);\
153 
	( qual_ ) = DEREF_cv ( x233_ + 1 ) ;\
 153 
	(qual_) = DEREF_cv(x233_ + 1);\
154 
	( name_ ) = DEREF_id ( x233_ + 2 ) ;\
 154 
	(name_) = DEREF_id(x233_ + 2);\
155 
	( rep_ ) = DEREF_ftype ( x233_ + 3 ) ;\
 155 
	(rep_) = DEREF_ftype(x233_ + 3);\
156 
	( sem_ ) = DEREF_ftype ( x233_ + 4 ) ;\
 156 
	(sem_) = DEREF_ftype(x233_ + 4);\
157 
    }
 157 
    }
158 
 
 158 
 
159 
#define DESTROY_type_floating( destroyer_, qual_, name_, rep_, sem_, c_class_type )\
 159 
#define DESTROY_type_floating(destroyer_, qual_, name_, rep_, sem_, c_class_type)\
160 
    {\
 160 
    {\
161 
	c_class *x234_ = CHECK_TAG ( ( c_class_type ), 2 ) ;\
 161 
	c_class *x234_ = CHECK_TAG((c_class_type), 2);\
162 
	( qual_ ) = DEREF_cv ( x234_ + 1 ) ;\
 162 
	(qual_) = DEREF_cv(x234_ + 1);\
163 
	( name_ ) = DEREF_id ( x234_ + 2 ) ;\
 163 
	(name_) = DEREF_id(x234_ + 2);\
164 
	( rep_ ) = DEREF_ftype ( x234_ + 3 ) ;\
 164 
	(rep_) = DEREF_ftype(x234_ + 3);\
165 
	( sem_ ) = DEREF_ftype ( x234_ + 4 ) ;\
 165 
	(sem_) = DEREF_ftype(x234_ + 4);\
166 
	( destroyer_ ) ( x234_, ( unsigned ) 5 ) ;\
 166 
	(destroyer_)(x234_, (unsigned)5);\
167 
    }
 167 
    }
168 
 
 168 
 
169 
 
 169 
 
170 
/* Operations for field set top_etc of union TYPE */
 170 
/* Operations for field set top_etc of union TYPE */
171 
 
 171 
 
172 
#define type_top_etc_tag		( ( unsigned ) 5 )
 172 
#define type_top_etc_tag		((unsigned)5)
173 
#define IS_type_top_etc( P )		( ( unsigned ) ( CHECK_NULL ( P )->ag_tag - 3 ) < ( unsigned ) 2 )
 173 
#define IS_type_top_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 3) < (unsigned)2)
174 
 
 174 
 
175 
 
 175 
 
176 
#define MAKE_type_top_etc( tag, qual_, c_class_type )\
 176 
#define MAKE_type_top_etc(tag, qual_, c_class_type)\
177 
    {\
 177 
    {\
178 
	c_class *x235_ = GEN_c_class ( 3, TYPEID_type ) ;\
 178 
	c_class *x235_ = GEN_c_class(3, TYPEID_type);\
179 
	x235_->ag_tag = ( tag ) ;\
 179 
	x235_->ag_tag = (tag);\
180 
	COPY_cv ( x235_ + 1, ( qual_ ) ) ;\
 180 
	COPY_cv(x235_ + 1, (qual_));\
181 
	COPY_id ( x235_ + 2, NULL_id ) ;\
 181 
	COPY_id(x235_ + 2, NULL_id);\
182 
	( c_class_type ) = CHECK_TAG_ETC ( x235_, 3, 5 ) ;\
 182 
	(c_class_type) = CHECK_TAG_ETC(x235_, 3, 5);\
183 
    }
 183 
    }
184 
 
 184 
 
185 
#define MODIFY_type_top_etc( tag, c_class_type )\
 185 
#define MODIFY_type_top_etc(tag, c_class_type)\
186 
    {\
 186 
    {\
187 
	c_class *x236_ = CHECK_TAG_ETC ( ( c_class_type ), 3, 5 ) ;\
 187 
	c_class *x236_ = CHECK_TAG_ETC ((c_class_type), 3, 5);\
188 
	x236_->ag_tag = ( tag ) ;\
 188 
	x236_->ag_tag = (tag);\
189 
	( void ) CHECK_TAG_ETC ( x236_, 3, 5 ) ;\
 189 
	(void) CHECK_TAG_ETC (x236_, 3, 5);\
190 
    }
 190 
    }
191 
 
 191 
 
192 
#define DECONS_type_top_etc( qual_, name_, c_class_type )\
 192 
#define DECONS_type_top_etc(qual_, name_, c_class_type)\
193 
    {\
 193 
    {\
194 
	c_class *x237_ = CHECK_TAG_ETC ( ( c_class_type ), 3, 5 ) ;\
 194 
	c_class *x237_ = CHECK_TAG_ETC((c_class_type), 3, 5);\
195 
	( qual_ ) = DEREF_cv ( x237_ + 1 ) ;\
 195 
	(qual_) = DEREF_cv(x237_ + 1);\
196 
	( name_ ) = DEREF_id ( x237_ + 2 ) ;\
 196 
	(name_) = DEREF_id(x237_ + 2);\
197 
    }
 197 
    }
198 
 
 198 
 
199 
#define DESTROY_type_top_etc( destroyer_, qual_, name_, c_class_type )\
 199 
#define DESTROY_type_top_etc(destroyer_, qual_, name_, c_class_type)\
200 
    {\
 200 
    {\
201 
	c_class *x238_ = CHECK_TAG_ETC ( ( c_class_type ), 3, 5 ) ;\
 201 
	c_class *x238_ = CHECK_TAG_ETC((c_class_type), 3, 5);\
202 
	( qual_ ) = DEREF_cv ( x238_ + 1 ) ;\
 202 
	(qual_) = DEREF_cv(x238_ + 1);\
203 
	( name_ ) = DEREF_id ( x238_ + 2 ) ;\
 203 
	(name_) = DEREF_id(x238_ + 2);\
204 
	( destroyer_ ) ( x238_, ( unsigned ) 3 ) ;\
 204 
	(destroyer_)(x238_, (unsigned)3);\
205 
    }
 205 
    }
206 
 
 206 
 
207 
 
 207 
 
208 
/* Operations for field top of union TYPE */
 208 
/* Operations for field top of union TYPE */
209 
 
 209 
 
210 
#define type_top_tag			( ( unsigned ) 3 )
 210 
#define type_top_tag			((unsigned)3)
211 
#define IS_type_top( P )		( CHECK_NULL ( P )->ag_tag == 3 )
 211 
#define IS_type_top(P)			(CHECK_NULL(P)->ag_tag == 3)
212 
 
 212 
 
213 
 
 213 
 
214 
#define MAKE_type_top( qual_, c_class_type )\
 214 
#define MAKE_type_top(qual_, c_class_type)\
215 
    {\
 215 
    {\
216 
	c_class *x239_ = GEN_c_class ( 3, TYPEID_type ) ;\
 216 
	c_class *x239_ = GEN_c_class(3, TYPEID_type);\
217 
	x239_->ag_tag = 3 ;\
 217 
	x239_->ag_tag = 3;\
218 
	COPY_cv ( x239_ + 1, ( qual_ ) ) ;\
 218 
	COPY_cv(x239_ + 1, (qual_));\
219 
	COPY_id ( x239_ + 2, NULL_id ) ;\
 219 
	COPY_id(x239_ + 2, NULL_id);\
220 
	( c_class_type ) = x239_ ;\
 220 
	(c_class_type) = x239_;\
221 
    }
 221 
    }
222 
 
 222 
 
223 
#define DECONS_type_top( qual_, name_, c_class_type )\
 223 
#define DECONS_type_top(qual_, name_, c_class_type)\
224 
    {\
 224 
    {\
225 
	c_class *x240_ = CHECK_TAG ( ( c_class_type ), 3 ) ;\
 225 
	c_class *x240_ = CHECK_TAG((c_class_type), 3);\
226 
	( qual_ ) = DEREF_cv ( x240_ + 1 ) ;\
 226 
	(qual_) = DEREF_cv(x240_ + 1);\
227 
	( name_ ) = DEREF_id ( x240_ + 2 ) ;\
 227 
	(name_) = DEREF_id(x240_ + 2);\
228 
    }
 228 
    }
229 
 
 229 
 
230 
#define DESTROY_type_top( destroyer_, qual_, name_, c_class_type )\
 230 
#define DESTROY_type_top(destroyer_, qual_, name_, c_class_type)\
231 
    {\
 231 
    {\
232 
	c_class *x241_ = CHECK_TAG ( ( c_class_type ), 3 ) ;\
 232 
	c_class *x241_ = CHECK_TAG((c_class_type), 3);\
233 
	( qual_ ) = DEREF_cv ( x241_ + 1 ) ;\
 233 
	(qual_) = DEREF_cv(x241_ + 1);\
234 
	( name_ ) = DEREF_id ( x241_ + 2 ) ;\
 234 
	(name_) = DEREF_id(x241_ + 2);\
235 
	( destroyer_ ) ( x241_, ( unsigned ) 3 ) ;\
 235 
	(destroyer_)(x241_, (unsigned)3);\
236 
    }
 236 
    }
237 
 
 237 
 
238 
 
 238 
 
239 
/* Operations for field bottom of union TYPE */
 239 
/* Operations for field bottom of union TYPE */
240 
 
 240 
 
241 
#define type_bottom_tag			( ( unsigned ) 4 )
 241 
#define type_bottom_tag			((unsigned)4)
242 
#define IS_type_bottom( P )		( CHECK_NULL ( P )->ag_tag == 4 )
 242 
#define IS_type_bottom(P)		(CHECK_NULL(P)->ag_tag == 4)
243 
 
 243 
 
244 
 
 244 
 
245 
#define MAKE_type_bottom( qual_, c_class_type )\
 245 
#define MAKE_type_bottom(qual_, c_class_type)\
246 
    {\
 246 
    {\
247 
	c_class *x242_ = GEN_c_class ( 3, TYPEID_type ) ;\
 247 
	c_class *x242_ = GEN_c_class(3, TYPEID_type);\
248 
	x242_->ag_tag = 4 ;\
 248 
	x242_->ag_tag = 4;\
249 
	COPY_cv ( x242_ + 1, ( qual_ ) ) ;\
 249 
	COPY_cv(x242_ + 1, (qual_));\
250 
	COPY_id ( x242_ + 2, NULL_id ) ;\
 250 
	COPY_id(x242_ + 2, NULL_id);\
251 
	( c_class_type ) = x242_ ;\
 251 
	(c_class_type) = x242_;\
252 
    }
 252 
    }
253 
 
 253 
 
254 
#define DECONS_type_bottom( qual_, name_, c_class_type )\
 254 
#define DECONS_type_bottom(qual_, name_, c_class_type)\
255 
    {\
 255 
    {\
256 
	c_class *x243_ = CHECK_TAG ( ( c_class_type ), 4 ) ;\
 256 
	c_class *x243_ = CHECK_TAG((c_class_type), 4);\
257 
	( qual_ ) = DEREF_cv ( x243_ + 1 ) ;\
 257 
	(qual_) = DEREF_cv(x243_ + 1);\
258 
	( name_ ) = DEREF_id ( x243_ + 2 ) ;\
 258 
	(name_) = DEREF_id(x243_ + 2);\
259 
    }
 259 
    }
260 
 
 260 
 
261 
#define DESTROY_type_bottom( destroyer_, qual_, name_, c_class_type )\
 261 
#define DESTROY_type_bottom(destroyer_, qual_, name_, c_class_type)\
262 
    {\
 262 
    {\
263 
	c_class *x244_ = CHECK_TAG ( ( c_class_type ), 4 ) ;\
 263 
	c_class *x244_ = CHECK_TAG((c_class_type), 4);\
264 
	( qual_ ) = DEREF_cv ( x244_ + 1 ) ;\
 264 
	(qual_) = DEREF_cv(x244_ + 1);\
265 
	( name_ ) = DEREF_id ( x244_ + 2 ) ;\
 265 
	(name_) = DEREF_id(x244_ + 2);\
266 
	( destroyer_ ) ( x244_, ( unsigned ) 3 ) ;\
 266 
	(destroyer_)(x244_, (unsigned)3);\
267 
    }
 267 
    }
268 
 
 268 
 
269 
 
 269 
 
270 
/* Operations for field set ptr_etc of union TYPE */
 270 
/* Operations for field set ptr_etc of union TYPE */
271 
 
 271 
 
272 
#define type_ptr_etc_tag		( ( unsigned ) 7 )
 272 
#define type_ptr_etc_tag		((unsigned)7)
273 
#define IS_type_ptr_etc( P )		( ( unsigned ) ( CHECK_NULL ( P )->ag_tag - 5 ) < ( unsigned ) 2 )
 273 
#define IS_type_ptr_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 5) < (unsigned)2)
274 
 
 274 
 
275 
#define type_ptr_etc_sub( P )		( CHECK_TAG_ETC ( ( P ), 5, 7 ) + 3 )
 275 
#define type_ptr_etc_sub(P)		(CHECK_TAG_ETC((P), 5, 7) + 3)
276 
 
 276 
 
277 
#define MAKE_type_ptr_etc( tag, qual_, sub_, c_class_type )\
 277 
#define MAKE_type_ptr_etc(tag, qual_, sub_, c_class_type)\
278 
    {\
 278 
    {\
279 
	c_class *x245_ = GEN_c_class ( 4, TYPEID_type ) ;\
 279 
	c_class *x245_ = GEN_c_class(4, TYPEID_type);\
280 
	x245_->ag_tag = ( tag ) ;\
 280 
	x245_->ag_tag = (tag);\
281 
	COPY_cv ( x245_ + 1, ( qual_ ) ) ;\
 281 
	COPY_cv(x245_ + 1, (qual_));\
282 
	COPY_id ( x245_ + 2, NULL_id ) ;\
 282 
	COPY_id(x245_ + 2, NULL_id);\
283 
	COPY_type ( x245_ + 3, ( sub_ ) ) ;\
 283 
	COPY_type(x245_ + 3, (sub_));\
284 
	( c_class_type ) = CHECK_TAG_ETC ( x245_, 5, 7 ) ;\
 284 
	(c_class_type) = CHECK_TAG_ETC(x245_, 5, 7);\
285 
    }
 285 
    }
286 
 
 286 
 
287 
#define MODIFY_type_ptr_etc( tag, c_class_type )\
 287 
#define MODIFY_type_ptr_etc(tag, c_class_type)\
288 
    {\
 288 
    {\
289 
	c_class *x246_ = CHECK_TAG_ETC ( ( c_class_type ), 5, 7 ) ;\
 289 
	c_class *x246_ = CHECK_TAG_ETC ((c_class_type), 5, 7);\
290 
	x246_->ag_tag = ( tag ) ;\
 290 
	x246_->ag_tag = (tag);\
291 
	( void ) CHECK_TAG_ETC ( x246_, 5, 7 ) ;\
 291 
	(void) CHECK_TAG_ETC (x246_, 5, 7);\
292 
    }
 292 
    }
293 
 
 293 
 
294 
#define DECONS_type_ptr_etc( qual_, name_, sub_, c_class_type )\
 294 
#define DECONS_type_ptr_etc(qual_, name_, sub_, c_class_type)\
295 
    {\
 295 
    {\
296 
	c_class *x247_ = CHECK_TAG_ETC ( ( c_class_type ), 5, 7 ) ;\
 296 
	c_class *x247_ = CHECK_TAG_ETC((c_class_type), 5, 7);\
297 
	( qual_ ) = DEREF_cv ( x247_ + 1 ) ;\
 297 
	(qual_) = DEREF_cv(x247_ + 1);\
298 
	( name_ ) = DEREF_id ( x247_ + 2 ) ;\
 298 
	(name_) = DEREF_id(x247_ + 2);\
299 
	( sub_ ) = DEREF_type ( x247_ + 3 ) ;\
 299 
	(sub_) = DEREF_type(x247_ + 3);\
300 
    }
 300 
    }
301 
 
 301 
 
302 
#define DESTROY_type_ptr_etc( destroyer_, qual_, name_, sub_, c_class_type )\
 302 
#define DESTROY_type_ptr_etc(destroyer_, qual_, name_, sub_, c_class_type)\
303 
    {\
 303 
    {\
304 
	c_class *x248_ = CHECK_TAG_ETC ( ( c_class_type ), 5, 7 ) ;\
 304 
	c_class *x248_ = CHECK_TAG_ETC((c_class_type), 5, 7);\
305 
	( qual_ ) = DEREF_cv ( x248_ + 1 ) ;\
 305 
	(qual_) = DEREF_cv(x248_ + 1);\
306 
	( name_ ) = DEREF_id ( x248_ + 2 ) ;\
 306 
	(name_) = DEREF_id(x248_ + 2);\
307 
	( sub_ ) = DEREF_type ( x248_ + 3 ) ;\
 307 
	(sub_) = DEREF_type(x248_ + 3);\
308 
	( destroyer_ ) ( x248_, ( unsigned ) 4 ) ;\
 308 
	(destroyer_)(x248_, (unsigned)4);\
309 
    }
 309 
    }
310 
 
 310 
 
311 
 
 311 
 
312 
/* Operations for field ptr of union TYPE */
 312 
/* Operations for field ptr of union TYPE */
313 
 
 313 
 
314 
#define type_ptr_tag			( ( unsigned ) 5 )
 314 
#define type_ptr_tag			((unsigned)5)
315 
#define IS_type_ptr( P )		( CHECK_NULL ( P )->ag_tag == 5 )
 315 
#define IS_type_ptr(P)			(CHECK_NULL(P)->ag_tag == 5)
316 
 
 316 
 
317 
#define type_ptr_sub( P )		( CHECK_TAG ( ( P ), 5 ) + 3 )
 317 
#define type_ptr_sub(P)			(CHECK_TAG((P), 5) + 3)
318 
 
 318 
 
319 
#define MAKE_type_ptr( qual_, sub_, c_class_type )\
 319 
#define MAKE_type_ptr(qual_, sub_, c_class_type)\
320 
    {\
 320 
    {\
321 
	c_class *x249_ = GEN_c_class ( 4, TYPEID_type ) ;\
 321 
	c_class *x249_ = GEN_c_class(4, TYPEID_type);\
322 
	x249_->ag_tag = 5 ;\
 322 
	x249_->ag_tag = 5;\
323 
	COPY_cv ( x249_ + 1, ( qual_ ) ) ;\
 323 
	COPY_cv(x249_ + 1, (qual_));\
324 
	COPY_id ( x249_ + 2, NULL_id ) ;\
 324 
	COPY_id(x249_ + 2, NULL_id);\
325 
	COPY_type ( x249_ + 3, ( sub_ ) ) ;\
 325 
	COPY_type(x249_ + 3, (sub_));\
326 
	( c_class_type ) = x249_ ;\
 326 
	(c_class_type) = x249_;\
327 
    }
 327 
    }
328 
 
 328 
 
329 
#define DECONS_type_ptr( qual_, name_, sub_, c_class_type )\
 329 
#define DECONS_type_ptr(qual_, name_, sub_, c_class_type)\
330 
    {\
 330 
    {\
331 
	c_class *x250_ = CHECK_TAG ( ( c_class_type ), 5 ) ;\
 331 
	c_class *x250_ = CHECK_TAG((c_class_type), 5);\
332 
	( qual_ ) = DEREF_cv ( x250_ + 1 ) ;\
 332 
	(qual_) = DEREF_cv(x250_ + 1);\
333 
	( name_ ) = DEREF_id ( x250_ + 2 ) ;\
 333 
	(name_) = DEREF_id(x250_ + 2);\
334 
	( sub_ ) = DEREF_type ( x250_ + 3 ) ;\
 334 
	(sub_) = DEREF_type(x250_ + 3);\
335 
    }
 335 
    }
336 
 
 336 
 
337 
#define DESTROY_type_ptr( destroyer_, qual_, name_, sub_, c_class_type )\
 337 
#define DESTROY_type_ptr(destroyer_, qual_, name_, sub_, c_class_type)\
338 
    {\
 338 
    {\
339 
	c_class *x251_ = CHECK_TAG ( ( c_class_type ), 5 ) ;\
 339 
	c_class *x251_ = CHECK_TAG((c_class_type), 5);\
340 
	( qual_ ) = DEREF_cv ( x251_ + 1 ) ;\
 340 
	(qual_) = DEREF_cv(x251_ + 1);\
341 
	( name_ ) = DEREF_id ( x251_ + 2 ) ;\
 341 
	(name_) = DEREF_id(x251_ + 2);\
342 
	( sub_ ) = DEREF_type ( x251_ + 3 ) ;\
 342 
	(sub_) = DEREF_type(x251_ + 3);\
343 
	( destroyer_ ) ( x251_, ( unsigned ) 4 ) ;\
 343 
	(destroyer_)(x251_, (unsigned)4);\
344 
    }
 344 
    }
345 
 
 345 
 
346 
 
 346 
 
347 
/* Operations for field ref of union TYPE */
 347 
/* Operations for field ref of union TYPE */
348 
 
 348 
 
349 
#define type_ref_tag			( ( unsigned ) 6 )
 349 
#define type_ref_tag			((unsigned)6)
350 
#define IS_type_ref( P )		( CHECK_NULL ( P )->ag_tag == 6 )
 350 
#define IS_type_ref(P)			(CHECK_NULL(P)->ag_tag == 6)
351 
 
 351 
 
352 
#define type_ref_sub( P )		( CHECK_TAG ( ( P ), 6 ) + 3 )
 352 
#define type_ref_sub(P)			(CHECK_TAG((P), 6) + 3)
353 
 
 353 
 
354 
#define MAKE_type_ref( qual_, sub_, c_class_type )\
 354 
#define MAKE_type_ref(qual_, sub_, c_class_type)\
355 
    {\
 355 
    {\
356 
	c_class *x252_ = GEN_c_class ( 4, TYPEID_type ) ;\
 356 
	c_class *x252_ = GEN_c_class(4, TYPEID_type);\
357 
	x252_->ag_tag = 6 ;\
 357 
	x252_->ag_tag = 6;\
358 
	COPY_cv ( x252_ + 1, ( qual_ ) ) ;\
 358 
	COPY_cv(x252_ + 1, (qual_));\
359 
	COPY_id ( x252_ + 2, NULL_id ) ;\
 359 
	COPY_id(x252_ + 2, NULL_id);\
360 
	COPY_type ( x252_ + 3, ( sub_ ) ) ;\
 360 
	COPY_type(x252_ + 3, (sub_));\
361 
	( c_class_type ) = x252_ ;\
 361 
	(c_class_type) = x252_;\
362 
    }
 362 
    }
363 
 
 363 
 
364 
#define DECONS_type_ref( qual_, name_, sub_, c_class_type )\
 364 
#define DECONS_type_ref(qual_, name_, sub_, c_class_type)\
365 
    {\
 365 
    {\
366 
	c_class *x253_ = CHECK_TAG ( ( c_class_type ), 6 ) ;\
 366 
	c_class *x253_ = CHECK_TAG((c_class_type), 6);\
367 
	( qual_ ) = DEREF_cv ( x253_ + 1 ) ;\
 367 
	(qual_) = DEREF_cv(x253_ + 1);\
368 
	( name_ ) = DEREF_id ( x253_ + 2 ) ;\
 368 
	(name_) = DEREF_id(x253_ + 2);\
369 
	( sub_ ) = DEREF_type ( x253_ + 3 ) ;\
 369 
	(sub_) = DEREF_type(x253_ + 3);\
370 
    }
 370 
    }
371 
 
 371 
 
372 
#define DESTROY_type_ref( destroyer_, qual_, name_, sub_, c_class_type )\
 372 
#define DESTROY_type_ref(destroyer_, qual_, name_, sub_, c_class_type)\
373 
    {\
 373 
    {\
374 
	c_class *x254_ = CHECK_TAG ( ( c_class_type ), 6 ) ;\
 374 
	c_class *x254_ = CHECK_TAG((c_class_type), 6);\
375 
	( qual_ ) = DEREF_cv ( x254_ + 1 ) ;\
 375 
	(qual_) = DEREF_cv(x254_ + 1);\
376 
	( name_ ) = DEREF_id ( x254_ + 2 ) ;\
 376 
	(name_) = DEREF_id(x254_ + 2);\
377 
	( sub_ ) = DEREF_type ( x254_ + 3 ) ;\
 377 
	(sub_) = DEREF_type(x254_ + 3);\
378 
	( destroyer_ ) ( x254_, ( unsigned ) 4 ) ;\
 378 
	(destroyer_)(x254_, (unsigned)4);\
379 
    }
 379 
    }
380 
 
 380 
 
381 
 
 381 
 
382 
/* Operations for field ptr_mem of union TYPE */
 382 
/* Operations for field ptr_mem of union TYPE */
383 
 
 383 
 
384 
#define type_ptr_mem_tag		( ( unsigned ) 7 )
 384 
#define type_ptr_mem_tag		((unsigned)7)
385 
#define IS_type_ptr_mem( P )		( CHECK_NULL ( P )->ag_tag == 7 )
 385 
#define IS_type_ptr_mem(P)		(CHECK_NULL(P)->ag_tag == 7)
386 
 
 386 
 
387 
#define type_ptr_mem_of( P )		( CHECK_TAG ( ( P ), 7 ) + 3 )
 387 
#define type_ptr_mem_of(P)		(CHECK_TAG((P), 7) + 3)
388 
#define type_ptr_mem_sub( P )		( CHECK_TAG ( ( P ), 7 ) + 4 )
 388 
#define type_ptr_mem_sub(P)		(CHECK_TAG((P), 7) + 4)
389 
 
 389 
 
390 
#define MAKE_type_ptr_mem( qual_, of_, sub_, c_class_type )\
 390 
#define MAKE_type_ptr_mem(qual_, of_, sub_, c_class_type)\
391 
    {\
 391 
    {\
392 
	c_class *x255_ = GEN_c_class ( 5, TYPEID_type ) ;\
 392 
	c_class *x255_ = GEN_c_class(5, TYPEID_type);\
393 
	x255_->ag_tag = 7 ;\
 393 
	x255_->ag_tag = 7;\
394 
	COPY_cv ( x255_ + 1, ( qual_ ) ) ;\
 394 
	COPY_cv(x255_ + 1, (qual_));\
395 
	COPY_id ( x255_ + 2, NULL_id ) ;\
 395 
	COPY_id(x255_ + 2, NULL_id);\
396 
	COPY_ctype ( x255_ + 3, ( of_ ) ) ;\
 396 
	COPY_ctype(x255_ + 3, (of_));\
397 
	COPY_type ( x255_ + 4, ( sub_ ) ) ;\
 397 
	COPY_type(x255_ + 4, (sub_));\
398 
	( c_class_type ) = x255_ ;\
 398 
	(c_class_type) = x255_;\
399 
    }
 399 
    }
400 
 
 400 
 
401 
#define DECONS_type_ptr_mem( qual_, name_, of_, sub_, c_class_type )\
 401 
#define DECONS_type_ptr_mem(qual_, name_, of_, sub_, c_class_type)\
402 
    {\
 402 
    {\
403 
	c_class *x256_ = CHECK_TAG ( ( c_class_type ), 7 ) ;\
 403 
	c_class *x256_ = CHECK_TAG((c_class_type), 7);\
404 
	( qual_ ) = DEREF_cv ( x256_ + 1 ) ;\
 404 
	(qual_) = DEREF_cv(x256_ + 1);\
405 
	( name_ ) = DEREF_id ( x256_ + 2 ) ;\
 405 
	(name_) = DEREF_id(x256_ + 2);\
406 
	( of_ ) = DEREF_ctype ( x256_ + 3 ) ;\
 406 
	(of_) = DEREF_ctype(x256_ + 3);\
407 
	( sub_ ) = DEREF_type ( x256_ + 4 ) ;\
 407 
	(sub_) = DEREF_type(x256_ + 4);\
408 
    }
 408 
    }
409 
 
 409 
 
410 
#define DESTROY_type_ptr_mem( destroyer_, qual_, name_, of_, sub_, c_class_type )\
 410 
#define DESTROY_type_ptr_mem(destroyer_, qual_, name_, of_, sub_, c_class_type)\
411 
    {\
 411 
    {\
412 
	c_class *x257_ = CHECK_TAG ( ( c_class_type ), 7 ) ;\
 412 
	c_class *x257_ = CHECK_TAG((c_class_type), 7);\
413 
	( qual_ ) = DEREF_cv ( x257_ + 1 ) ;\
 413 
	(qual_) = DEREF_cv(x257_ + 1);\
414 
	( name_ ) = DEREF_id ( x257_ + 2 ) ;\
 414 
	(name_) = DEREF_id(x257_ + 2);\
415 
	( of_ ) = DEREF_ctype ( x257_ + 3 ) ;\
 415 
	(of_) = DEREF_ctype(x257_ + 3);\
416 
	( sub_ ) = DEREF_type ( x257_ + 4 ) ;\
 416 
	(sub_) = DEREF_type(x257_ + 4);\
417 
	( destroyer_ ) ( x257_, ( unsigned ) 5 ) ;\
 417 
	(destroyer_)(x257_, (unsigned)5);\
418 
    }
 418 
    }
419 
 
 419 
 
420 
 
 420 
 
421 
/* Operations for field func of union TYPE */
 421 
/* Operations for field func of union TYPE */
422 
 
 422 
 
423 
#define type_func_tag			( ( unsigned ) 8 )
 423 
#define type_func_tag			((unsigned)8)
424 
#define IS_type_func( P )		( CHECK_NULL ( P )->ag_tag == 8 )
 424 
#define IS_type_func(P)			(CHECK_NULL(P)->ag_tag == 8)
425 
 
 425 
 
426 
#define type_func_ret( P )		( CHECK_TAG ( ( P ), 8 ) + 3 )
 426 
#define type_func_ret(P)		(CHECK_TAG((P), 8) + 3)
427 
#define type_func_ptypes( P )		( CHECK_TAG ( ( P ), 8 ) + 4 )
 427 
#define type_func_ptypes(P)		(CHECK_TAG((P), 8) + 4)
428 
#define type_func_ellipsis( P )		( CHECK_TAG ( ( P ), 8 ) + 5 )
 428 
#define type_func_ellipsis(P)		(CHECK_TAG((P), 8) + 5)
429 
#define type_func_mqual( P )		( CHECK_TAG ( ( P ), 8 ) + 6 )
 429 
#define type_func_mqual(P)		(CHECK_TAG((P), 8) + 6)
430 
#define type_func_mtypes( P )		( CHECK_TAG ( ( P ), 8 ) + 7 )
 430 
#define type_func_mtypes(P)		(CHECK_TAG((P), 8) + 7)
431 
#define type_func_pars( P )		( CHECK_TAG ( ( P ), 8 ) + 8 )
 431 
#define type_func_pars(P)		(CHECK_TAG((P), 8) + 8)
432 
#define type_func_pids( P )		( CHECK_TAG ( ( P ), 8 ) + 9 )
 432 
#define type_func_pids(P)		(CHECK_TAG((P), 8) + 9)
433 
#define type_func_except( P )		( CHECK_TAG ( ( P ), 8 ) + 10 )
 433 
#define type_func_except(P)		(CHECK_TAG((P), 8) + 10)
434 
 
 434 
 
435 
#define MAKE_type_func( qual_, ret_, ptypes_, ellipsis_, mqual_, mtypes_, pars_, pids_, except_, c_class_type )\
 435 
#define MAKE_type_func(qual_, ret_, ptypes_, ellipsis_, mqual_, mtypes_, pars_, pids_, except_, c_class_type)\
436 
    {\
 436 
    {\
437 
	c_class *x258_ = GEN_c_class ( 11, TYPEID_type ) ;\
 437 
	c_class *x258_ = GEN_c_class(11, TYPEID_type);\
438 
	x258_->ag_tag = 8 ;\
 438 
	x258_->ag_tag = 8;\
439 
	COPY_cv ( x258_ + 1, ( qual_ ) ) ;\
 439 
	COPY_cv(x258_ + 1, (qual_));\
440 
	COPY_id ( x258_ + 2, NULL_id ) ;\
 440 
	COPY_id(x258_ + 2, NULL_id);\
441 
	COPY_type ( x258_ + 3, ( ret_ ) ) ;\
 441 
	COPY_type(x258_ + 3, (ret_));\
442 
	COPY_list ( x258_ + 4, ( ptypes_ ) ) ;\
 442 
	COPY_list(x258_ + 4, (ptypes_));\
443 
	COPY_int ( x258_ + 5, ( ellipsis_ ) ) ;\
 443 
	COPY_int(x258_ + 5, (ellipsis_));\
444 
	COPY_cv ( x258_ + 6, ( mqual_ ) ) ;\
 444 
	COPY_cv(x258_ + 6, (mqual_));\
445 
	COPY_list ( x258_ + 7, ( mtypes_ ) ) ;\
 445 
	COPY_list(x258_ + 7, (mtypes_));\
446 
	COPY_nspace ( x258_ + 8, ( pars_ ) ) ;\
 446 
	COPY_nspace(x258_ + 8, (pars_));\
447 
	COPY_list ( x258_ + 9, ( pids_ ) ) ;\
 447 
	COPY_list(x258_ + 9, (pids_));\
448 
	COPY_list ( x258_ + 10, ( except_ ) ) ;\
 448 
	COPY_list(x258_ + 10, (except_));\
449 
	( c_class_type ) = x258_ ;\
 449 
	(c_class_type) = x258_;\
450 
    }
 450 
    }
451 
 
 451 
 
452 
#define DECONS_type_func( qual_, name_, ret_, ptypes_, ellipsis_, mqual_, mtypes_, pars_, pids_, except_, c_class_type )\
 452 
#define DECONS_type_func(qual_, name_, ret_, ptypes_, ellipsis_, mqual_, mtypes_, pars_, pids_, except_, c_class_type)\
453 
    {\
 453 
    {\
454 
	c_class *x259_ = CHECK_TAG ( ( c_class_type ), 8 ) ;\
 454 
	c_class *x259_ = CHECK_TAG((c_class_type), 8);\
455 
	( qual_ ) = DEREF_cv ( x259_ + 1 ) ;\
 455 
	(qual_) = DEREF_cv(x259_ + 1);\
456 
	( name_ ) = DEREF_id ( x259_ + 2 ) ;\
 456 
	(name_) = DEREF_id(x259_ + 2);\
457 
	( ret_ ) = DEREF_type ( x259_ + 3 ) ;\
 457 
	(ret_) = DEREF_type(x259_ + 3);\
458 
	( ptypes_ ) = DEREF_list ( x259_ + 4 ) ;\
 458 
	(ptypes_) = DEREF_list(x259_ + 4);\
459 
	( ellipsis_ ) = DEREF_int ( x259_ + 5 ) ;\
 459 
	(ellipsis_) = DEREF_int(x259_ + 5);\
460 
	( mqual_ ) = DEREF_cv ( x259_ + 6 ) ;\
 460 
	(mqual_) = DEREF_cv(x259_ + 6);\
461 
	( mtypes_ ) = DEREF_list ( x259_ + 7 ) ;\
 461 
	(mtypes_) = DEREF_list(x259_ + 7);\
462 
	( pars_ ) = DEREF_nspace ( x259_ + 8 ) ;\
 462 
	(pars_) = DEREF_nspace(x259_ + 8);\
463 
	( pids_ ) = DEREF_list ( x259_ + 9 ) ;\
 463 
	(pids_) = DEREF_list(x259_ + 9);\
464 
	( except_ ) = DEREF_list ( x259_ + 10 ) ;\
 464 
	(except_) = DEREF_list(x259_ + 10);\
465 
    }
 465 
    }
466 
 
 466 
 
467 
#define DESTROY_type_func( destroyer_, qual_, name_, ret_, ptypes_, ellipsis_, mqual_, mtypes_, pars_, pids_, except_, c_class_type )\
 467 
#define DESTROY_type_func(destroyer_, qual_, name_, ret_, ptypes_, ellipsis_, mqual_, mtypes_, pars_, pids_, except_, c_class_type)\
468 
    {\
 468 
    {\
469 
	c_class *x260_ = CHECK_TAG ( ( c_class_type ), 8 ) ;\
 469 
	c_class *x260_ = CHECK_TAG((c_class_type), 8);\
470 
	( qual_ ) = DEREF_cv ( x260_ + 1 ) ;\
 470 
	(qual_) = DEREF_cv(x260_ + 1);\
471 
	( name_ ) = DEREF_id ( x260_ + 2 ) ;\
 471 
	(name_) = DEREF_id(x260_ + 2);\
472 
	( ret_ ) = DEREF_type ( x260_ + 3 ) ;\
 472 
	(ret_) = DEREF_type(x260_ + 3);\
473 
	( ptypes_ ) = DEREF_list ( x260_ + 4 ) ;\
 473 
	(ptypes_) = DEREF_list(x260_ + 4);\
474 
	( ellipsis_ ) = DEREF_int ( x260_ + 5 ) ;\
 474 
	(ellipsis_) = DEREF_int(x260_ + 5);\
475 
	( mqual_ ) = DEREF_cv ( x260_ + 6 ) ;\
 475 
	(mqual_) = DEREF_cv(x260_ + 6);\
476 
	( mtypes_ ) = DEREF_list ( x260_ + 7 ) ;\
 476 
	(mtypes_) = DEREF_list(x260_ + 7);\
477 
	( pars_ ) = DEREF_nspace ( x260_ + 8 ) ;\
 477 
	(pars_) = DEREF_nspace(x260_ + 8);\
478 
	( pids_ ) = DEREF_list ( x260_ + 9 ) ;\
 478 
	(pids_) = DEREF_list(x260_ + 9);\
479 
	( except_ ) = DEREF_list ( x260_ + 10 ) ;\
 479 
	(except_) = DEREF_list(x260_ + 10);\
480 
	( destroyer_ ) ( x260_, ( unsigned ) 11 ) ;\
 480 
	(destroyer_)(x260_, (unsigned)11);\
481 
    }
 481 
    }
482 
 
 482 
 
483 
 
 483 
 
484 
/* Operations for field array of union TYPE */
 484 
/* Operations for field array of union TYPE */
485 
 
 485 
 
486 
#define type_array_tag			( ( unsigned ) 9 )
 486 
#define type_array_tag			((unsigned)9)
487 
#define IS_type_array( P )		( CHECK_NULL ( P )->ag_tag == 9 )
 487 
#define IS_type_array(P)		(CHECK_NULL(P)->ag_tag == 9)
488 
 
 488 
 
489 
#define type_array_sub( P )		( CHECK_TAG ( ( P ), 9 ) + 3 )
 489 
#define type_array_sub(P)		(CHECK_TAG((P), 9) + 3)
490 
#define type_array_size( P )		( CHECK_TAG ( ( P ), 9 ) + 4 )
 490 
#define type_array_size(P)		(CHECK_TAG((P), 9) + 4)
491 
 
 491 
 
492 
#define MAKE_type_array( qual_, sub_, size_, c_class_type )\
 492 
#define MAKE_type_array(qual_, sub_, size_, c_class_type)\
493 
    {\
 493 
    {\
494 
	c_class *x261_ = GEN_c_class ( 5, TYPEID_type ) ;\
 494 
	c_class *x261_ = GEN_c_class(5, TYPEID_type);\
495 
	x261_->ag_tag = 9 ;\
 495 
	x261_->ag_tag = 9;\
496 
	COPY_cv ( x261_ + 1, ( qual_ ) ) ;\
 496 
	COPY_cv(x261_ + 1, (qual_));\
497 
	COPY_id ( x261_ + 2, NULL_id ) ;\
 497 
	COPY_id(x261_ + 2, NULL_id);\
498 
	COPY_type ( x261_ + 3, ( sub_ ) ) ;\
 498 
	COPY_type(x261_ + 3, (sub_));\
499 
	COPY_nat ( x261_ + 4, ( size_ ) ) ;\
 499 
	COPY_nat(x261_ + 4, (size_));\
500 
	( c_class_type ) = x261_ ;\
 500 
	(c_class_type) = x261_;\
501 
    }
 501 
    }
502 
 
 502 
 
503 
#define DECONS_type_array( qual_, name_, sub_, size_, c_class_type )\
 503 
#define DECONS_type_array(qual_, name_, sub_, size_, c_class_type)\
504 
    {\
 504 
    {\
505 
	c_class *x262_ = CHECK_TAG ( ( c_class_type ), 9 ) ;\
 505 
	c_class *x262_ = CHECK_TAG((c_class_type), 9);\
506 
	( qual_ ) = DEREF_cv ( x262_ + 1 ) ;\
 506 
	(qual_) = DEREF_cv(x262_ + 1);\
507 
	( name_ ) = DEREF_id ( x262_ + 2 ) ;\
 507 
	(name_) = DEREF_id(x262_ + 2);\
508 
	( sub_ ) = DEREF_type ( x262_ + 3 ) ;\
 508 
	(sub_) = DEREF_type(x262_ + 3);\
509 
	( size_ ) = DEREF_nat ( x262_ + 4 ) ;\
 509 
	(size_) = DEREF_nat(x262_ + 4);\
510 
    }
 510 
    }
511 
 
 511 
 
512 
#define DESTROY_type_array( destroyer_, qual_, name_, sub_, size_, c_class_type )\
 512 
#define DESTROY_type_array(destroyer_, qual_, name_, sub_, size_, c_class_type)\
513 
    {\
 513 
    {\
514 
	c_class *x263_ = CHECK_TAG ( ( c_class_type ), 9 ) ;\
 514 
	c_class *x263_ = CHECK_TAG((c_class_type), 9);\
515 
	( qual_ ) = DEREF_cv ( x263_ + 1 ) ;\
 515 
	(qual_) = DEREF_cv(x263_ + 1);\
516 
	( name_ ) = DEREF_id ( x263_ + 2 ) ;\
 516 
	(name_) = DEREF_id(x263_ + 2);\
517 
	( sub_ ) = DEREF_type ( x263_ + 3 ) ;\
 517 
	(sub_) = DEREF_type(x263_ + 3);\
518 
	( size_ ) = DEREF_nat ( x263_ + 4 ) ;\
 518 
	(size_) = DEREF_nat(x263_ + 4);\
519 
	( destroyer_ ) ( x263_, ( unsigned ) 5 ) ;\
 519 
	(destroyer_)(x263_, (unsigned)5);\
520 
    }
 520 
    }
521 
 
 521 
 
522 
 
 522 
 
523 
/* Operations for field bitfield of union TYPE */
 523 
/* Operations for field bitfield of union TYPE */
524 
 
 524 
 
525 
#define type_bitfield_tag		( ( unsigned ) 10 )
 525 
#define type_bitfield_tag		((unsigned)10)
526 
#define IS_type_bitfield( P )		( CHECK_NULL ( P )->ag_tag == 10 )
 526 
#define IS_type_bitfield(P)		(CHECK_NULL(P)->ag_tag == 10)
527 
 
 527 
 
528 
#define type_bitfield_defn( P )		( CHECK_TAG ( ( P ), 10 ) + 3 )
 528 
#define type_bitfield_defn(P)		(CHECK_TAG((P), 10) + 3)
529 
 
 529 
 
530 
#define MAKE_type_bitfield( qual_, defn_, c_class_type )\
 530 
#define MAKE_type_bitfield(qual_, defn_, c_class_type)\
531 
    {\
 531 
    {\
532 
	c_class *x264_ = GEN_c_class ( 4, TYPEID_type ) ;\
 532 
	c_class *x264_ = GEN_c_class(4, TYPEID_type);\
533 
	x264_->ag_tag = 10 ;\
 533 
	x264_->ag_tag = 10;\
534 
	COPY_cv ( x264_ + 1, ( qual_ ) ) ;\
 534 
	COPY_cv(x264_ + 1, (qual_));\
535 
	COPY_id ( x264_ + 2, NULL_id ) ;\
 535 
	COPY_id(x264_ + 2, NULL_id);\
536 
	COPY_itype ( x264_ + 3, ( defn_ ) ) ;\
 536 
	COPY_itype(x264_ + 3, (defn_));\
537 
	( c_class_type ) = x264_ ;\
 537 
	(c_class_type) = x264_;\
538 
    }
 538 
    }
539 
 
 539 
 
540 
#define DECONS_type_bitfield( qual_, name_, defn_, c_class_type )\
 540 
#define DECONS_type_bitfield(qual_, name_, defn_, c_class_type)\
541 
    {\
 541 
    {\
542 
	c_class *x265_ = CHECK_TAG ( ( c_class_type ), 10 ) ;\
 542 
	c_class *x265_ = CHECK_TAG((c_class_type), 10);\
543 
	( qual_ ) = DEREF_cv ( x265_ + 1 ) ;\
 543 
	(qual_) = DEREF_cv(x265_ + 1);\
544 
	( name_ ) = DEREF_id ( x265_ + 2 ) ;\
 544 
	(name_) = DEREF_id(x265_ + 2);\
545 
	( defn_ ) = DEREF_itype ( x265_ + 3 ) ;\
 545 
	(defn_) = DEREF_itype(x265_ + 3);\
546 
    }
 546 
    }
547 
 
 547 
 
548 
#define DESTROY_type_bitfield( destroyer_, qual_, name_, defn_, c_class_type )\
 548 
#define DESTROY_type_bitfield(destroyer_, qual_, name_, defn_, c_class_type)\
549 
    {\
 549 
    {\
550 
	c_class *x266_ = CHECK_TAG ( ( c_class_type ), 10 ) ;\
 550 
	c_class *x266_ = CHECK_TAG((c_class_type), 10);\
551 
	( qual_ ) = DEREF_cv ( x266_ + 1 ) ;\
 551 
	(qual_) = DEREF_cv(x266_ + 1);\
552 
	( name_ ) = DEREF_id ( x266_ + 2 ) ;\
 552 
	(name_) = DEREF_id(x266_ + 2);\
553 
	( defn_ ) = DEREF_itype ( x266_ + 3 ) ;\
 553 
	(defn_) = DEREF_itype(x266_ + 3);\
554 
	( destroyer_ ) ( x266_, ( unsigned ) 4 ) ;\
 554 
	(destroyer_)(x266_, (unsigned)4);\
555 
    }
 555 
    }
556 
 
 556 
 
557 
 
 557 
 
558 
/* Operations for field compound of union TYPE */
 558 
/* Operations for field compound of union TYPE */
559 
 
 559 
 
560 
#define type_compound_tag		( ( unsigned ) 11 )
 560 
#define type_compound_tag		((unsigned)11)
561 
#define IS_type_compound( P )		( CHECK_NULL ( P )->ag_tag == 11 )
 561 
#define IS_type_compound(P)		(CHECK_NULL(P)->ag_tag == 11)
562 
 
 562 
 
563 
#define type_compound_defn( P )		( CHECK_TAG ( ( P ), 11 ) + 3 )
 563 
#define type_compound_defn(P)		(CHECK_TAG((P), 11) + 3)
564 
 
 564 
 
565 
#define MAKE_type_compound( qual_, defn_, c_class_type )\
 565 
#define MAKE_type_compound(qual_, defn_, c_class_type)\
566 
    {\
 566 
    {\
567 
	c_class *x267_ = GEN_c_class ( 4, TYPEID_type ) ;\
 567 
	c_class *x267_ = GEN_c_class(4, TYPEID_type);\
568 
	x267_->ag_tag = 11 ;\
 568 
	x267_->ag_tag = 11;\
569 
	COPY_cv ( x267_ + 1, ( qual_ ) ) ;\
 569 
	COPY_cv(x267_ + 1, (qual_));\
570 
	COPY_id ( x267_ + 2, NULL_id ) ;\
 570 
	COPY_id(x267_ + 2, NULL_id);\
571 
	COPY_ctype ( x267_ + 3, ( defn_ ) ) ;\
 571 
	COPY_ctype(x267_ + 3, (defn_));\
572 
	( c_class_type ) = x267_ ;\
 572 
	(c_class_type) = x267_;\
573 
    }
 573 
    }
574 
 
 574 
 
575 
#define DECONS_type_compound( qual_, name_, defn_, c_class_type )\
 575 
#define DECONS_type_compound(qual_, name_, defn_, c_class_type)\
576 
    {\
 576 
    {\
577 
	c_class *x268_ = CHECK_TAG ( ( c_class_type ), 11 ) ;\
 577 
	c_class *x268_ = CHECK_TAG((c_class_type), 11);\
578 
	( qual_ ) = DEREF_cv ( x268_ + 1 ) ;\
 578 
	(qual_) = DEREF_cv(x268_ + 1);\
579 
	( name_ ) = DEREF_id ( x268_ + 2 ) ;\
 579 
	(name_) = DEREF_id(x268_ + 2);\
580 
	( defn_ ) = DEREF_ctype ( x268_ + 3 ) ;\
 580 
	(defn_) = DEREF_ctype(x268_ + 3);\
581 
    }
 581 
    }
582 
 
 582 
 
583 
#define DESTROY_type_compound( destroyer_, qual_, name_, defn_, c_class_type )\
 583 
#define DESTROY_type_compound(destroyer_, qual_, name_, defn_, c_class_type)\
584 
    {\
 584 
    {\
585 
	c_class *x269_ = CHECK_TAG ( ( c_class_type ), 11 ) ;\
 585 
	c_class *x269_ = CHECK_TAG((c_class_type), 11);\
586 
	( qual_ ) = DEREF_cv ( x269_ + 1 ) ;\
 586 
	(qual_) = DEREF_cv(x269_ + 1);\
587 
	( name_ ) = DEREF_id ( x269_ + 2 ) ;\
 587 
	(name_) = DEREF_id(x269_ + 2);\
588 
	( defn_ ) = DEREF_ctype ( x269_ + 3 ) ;\
 588 
	(defn_) = DEREF_ctype(x269_ + 3);\
589 
	( destroyer_ ) ( x269_, ( unsigned ) 4 ) ;\
 589 
	(destroyer_)(x269_, (unsigned)4);\
590 
    }
 590 
    }
591 
 
 591 
 
592 
 
 592 
 
593 
/* Operations for field enumerate of union TYPE */
 593 
/* Operations for field enumerate of union TYPE */
594 
 
 594 
 
595 
#define type_enumerate_tag		( ( unsigned ) 12 )
 595 
#define type_enumerate_tag		((unsigned)12)
596 
#define IS_type_enumerate( P )		( CHECK_NULL ( P )->ag_tag == 12 )
 596 
#define IS_type_enumerate(P)		(CHECK_NULL(P)->ag_tag == 12)
597 
 
 597 
 
598 
#define type_enumerate_defn( P )	( CHECK_TAG ( ( P ), 12 ) + 3 )
 598 
#define type_enumerate_defn(P)		(CHECK_TAG((P), 12) + 3)
599 
 
 599 
 
600 
#define MAKE_type_enumerate( qual_, defn_, c_class_type )\
 600 
#define MAKE_type_enumerate(qual_, defn_, c_class_type)\
601 
    {\
 601 
    {\
602 
	c_class *x270_ = GEN_c_class ( 4, TYPEID_type ) ;\
 602 
	c_class *x270_ = GEN_c_class(4, TYPEID_type);\
603 
	x270_->ag_tag = 12 ;\
 603 
	x270_->ag_tag = 12;\
604 
	COPY_cv ( x270_ + 1, ( qual_ ) ) ;\
 604 
	COPY_cv(x270_ + 1, (qual_));\
605 
	COPY_id ( x270_ + 2, NULL_id ) ;\
 605 
	COPY_id(x270_ + 2, NULL_id);\
606 
	COPY_etype ( x270_ + 3, ( defn_ ) ) ;\
 606 
	COPY_etype(x270_ + 3, (defn_));\
607 
	( c_class_type ) = x270_ ;\
 607 
	(c_class_type) = x270_;\
608 
    }
 608 
    }
609 
 
 609 
 
610 
#define DECONS_type_enumerate( qual_, name_, defn_, c_class_type )\
 610 
#define DECONS_type_enumerate(qual_, name_, defn_, c_class_type)\
611 
    {\
 611 
    {\
612 
	c_class *x271_ = CHECK_TAG ( ( c_class_type ), 12 ) ;\
 612 
	c_class *x271_ = CHECK_TAG((c_class_type), 12);\
613 
	( qual_ ) = DEREF_cv ( x271_ + 1 ) ;\
 613 
	(qual_) = DEREF_cv(x271_ + 1);\
614 
	( name_ ) = DEREF_id ( x271_ + 2 ) ;\
 614 
	(name_) = DEREF_id(x271_ + 2);\
615 
	( defn_ ) = DEREF_etype ( x271_ + 3 ) ;\
 615 
	(defn_) = DEREF_etype(x271_ + 3);\
616 
    }
 616 
    }
617 
 
 617 
 
618 
#define DESTROY_type_enumerate( destroyer_, qual_, name_, defn_, c_class_type )\
 618 
#define DESTROY_type_enumerate(destroyer_, qual_, name_, defn_, c_class_type)\
619 
    {\
 619 
    {\
620 
	c_class *x272_ = CHECK_TAG ( ( c_class_type ), 12 ) ;\
 620 
	c_class *x272_ = CHECK_TAG((c_class_type), 12);\
621 
	( qual_ ) = DEREF_cv ( x272_ + 1 ) ;\
 621 
	(qual_) = DEREF_cv(x272_ + 1);\
622 
	( name_ ) = DEREF_id ( x272_ + 2 ) ;\
 622 
	(name_) = DEREF_id(x272_ + 2);\
623 
	( defn_ ) = DEREF_etype ( x272_ + 3 ) ;\
 623 
	(defn_) = DEREF_etype(x272_ + 3);\
624 
	( destroyer_ ) ( x272_, ( unsigned ) 4 ) ;\
 624 
	(destroyer_)(x272_, (unsigned)4);\
625 
    }
 625 
    }
626 
 
 626 
 
627 
 
 627 
 
628 
/* Operations for field token of union TYPE */
 628 
/* Operations for field token of union TYPE */
629 
 
 629 
 
630 
#define type_token_tag			( ( unsigned ) 13 )
 630 
#define type_token_tag			((unsigned)13)
631 
#define IS_type_token( P )		( CHECK_NULL ( P )->ag_tag == 13 )
 631 
#define IS_type_token(P)		(CHECK_NULL(P)->ag_tag == 13)
632 
 
 632 
 
633 
#define type_token_tok( P )		( CHECK_TAG ( ( P ), 13 ) + 3 )
 633 
#define type_token_tok(P)		(CHECK_TAG((P), 13) + 3)
634 
#define type_token_args( P )		( CHECK_TAG ( ( P ), 13 ) + 4 )
 634 
#define type_token_args(P)		(CHECK_TAG((P), 13) + 4)
635 
#define type_token_app( P )		( CHECK_TAG ( ( P ), 13 ) + 5 )
 635 
#define type_token_app(P)		(CHECK_TAG((P), 13) + 5)
636 
 
 636 
 
637 
#define MAKE_type_token( qual_, tok_, args_, c_class_type )\
 637 
#define MAKE_type_token(qual_, tok_, args_, c_class_type)\
638 
    {\
 638 
    {\
639 
	c_class *x273_ = GEN_c_class ( 6, TYPEID_type ) ;\
 639 
	c_class *x273_ = GEN_c_class(6, TYPEID_type);\
640 
	x273_->ag_tag = 13 ;\
 640 
	x273_->ag_tag = 13;\
641 
	COPY_cv ( x273_ + 1, ( qual_ ) ) ;\
 641 
	COPY_cv(x273_ + 1, (qual_));\
642 
	COPY_id ( x273_ + 2, NULL_id ) ;\
 642 
	COPY_id(x273_ + 2, NULL_id);\
643 
	COPY_id ( x273_ + 3, ( tok_ ) ) ;\
 643 
	COPY_id(x273_ + 3, (tok_));\
644 
	COPY_list ( x273_ + 4, ( args_ ) ) ;\
 644 
	COPY_list(x273_ + 4, (args_));\
645 
	COPY_inst ( x273_ + 5, NULL_inst ) ;\
 645 
	COPY_inst(x273_ + 5, NULL_inst);\
646 
	( c_class_type ) = x273_ ;\
 646 
	(c_class_type) = x273_;\
647 
    }
 647 
    }
648 
 
 648 
 
649 
#define DECONS_type_token( qual_, name_, tok_, args_, app_, c_class_type )\
 649 
#define DECONS_type_token(qual_, name_, tok_, args_, app_, c_class_type)\
650 
    {\
 650 
    {\
651 
	c_class *x274_ = CHECK_TAG ( ( c_class_type ), 13 ) ;\
 651 
	c_class *x274_ = CHECK_TAG((c_class_type), 13);\
652 
	( qual_ ) = DEREF_cv ( x274_ + 1 ) ;\
 652 
	(qual_) = DEREF_cv(x274_ + 1);\
653 
	( name_ ) = DEREF_id ( x274_ + 2 ) ;\
 653 
	(name_) = DEREF_id(x274_ + 2);\
654 
	( tok_ ) = DEREF_id ( x274_ + 3 ) ;\
 654 
	(tok_) = DEREF_id(x274_ + 3);\
655 
	( args_ ) = DEREF_list ( x274_ + 4 ) ;\
 655 
	(args_) = DEREF_list(x274_ + 4);\
656 
	( app_ ) = DEREF_inst ( x274_ + 5 ) ;\
 656 
	(app_) = DEREF_inst(x274_ + 5);\
657 
    }
 657 
    }
658 
 
 658 
 
659 
#define DESTROY_type_token( destroyer_, qual_, name_, tok_, args_, app_, c_class_type )\
 659 
#define DESTROY_type_token(destroyer_, qual_, name_, tok_, args_, app_, c_class_type)\
660 
    {\
 660 
    {\
661 
	c_class *x275_ = CHECK_TAG ( ( c_class_type ), 13 ) ;\
 661 
	c_class *x275_ = CHECK_TAG((c_class_type), 13);\
662 
	( qual_ ) = DEREF_cv ( x275_ + 1 ) ;\
 662 
	(qual_) = DEREF_cv(x275_ + 1);\
663 
	( name_ ) = DEREF_id ( x275_ + 2 ) ;\
 663 
	(name_) = DEREF_id(x275_ + 2);\
664 
	( tok_ ) = DEREF_id ( x275_ + 3 ) ;\
 664 
	(tok_) = DEREF_id(x275_ + 3);\
665 
	( args_ ) = DEREF_list ( x275_ + 4 ) ;\
 665 
	(args_) = DEREF_list(x275_ + 4);\
666 
	( app_ ) = DEREF_inst ( x275_ + 5 ) ;\
 666 
	(app_) = DEREF_inst(x275_ + 5);\
667 
	( destroyer_ ) ( x275_, ( unsigned ) 6 ) ;\
 667 
	(destroyer_)(x275_, (unsigned)6);\
668 
    }
 668 
    }
669 
 
 669 
 
670 
 
 670 
 
671 
/* Operations for field templ of union TYPE */
 671 
/* Operations for field templ of union TYPE */
672 
 
 672 
 
673 
#define type_templ_tag			( ( unsigned ) 14 )
 673 
#define type_templ_tag			((unsigned)14)
674 
#define IS_type_templ( P )		( CHECK_NULL ( P )->ag_tag == 14 )
 674 
#define IS_type_templ(P)		(CHECK_NULL(P)->ag_tag == 14)
675 
 
 675 
 
676 
#define type_templ_sort( P )		( CHECK_TAG ( ( P ), 14 ) + 3 )
 676 
#define type_templ_sort(P)		(CHECK_TAG((P), 14) + 3)
677 
#define type_templ_defn( P )		( CHECK_TAG ( ( P ), 14 ) + 4 )
 677 
#define type_templ_defn(P)		(CHECK_TAG((P), 14) + 4)
678 
#define type_templ_fix( P )		( CHECK_TAG ( ( P ), 14 ) + 5 )
 678 
#define type_templ_fix(P)		(CHECK_TAG((P), 14) + 5)
679 
 
 679 
 
680 
#define MAKE_type_templ( qual_, sort_, defn_, fix_, c_class_type )\
 680 
#define MAKE_type_templ(qual_, sort_, defn_, fix_, c_class_type)\
681 
    {\
 681 
    {\
682 
	c_class *x276_ = GEN_c_class ( 6, TYPEID_type ) ;\
 682 
	c_class *x276_ = GEN_c_class(6, TYPEID_type);\
683 
	x276_->ag_tag = 14 ;\
 683 
	x276_->ag_tag = 14;\
684 
	COPY_cv ( x276_ + 1, ( qual_ ) ) ;\
 684 
	COPY_cv(x276_ + 1, (qual_));\
685 
	COPY_id ( x276_ + 2, NULL_id ) ;\
 685 
	COPY_id(x276_ + 2, NULL_id);\
686 
	COPY_tok ( x276_ + 3, ( sort_ ) ) ;\
 686 
	COPY_tok(x276_ + 3, (sort_));\
687 
	COPY_type ( x276_ + 4, ( defn_ ) ) ;\
 687 
	COPY_type(x276_ + 4, (defn_));\
688 
	COPY_int ( x276_ + 5, ( fix_ ) ) ;\
 688 
	COPY_int(x276_ + 5, (fix_));\
689 
	( c_class_type ) = x276_ ;\
 689 
	(c_class_type) = x276_;\
690 
    }
 690 
    }
691 
 
 691 
 
692 
#define DECONS_type_templ( qual_, name_, sort_, defn_, fix_, c_class_type )\
 692 
#define DECONS_type_templ(qual_, name_, sort_, defn_, fix_, c_class_type)\
693 
    {\
 693 
    {\
694 
	c_class *x277_ = CHECK_TAG ( ( c_class_type ), 14 ) ;\
 694 
	c_class *x277_ = CHECK_TAG((c_class_type), 14);\
695 
	( qual_ ) = DEREF_cv ( x277_ + 1 ) ;\
 695 
	(qual_) = DEREF_cv(x277_ + 1);\
696 
	( name_ ) = DEREF_id ( x277_ + 2 ) ;\
 696 
	(name_) = DEREF_id(x277_ + 2);\
697 
	( sort_ ) = DEREF_tok ( x277_ + 3 ) ;\
 697 
	(sort_) = DEREF_tok(x277_ + 3);\
698 
	( defn_ ) = DEREF_type ( x277_ + 4 ) ;\
 698 
	(defn_) = DEREF_type(x277_ + 4);\
699 
	( fix_ ) = DEREF_int ( x277_ + 5 ) ;\
 699 
	(fix_) = DEREF_int(x277_ + 5);\
700 
    }
 700 
    }
701 
 
 701 
 
702 
#define DESTROY_type_templ( destroyer_, qual_, name_, sort_, defn_, fix_, c_class_type )\
 702 
#define DESTROY_type_templ(destroyer_, qual_, name_, sort_, defn_, fix_, c_class_type)\
703 
    {\
 703 
    {\
704 
	c_class *x278_ = CHECK_TAG ( ( c_class_type ), 14 ) ;\
 704 
	c_class *x278_ = CHECK_TAG((c_class_type), 14);\
705 
	( qual_ ) = DEREF_cv ( x278_ + 1 ) ;\
 705 
	(qual_) = DEREF_cv(x278_ + 1);\
706 
	( name_ ) = DEREF_id ( x278_ + 2 ) ;\
 706 
	(name_) = DEREF_id(x278_ + 2);\
707 
	( sort_ ) = DEREF_tok ( x278_ + 3 ) ;\
 707 
	(sort_) = DEREF_tok(x278_ + 3);\
708 
	( defn_ ) = DEREF_type ( x278_ + 4 ) ;\
 708 
	(defn_) = DEREF_type(x278_ + 4);\
709 
	( fix_ ) = DEREF_int ( x278_ + 5 ) ;\
 709 
	(fix_) = DEREF_int(x278_ + 5);\
710 
	( destroyer_ ) ( x278_, ( unsigned ) 6 ) ;\
 710 
	(destroyer_)(x278_, (unsigned)6);\
711 
    }
 711 
    }
712 
 
 712 
 
713 
 
 713 
 
714 
/* Operations for field instance of union TYPE */
 714 
/* Operations for field instance of union TYPE */
715 
 
 715 
 
716 
#define type_instance_tag		( ( unsigned ) 15 )
 716 
#define type_instance_tag		((unsigned)15)
717 
#define IS_type_instance( P )		( CHECK_NULL ( P )->ag_tag == 15 )
 717 
#define IS_type_instance(P)		(CHECK_NULL(P)->ag_tag == 15)
718 
 
 718 
 
719 
#define type_instance_id( P )		( CHECK_TAG ( ( P ), 15 ) + 3 )
 719 
#define type_instance_id(P)		(CHECK_TAG((P), 15) + 3)
720 
#define type_instance_access( P )	( CHECK_TAG ( ( P ), 15 ) + 4 )
 720 
#define type_instance_access(P)		(CHECK_TAG((P), 15) + 4)
721 
 
 721 
 
722 
#define MAKE_type_instance( qual_, id_, access_, c_class_type )\
 722 
#define MAKE_type_instance(qual_, id_, access_, c_class_type)\
723 
    {\
 723 
    {\
724 
	c_class *x279_ = GEN_c_class ( 5, TYPEID_type ) ;\
 724 
	c_class *x279_ = GEN_c_class(5, TYPEID_type);\
725 
	x279_->ag_tag = 15 ;\
 725 
	x279_->ag_tag = 15;\
726 
	COPY_cv ( x279_ + 1, ( qual_ ) ) ;\
 726 
	COPY_cv(x279_ + 1, (qual_));\
727 
	COPY_id ( x279_ + 2, NULL_id ) ;\
 727 
	COPY_id(x279_ + 2, NULL_id);\
728 
	COPY_id ( x279_ + 3, ( id_ ) ) ;\
 728 
	COPY_id(x279_ + 3, (id_));\
729 
	COPY_dspec ( x279_ + 4, ( access_ ) ) ;\
 729 
	COPY_dspec(x279_ + 4, (access_));\
730 
	( c_class_type ) = x279_ ;\
 730 
	(c_class_type) = x279_;\
731 
    }
 731 
    }
732 
 
 732 
 
733 
#define DECONS_type_instance( qual_, name_, id_, access_, c_class_type )\
 733 
#define DECONS_type_instance(qual_, name_, id_, access_, c_class_type)\
734 
    {\
 734 
    {\
735 
	c_class *x280_ = CHECK_TAG ( ( c_class_type ), 15 ) ;\
 735 
	c_class *x280_ = CHECK_TAG((c_class_type), 15);\
736 
	( qual_ ) = DEREF_cv ( x280_ + 1 ) ;\
 736 
	(qual_) = DEREF_cv(x280_ + 1);\
737 
	( name_ ) = DEREF_id ( x280_ + 2 ) ;\
 737 
	(name_) = DEREF_id(x280_ + 2);\
738 
	( id_ ) = DEREF_id ( x280_ + 3 ) ;\
 738 
	(id_) = DEREF_id(x280_ + 3);\
739 
	( access_ ) = DEREF_dspec ( x280_ + 4 ) ;\
 739 
	(access_) = DEREF_dspec(x280_ + 4);\
740 
    }
 740 
    }
741 
 
 741 
 
742 
#define DESTROY_type_instance( destroyer_, qual_, name_, id_, access_, c_class_type )\
 742 
#define DESTROY_type_instance(destroyer_, qual_, name_, id_, access_, c_class_type)\
743 
    {\
 743 
    {\
744 
	c_class *x281_ = CHECK_TAG ( ( c_class_type ), 15 ) ;\
 744 
	c_class *x281_ = CHECK_TAG((c_class_type), 15);\
745 
	( qual_ ) = DEREF_cv ( x281_ + 1 ) ;\
 745 
	(qual_) = DEREF_cv(x281_ + 1);\
746 
	( name_ ) = DEREF_id ( x281_ + 2 ) ;\
 746 
	(name_) = DEREF_id(x281_ + 2);\
747 
	( id_ ) = DEREF_id ( x281_ + 3 ) ;\
 747 
	(id_) = DEREF_id(x281_ + 3);\
748 
	( access_ ) = DEREF_dspec ( x281_ + 4 ) ;\
 748 
	(access_) = DEREF_dspec(x281_ + 4);\
749 
	( destroyer_ ) ( x281_, ( unsigned ) 5 ) ;\
 749 
	(destroyer_)(x281_, (unsigned)5);\
750 
    }
 750 
    }
751 
 
 751 
 
752 
 
 752 
 
753 
/* Operations for field dummy of union TYPE */
 753 
/* Operations for field dummy of union TYPE */
754 
 
 754 
 
755 
#define type_dummy_tag			( ( unsigned ) 16 )
 755 
#define type_dummy_tag			((unsigned)16)
756 
#define IS_type_dummy( P )		( CHECK_NULL ( P )->ag_tag == 16 )
 756 
#define IS_type_dummy(P)		(CHECK_NULL(P)->ag_tag == 16)
757 
 
 757 
 
758 
#define type_dummy_tok( P )		( CHECK_TAG ( ( P ), 16 ) + 3 )
 758 
#define type_dummy_tok(P)		(CHECK_TAG((P), 16) + 3)
759 
 
 759 
 
760 
#define MAKE_type_dummy( qual_, tok_, c_class_type )\
 760 
#define MAKE_type_dummy(qual_, tok_, c_class_type)\
761 
    {\
 761 
    {\
762 
	c_class *x282_ = GEN_c_class ( 4, TYPEID_type ) ;\
 762 
	c_class *x282_ = GEN_c_class(4, TYPEID_type);\
763 
	x282_->ag_tag = 16 ;\
 763 
	x282_->ag_tag = 16;\
764 
	COPY_cv ( x282_ + 1, ( qual_ ) ) ;\
 764 
	COPY_cv(x282_ + 1, (qual_));\
765 
	COPY_id ( x282_ + 2, NULL_id ) ;\
 765 
	COPY_id(x282_ + 2, NULL_id);\
766 
	COPY_int ( x282_ + 3, ( tok_ ) ) ;\
 766 
	COPY_int(x282_ + 3, (tok_));\
767 
	( c_class_type ) = x282_ ;\
 767 
	(c_class_type) = x282_;\
768 
    }
 768 
    }
769 
 
 769 
 
770 
#define DECONS_type_dummy( qual_, name_, tok_, c_class_type )\
 770 
#define DECONS_type_dummy(qual_, name_, tok_, c_class_type)\
771 
    {\
 771 
    {\
772 
	c_class *x283_ = CHECK_TAG ( ( c_class_type ), 16 ) ;\
 772 
	c_class *x283_ = CHECK_TAG((c_class_type), 16);\
773 
	( qual_ ) = DEREF_cv ( x283_ + 1 ) ;\
 773 
	(qual_) = DEREF_cv(x283_ + 1);\
774 
	( name_ ) = DEREF_id ( x283_ + 2 ) ;\
 774 
	(name_) = DEREF_id(x283_ + 2);\
775 
	( tok_ ) = DEREF_int ( x283_ + 3 ) ;\
 775 
	(tok_) = DEREF_int(x283_ + 3);\
776 
    }
 776 
    }
777 
 
 777 
 
778 
#define DESTROY_type_dummy( destroyer_, qual_, name_, tok_, c_class_type )\
 778 
#define DESTROY_type_dummy(destroyer_, qual_, name_, tok_, c_class_type)\
779 
    {\
 779 
    {\
780 
	c_class *x284_ = CHECK_TAG ( ( c_class_type ), 16 ) ;\
 780 
	c_class *x284_ = CHECK_TAG((c_class_type), 16);\
781 
	( qual_ ) = DEREF_cv ( x284_ + 1 ) ;\
 781 
	(qual_) = DEREF_cv(x284_ + 1);\
782 
	( name_ ) = DEREF_id ( x284_ + 2 ) ;\
 782 
	(name_) = DEREF_id(x284_ + 2);\
783 
	( tok_ ) = DEREF_int ( x284_ + 3 ) ;\
 783 
	(tok_) = DEREF_int(x284_ + 3);\
784 
	( destroyer_ ) ( x284_, ( unsigned ) 4 ) ;\
 784 
	(destroyer_)(x284_, (unsigned)4);\
785 
    }
 785 
    }
786 
 
 786 
 
787 
 
 787 
 
788 
/* Operations for field error of union TYPE */
 788 
/* Operations for field error of union TYPE */
789 
 
 789 
 
790 
#define type_error_tag			( ( unsigned ) 17 )
 790 
#define type_error_tag			((unsigned)17)
791 
#define IS_type_error( P )		( CHECK_NULL ( P )->ag_tag == 17 )
 791 
#define IS_type_error(P)		(CHECK_NULL(P)->ag_tag == 17)
792 
 
 792 
 
793 
 
 793 
 
794 
#define MAKE_type_error( qual_, c_class_type )\
 794 
#define MAKE_type_error(qual_, c_class_type)\
795 
    {\
 795 
    {\
796 
	c_class *x285_ = GEN_c_class ( 3, TYPEID_type ) ;\
 796 
	c_class *x285_ = GEN_c_class(3, TYPEID_type);\
797 
	x285_->ag_tag = 17 ;\
 797 
	x285_->ag_tag = 17;\
798 
	COPY_cv ( x285_ + 1, ( qual_ ) ) ;\
 798 
	COPY_cv(x285_ + 1, (qual_));\
799 
	COPY_id ( x285_ + 2, NULL_id ) ;\
 799 
	COPY_id(x285_ + 2, NULL_id);\
800 
	( c_class_type ) = x285_ ;\
 800 
	(c_class_type) = x285_;\
801 
    }
 801 
    }
802 
 
 802 
 
803 
#define DECONS_type_error( qual_, name_, c_class_type )\
 803 
#define DECONS_type_error(qual_, name_, c_class_type)\
804 
    {\
 804 
    {\
805 
	c_class *x286_ = CHECK_TAG ( ( c_class_type ), 17 ) ;\
 805 
	c_class *x286_ = CHECK_TAG((c_class_type), 17);\
806 
	( qual_ ) = DEREF_cv ( x286_ + 1 ) ;\
 806 
	(qual_) = DEREF_cv(x286_ + 1);\
807 
	( name_ ) = DEREF_id ( x286_ + 2 ) ;\
 807 
	(name_) = DEREF_id(x286_ + 2);\
808 
    }
 808 
    }
809 
 
 809 
 
810 
#define DESTROY_type_error( destroyer_, qual_, name_, c_class_type )\
 810 
#define DESTROY_type_error(destroyer_, qual_, name_, c_class_type)\
811 
    {\
 811 
    {\
812 
	c_class *x287_ = CHECK_TAG ( ( c_class_type ), 17 ) ;\
 812 
	c_class *x287_ = CHECK_TAG((c_class_type), 17);\
813 
	( qual_ ) = DEREF_cv ( x287_ + 1 ) ;\
 813 
	(qual_) = DEREF_cv(x287_ + 1);\
814 
	( name_ ) = DEREF_id ( x287_ + 2 ) ;\
 814 
	(name_) = DEREF_id(x287_ + 2);\
815 
	( destroyer_ ) ( x287_, ( unsigned ) 3 ) ;\
 815 
	(destroyer_)(x287_, (unsigned)3);\
816 
    }
 816 
    }
817 
 
 817 
 
818 
 
 818 
 
819 
#endif
 819 
#endif