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 OFF_OPS_H_INCLUDED
 35 
#ifndef OFF_OPS_H_INCLUDED
36 
#define OFF_OPS_H_INCLUDED
 36 
#define OFF_OPS_H_INCLUDED
37 
 
 37 
 
38 
/* Operations for union OFFSET */
 38 
/* Operations for union OFFSET */
39 
 
 39 
 
40 
#define TAG_off( P )			( CHECK_NULL ( P )->ag_tag )
 40 
#define TAG_off(P)			(CHECK_NULL(P)->ag_tag)
41 
 
 41 
 
42 
 
 42 
 
43 
/* Operations for field zero of union OFFSET */
 43 
/* Operations for field zero of union OFFSET */
44 
 
 44 
 
45 
#define off_zero_tag			( ( unsigned ) 0 )
 45 
#define off_zero_tag			((unsigned)0)
46 
#define IS_off_zero( P )		( CHECK_NULL ( P )->ag_tag == 0 )
 46 
#define IS_off_zero(P)			(CHECK_NULL(P)->ag_tag == 0)
47 
 
 47 
 
48 
#define off_zero_type( P )		( CHECK_TAG ( ( P ), 0 ) + 1 )
 48 
#define off_zero_type(P)		(CHECK_TAG((P), 0) + 1)
49 
 
 49 
 
50 
#define MAKE_off_zero( type_, c_class_off )\
 50 
#define MAKE_off_zero(type_, c_class_off)\
51 
    {\
 51 
    {\
52 
	c_class *x778_ = GEN_c_class ( 2, TYPEID_off ) ;\
 52 
	c_class *x778_ = GEN_c_class(2, TYPEID_off);\
53 
	x778_->ag_tag = 0 ;\
 53 
	x778_->ag_tag = 0;\
54 
	COPY_type ( x778_ + 1, ( type_ ) ) ;\
 54 
	COPY_type(x778_ + 1, (type_));\
55 
	( c_class_off ) = x778_ ;\
 55 
	(c_class_off) = x778_;\
56 
    }
 56 
    }
57 
 
 57 
 
58 
#define DECONS_off_zero( type_, c_class_off )\
 58 
#define DECONS_off_zero(type_, c_class_off)\
59 
    {\
 59 
    {\
60 
	c_class *x779_ = CHECK_TAG ( ( c_class_off ), 0 ) ;\
 60 
	c_class *x779_ = CHECK_TAG((c_class_off), 0);\
61 
	( type_ ) = DEREF_type ( x779_ + 1 ) ;\
 61 
	(type_) = DEREF_type(x779_ + 1);\
62 
    }
 62 
    }
63 
 
 63 
 
64 
#define DESTROY_off_zero( destroyer_, type_, c_class_off )\
 64 
#define DESTROY_off_zero(destroyer_, type_, c_class_off)\
65 
    {\
 65 
    {\
66 
	c_class *x780_ = CHECK_TAG ( ( c_class_off ), 0 ) ;\
 66 
	c_class *x780_ = CHECK_TAG((c_class_off), 0);\
67 
	( type_ ) = DEREF_type ( x780_ + 1 ) ;\
 67 
	(type_) = DEREF_type(x780_ + 1);\
68 
	( destroyer_ ) ( x780_, ( unsigned ) 2 ) ;\
 68 
	(destroyer_)(x780_, (unsigned)2);\
69 
    }
 69 
    }
70 
 
 70 
 
71 
 
 71 
 
72 
/* Operations for field type of union OFFSET */
 72 
/* Operations for field type of union OFFSET */
73 
 
 73 
 
74 
#define off_type_tag			( ( unsigned ) 1 )
 74 
#define off_type_tag			((unsigned)1)
75 
#define IS_off_type( P )		( CHECK_NULL ( P )->ag_tag == 1 )
 75 
#define IS_off_type(P)			(CHECK_NULL(P)->ag_tag == 1)
76 
 
 76 
 
77 
#define off_type_type( P )		( CHECK_TAG ( ( P ), 1 ) + 1 )
 77 
#define off_type_type(P)		(CHECK_TAG((P), 1) + 1)
78 
 
 78 
 
79 
#define MAKE_off_type( type_, c_class_off )\
 79 
#define MAKE_off_type(type_, c_class_off)\
80 
    {\
 80 
    {\
81 
	c_class *x781_ = GEN_c_class ( 2, TYPEID_off ) ;\
 81 
	c_class *x781_ = GEN_c_class(2, TYPEID_off);\
82 
	x781_->ag_tag = 1 ;\
 82 
	x781_->ag_tag = 1;\
83 
	COPY_type ( x781_ + 1, ( type_ ) ) ;\
 83 
	COPY_type(x781_ + 1, (type_));\
84 
	( c_class_off ) = x781_ ;\
 84 
	(c_class_off) = x781_;\
85 
    }
 85 
    }
86 
 
 86 
 
87 
#define DECONS_off_type( type_, c_class_off )\
 87 
#define DECONS_off_type(type_, c_class_off)\
88 
    {\
 88 
    {\
89 
	c_class *x782_ = CHECK_TAG ( ( c_class_off ), 1 ) ;\
 89 
	c_class *x782_ = CHECK_TAG((c_class_off), 1);\
90 
	( type_ ) = DEREF_type ( x782_ + 1 ) ;\
 90 
	(type_) = DEREF_type(x782_ + 1);\
91 
    }
 91 
    }
92 
 
 92 
 
93 
#define DESTROY_off_type( destroyer_, type_, c_class_off )\
 93 
#define DESTROY_off_type(destroyer_, type_, c_class_off)\
94 
    {\
 94 
    {\
95 
	c_class *x783_ = CHECK_TAG ( ( c_class_off ), 1 ) ;\
 95 
	c_class *x783_ = CHECK_TAG((c_class_off), 1);\
96 
	( type_ ) = DEREF_type ( x783_ + 1 ) ;\
 96 
	(type_) = DEREF_type(x783_ + 1);\
97 
	( destroyer_ ) ( x783_, ( unsigned ) 2 ) ;\
 97 
	(destroyer_)(x783_, (unsigned)2);\
98 
    }
 98 
    }
99 
 
 99 
 
100 
 
 100 
 
101 
/* Operations for field array of union OFFSET */
 101 
/* Operations for field array of union OFFSET */
102 
 
 102 
 
103 
#define off_array_tag			( ( unsigned ) 2 )
 103 
#define off_array_tag			((unsigned)2)
104 
#define IS_off_array( P )		( CHECK_NULL ( P )->ag_tag == 2 )
 104 
#define IS_off_array(P)			(CHECK_NULL(P)->ag_tag == 2)
105 
 
 105 
 
106 
#define off_array_type( P )		( CHECK_TAG ( ( P ), 2 ) + 1 )
 106 
#define off_array_type(P)		(CHECK_TAG((P), 2) + 1)
107 
#define off_array_arg( P )		( CHECK_TAG ( ( P ), 2 ) + 2 )
 107 
#define off_array_arg(P)		(CHECK_TAG((P), 2) + 2)
108 
 
 108 
 
109 
#define MAKE_off_array( type_, arg_, c_class_off )\
 109 
#define MAKE_off_array(type_, arg_, c_class_off)\
110 
    {\
 110 
    {\
111 
	c_class *x784_ = GEN_c_class ( 3, TYPEID_off ) ;\
 111 
	c_class *x784_ = GEN_c_class(3, TYPEID_off);\
112 
	x784_->ag_tag = 2 ;\
 112 
	x784_->ag_tag = 2;\
113 
	COPY_type ( x784_ + 1, ( type_ ) ) ;\
 113 
	COPY_type(x784_ + 1, (type_));\
114 
	COPY_unsigned ( x784_ + 2, ( arg_ ) ) ;\
 114 
	COPY_unsigned(x784_ + 2, (arg_));\
115 
	( c_class_off ) = x784_ ;\
 115 
	(c_class_off) = x784_;\
116 
    }
 116 
    }
117 
 
 117 
 
118 
#define DECONS_off_array( type_, arg_, c_class_off )\
 118 
#define DECONS_off_array(type_, arg_, c_class_off)\
119 
    {\
 119 
    {\
120 
	c_class *x785_ = CHECK_TAG ( ( c_class_off ), 2 ) ;\
 120 
	c_class *x785_ = CHECK_TAG((c_class_off), 2);\
121 
	( type_ ) = DEREF_type ( x785_ + 1 ) ;\
 121 
	(type_) = DEREF_type(x785_ + 1);\
122 
	( arg_ ) = DEREF_unsigned ( x785_ + 2 ) ;\
 122 
	(arg_) = DEREF_unsigned(x785_ + 2);\
123 
    }
 123 
    }
124 
 
 124 
 
125 
#define DESTROY_off_array( destroyer_, type_, arg_, c_class_off )\
 125 
#define DESTROY_off_array(destroyer_, type_, arg_, c_class_off)\
126 
    {\
 126 
    {\
127 
	c_class *x786_ = CHECK_TAG ( ( c_class_off ), 2 ) ;\
 127 
	c_class *x786_ = CHECK_TAG((c_class_off), 2);\
128 
	( type_ ) = DEREF_type ( x786_ + 1 ) ;\
 128 
	(type_) = DEREF_type(x786_ + 1);\
129 
	( arg_ ) = DEREF_unsigned ( x786_ + 2 ) ;\
 129 
	(arg_) = DEREF_unsigned(x786_ + 2);\
130 
	( destroyer_ ) ( x786_, ( unsigned ) 3 ) ;\
 130 
	(destroyer_)(x786_, (unsigned)3);\
131 
    }
 131 
    }
132 
 
 132 
 
133 
 
 133 
 
134 
/* Operations for field extra of union OFFSET */
 134 
/* Operations for field extra of union OFFSET */
135 
 
 135 
 
136 
#define off_extra_tag			( ( unsigned ) 3 )
 136 
#define off_extra_tag			((unsigned)3)
137 
#define IS_off_extra( P )		( CHECK_NULL ( P )->ag_tag == 3 )
 137 
#define IS_off_extra(P)			(CHECK_NULL(P)->ag_tag == 3)
138 
 
 138 
 
139 
#define off_extra_type( P )		( CHECK_TAG ( ( P ), 3 ) + 1 )
 139 
#define off_extra_type(P)		(CHECK_TAG((P), 3) + 1)
140 
#define off_extra_scale( P )		( CHECK_TAG ( ( P ), 3 ) + 2 )
 140 
#define off_extra_scale(P)		(CHECK_TAG((P), 3) + 2)
141 
 
 141 
 
142 
#define MAKE_off_extra( type_, scale_, c_class_off )\
 142 
#define MAKE_off_extra(type_, scale_, c_class_off)\
143 
    {\
 143 
    {\
144 
	c_class *x787_ = GEN_c_class ( 3, TYPEID_off ) ;\
 144 
	c_class *x787_ = GEN_c_class(3, TYPEID_off);\
145 
	x787_->ag_tag = 3 ;\
 145 
	x787_->ag_tag = 3;\
146 
	COPY_type ( x787_ + 1, ( type_ ) ) ;\
 146 
	COPY_type(x787_ + 1, (type_));\
147 
	COPY_int ( x787_ + 2, ( scale_ ) ) ;\
 147 
	COPY_int(x787_ + 2, (scale_));\
148 
	( c_class_off ) = x787_ ;\
 148 
	(c_class_off) = x787_;\
149 
    }
 149 
    }
150 
 
 150 
 
151 
#define DECONS_off_extra( type_, scale_, c_class_off )\
 151 
#define DECONS_off_extra(type_, scale_, c_class_off)\
152 
    {\
 152 
    {\
153 
	c_class *x788_ = CHECK_TAG ( ( c_class_off ), 3 ) ;\
 153 
	c_class *x788_ = CHECK_TAG((c_class_off), 3);\
154 
	( type_ ) = DEREF_type ( x788_ + 1 ) ;\
 154 
	(type_) = DEREF_type(x788_ + 1);\
155 
	( scale_ ) = DEREF_int ( x788_ + 2 ) ;\
 155 
	(scale_) = DEREF_int(x788_ + 2);\
156 
    }
 156 
    }
157 
 
 157 
 
158 
#define DESTROY_off_extra( destroyer_, type_, scale_, c_class_off )\
 158 
#define DESTROY_off_extra(destroyer_, type_, scale_, c_class_off)\
159 
    {\
 159 
    {\
160 
	c_class *x789_ = CHECK_TAG ( ( c_class_off ), 3 ) ;\
 160 
	c_class *x789_ = CHECK_TAG((c_class_off), 3);\
161 
	( type_ ) = DEREF_type ( x789_ + 1 ) ;\
 161 
	(type_) = DEREF_type(x789_ + 1);\
162 
	( scale_ ) = DEREF_int ( x789_ + 2 ) ;\
 162 
	(scale_) = DEREF_int(x789_ + 2);\
163 
	( destroyer_ ) ( x789_, ( unsigned ) 3 ) ;\
 163 
	(destroyer_)(x789_, (unsigned)3);\
164 
    }
 164 
    }
165 
 
 165 
 
166 
 
 166 
 
167 
/* Operations for field base of union OFFSET */
 167 
/* Operations for field base of union OFFSET */
168 
 
 168 
 
169 
#define off_base_tag			( ( unsigned ) 4 )
 169 
#define off_base_tag			((unsigned)4)
170 
#define IS_off_base( P )		( CHECK_NULL ( P )->ag_tag == 4 )
 170 
#define IS_off_base(P)			(CHECK_NULL(P)->ag_tag == 4)
171 
 
 171 
 
172 
#define off_base_graph( P )		( CHECK_TAG ( ( P ), 4 ) + 1 )
 172 
#define off_base_graph(P)		(CHECK_TAG((P), 4) + 1)
173 
 
 173 
 
174 
#define MAKE_off_base( graph_, c_class_off )\
 174 
#define MAKE_off_base(graph_, c_class_off)\
175 
    {\
 175 
    {\
176 
	c_class *x790_ = GEN_c_class ( 2, TYPEID_off ) ;\
 176 
	c_class *x790_ = GEN_c_class(2, TYPEID_off);\
177 
	x790_->ag_tag = 4 ;\
 177 
	x790_->ag_tag = 4;\
178 
	COPY_graph ( x790_ + 1, ( graph_ ) ) ;\
 178 
	COPY_graph(x790_ + 1, (graph_));\
179 
	( c_class_off ) = x790_ ;\
 179 
	(c_class_off) = x790_;\
180 
    }
 180 
    }
181 
 
 181 
 
182 
#define DECONS_off_base( graph_, c_class_off )\
 182 
#define DECONS_off_base(graph_, c_class_off)\
183 
    {\
 183 
    {\
184 
	c_class *x791_ = CHECK_TAG ( ( c_class_off ), 4 ) ;\
 184 
	c_class *x791_ = CHECK_TAG((c_class_off), 4);\
185 
	( graph_ ) = DEREF_graph ( x791_ + 1 ) ;\
 185 
	(graph_) = DEREF_graph(x791_ + 1);\
186 
    }
 186 
    }
187 
 
 187 
 
188 
#define DESTROY_off_base( destroyer_, graph_, c_class_off )\
 188 
#define DESTROY_off_base(destroyer_, graph_, c_class_off)\
189 
    {\
 189 
    {\
190 
	c_class *x792_ = CHECK_TAG ( ( c_class_off ), 4 ) ;\
 190 
	c_class *x792_ = CHECK_TAG((c_class_off), 4);\
191 
	( graph_ ) = DEREF_graph ( x792_ + 1 ) ;\
 191 
	(graph_) = DEREF_graph(x792_ + 1);\
192 
	( destroyer_ ) ( x792_, ( unsigned ) 2 ) ;\
 192 
	(destroyer_)(x792_, (unsigned)2);\
193 
    }
 193 
    }
194 
 
 194 
 
195 
 
 195 
 
196 
/* Operations for field deriv of union OFFSET */
 196 
/* Operations for field deriv of union OFFSET */
197 
 
 197 
 
198 
#define off_deriv_tag			( ( unsigned ) 5 )
 198 
#define off_deriv_tag			((unsigned)5)
199 
#define IS_off_deriv( P )		( CHECK_NULL ( P )->ag_tag == 5 )
 199 
#define IS_off_deriv(P)			(CHECK_NULL(P)->ag_tag == 5)
200 
 
 200 
 
201 
#define off_deriv_graph( P )		( CHECK_TAG ( ( P ), 5 ) + 1 )
 201 
#define off_deriv_graph(P)		(CHECK_TAG((P), 5) + 1)
202 
#define off_deriv_direct( P )		( CHECK_TAG ( ( P ), 5 ) + 2 )
 202 
#define off_deriv_direct(P)		(CHECK_TAG((P), 5) + 2)
203 
#define off_deriv_indirect( P )		( CHECK_TAG ( ( P ), 5 ) + 3 )
 203 
#define off_deriv_indirect(P)		(CHECK_TAG((P), 5) + 3)
204 
 
 204 
 
205 
#define MAKE_off_deriv( graph_, direct_, indirect_, c_class_off )\
 205 
#define MAKE_off_deriv(graph_, direct_, indirect_, c_class_off)\
206 
    {\
 206 
    {\
207 
	c_class *x793_ = GEN_c_class ( 4, TYPEID_off ) ;\
 207 
	c_class *x793_ = GEN_c_class(4, TYPEID_off);\
208 
	x793_->ag_tag = 5 ;\
 208 
	x793_->ag_tag = 5;\
209 
	COPY_graph ( x793_ + 1, ( graph_ ) ) ;\
 209 
	COPY_graph(x793_ + 1, (graph_));\
210 
	COPY_off ( x793_ + 2, ( direct_ ) ) ;\
 210 
	COPY_off(x793_ + 2, (direct_));\
211 
	COPY_off ( x793_ + 3, ( indirect_ ) ) ;\
 211 
	COPY_off(x793_ + 3, (indirect_));\
212 
	( c_class_off ) = x793_ ;\
 212 
	(c_class_off) = x793_;\
213 
    }
 213 
    }
214 
 
 214 
 
215 
#define DECONS_off_deriv( graph_, direct_, indirect_, c_class_off )\
 215 
#define DECONS_off_deriv(graph_, direct_, indirect_, c_class_off)\
216 
    {\
 216 
    {\
217 
	c_class *x794_ = CHECK_TAG ( ( c_class_off ), 5 ) ;\
 217 
	c_class *x794_ = CHECK_TAG((c_class_off), 5);\
218 
	( graph_ ) = DEREF_graph ( x794_ + 1 ) ;\
 218 
	(graph_) = DEREF_graph(x794_ + 1);\
219 
	( direct_ ) = DEREF_off ( x794_ + 2 ) ;\
 219 
	(direct_) = DEREF_off(x794_ + 2);\
220 
	( indirect_ ) = DEREF_off ( x794_ + 3 ) ;\
 220 
	(indirect_) = DEREF_off(x794_ + 3);\
221 
    }
 221 
    }
222 
 
 222 
 
223 
#define DESTROY_off_deriv( destroyer_, graph_, direct_, indirect_, c_class_off )\
 223 
#define DESTROY_off_deriv(destroyer_, graph_, direct_, indirect_, c_class_off)\
224 
    {\
 224 
    {\
225 
	c_class *x795_ = CHECK_TAG ( ( c_class_off ), 5 ) ;\
 225 
	c_class *x795_ = CHECK_TAG((c_class_off), 5);\
226 
	( graph_ ) = DEREF_graph ( x795_ + 1 ) ;\
 226 
	(graph_) = DEREF_graph(x795_ + 1);\
227 
	( direct_ ) = DEREF_off ( x795_ + 2 ) ;\
 227 
	(direct_) = DEREF_off(x795_ + 2);\
228 
	( indirect_ ) = DEREF_off ( x795_ + 3 ) ;\
 228 
	(indirect_) = DEREF_off(x795_ + 3);\
229 
	( destroyer_ ) ( x795_, ( unsigned ) 4 ) ;\
 229 
	(destroyer_)(x795_, (unsigned)4);\
230 
    }
 230 
    }
231 
 
 231 
 
232 
 
 232 
 
233 
/* Operations for field member of union OFFSET */
 233 
/* Operations for field member of union OFFSET */
234 
 
 234 
 
235 
#define off_member_tag			( ( unsigned ) 6 )
 235 
#define off_member_tag			((unsigned)6)
236 
#define IS_off_member( P )		( CHECK_NULL ( P )->ag_tag == 6 )
 236 
#define IS_off_member(P)		(CHECK_NULL(P)->ag_tag == 6)
237 
 
 237 
 
238 
#define off_member_id( P )		( CHECK_TAG ( ( P ), 6 ) + 1 )
 238 
#define off_member_id(P)		(CHECK_TAG((P), 6) + 1)
239 
 
 239 
 
240 
#define MAKE_off_member( id_, c_class_off )\
 240 
#define MAKE_off_member(id_, c_class_off)\
241 
    {\
 241 
    {\
242 
	c_class *x796_ = GEN_c_class ( 2, TYPEID_off ) ;\
 242 
	c_class *x796_ = GEN_c_class(2, TYPEID_off);\
243 
	x796_->ag_tag = 6 ;\
 243 
	x796_->ag_tag = 6;\
244 
	COPY_id ( x796_ + 1, ( id_ ) ) ;\
 244 
	COPY_id(x796_ + 1, (id_));\
245 
	( c_class_off ) = x796_ ;\
 245 
	(c_class_off) = x796_;\
246 
    }
 246 
    }
247 
 
 247 
 
248 
#define DECONS_off_member( id_, c_class_off )\
 248 
#define DECONS_off_member(id_, c_class_off)\
249 
    {\
 249 
    {\
250 
	c_class *x797_ = CHECK_TAG ( ( c_class_off ), 6 ) ;\
 250 
	c_class *x797_ = CHECK_TAG((c_class_off), 6);\
251 
	( id_ ) = DEREF_id ( x797_ + 1 ) ;\
 251 
	(id_) = DEREF_id(x797_ + 1);\
252 
    }
 252 
    }
253 
 
 253 
 
254 
#define DESTROY_off_member( destroyer_, id_, c_class_off )\
 254 
#define DESTROY_off_member(destroyer_, id_, c_class_off)\
255 
    {\
 255 
    {\
256 
	c_class *x798_ = CHECK_TAG ( ( c_class_off ), 6 ) ;\
 256 
	c_class *x798_ = CHECK_TAG((c_class_off), 6);\
257 
	( id_ ) = DEREF_id ( x798_ + 1 ) ;\
 257 
	(id_) = DEREF_id(x798_ + 1);\
258 
	( destroyer_ ) ( x798_, ( unsigned ) 2 ) ;\
 258 
	(destroyer_)(x798_, (unsigned)2);\
259 
    }
 259 
    }
260 
 
 260 
 
261 
 
 261 
 
262 
/* Operations for field ptr_mem of union OFFSET */
 262 
/* Operations for field ptr_mem of union OFFSET */
263 
 
 263 
 
264 
#define off_ptr_mem_tag			( ( unsigned ) 7 )
 264 
#define off_ptr_mem_tag			((unsigned)7)
265 
#define IS_off_ptr_mem( P )		( CHECK_NULL ( P )->ag_tag == 7 )
 265 
#define IS_off_ptr_mem(P)		(CHECK_NULL(P)->ag_tag == 7)
266 
 
 266 
 
267 
#define off_ptr_mem_arg( P )		( CHECK_TAG ( ( P ), 7 ) + 1 )
 267 
#define off_ptr_mem_arg(P)		(CHECK_TAG((P), 7) + 1)
268 
 
 268 
 
269 
#define MAKE_off_ptr_mem( arg_, c_class_off )\
 269 
#define MAKE_off_ptr_mem(arg_, c_class_off)\
270 
    {\
 270 
    {\
271 
	c_class *x799_ = GEN_c_class ( 2, TYPEID_off ) ;\
 271 
	c_class *x799_ = GEN_c_class(2, TYPEID_off);\
272 
	x799_->ag_tag = 7 ;\
 272 
	x799_->ag_tag = 7;\
273 
	COPY_exp ( x799_ + 1, ( arg_ ) ) ;\
 273 
	COPY_exp(x799_ + 1, (arg_));\
274 
	( c_class_off ) = x799_ ;\
 274 
	(c_class_off) = x799_;\
275 
    }
 275 
    }
276 
 
 276 
 
277 
#define DECONS_off_ptr_mem( arg_, c_class_off )\
 277 
#define DECONS_off_ptr_mem(arg_, c_class_off)\
278 
    {\
 278 
    {\
279 
	c_class *x800_ = CHECK_TAG ( ( c_class_off ), 7 ) ;\
 279 
	c_class *x800_ = CHECK_TAG((c_class_off), 7);\
280 
	( arg_ ) = DEREF_exp ( x800_ + 1 ) ;\
 280 
	(arg_) = DEREF_exp(x800_ + 1);\
281 
    }
 281 
    }
282 
 
 282 
 
283 
#define DESTROY_off_ptr_mem( destroyer_, arg_, c_class_off )\
 283 
#define DESTROY_off_ptr_mem(destroyer_, arg_, c_class_off)\
284 
    {\
 284 
    {\
285 
	c_class *x801_ = CHECK_TAG ( ( c_class_off ), 7 ) ;\
 285 
	c_class *x801_ = CHECK_TAG((c_class_off), 7);\
286 
	( arg_ ) = DEREF_exp ( x801_ + 1 ) ;\
 286 
	(arg_) = DEREF_exp(x801_ + 1);\
287 
	( destroyer_ ) ( x801_, ( unsigned ) 2 ) ;\
 287 
	(destroyer_)(x801_, (unsigned)2);\
288 
    }
 288 
    }
289 
 
 289 
 
290 
 
 290 
 
291 
/* Operations for field negate of union OFFSET */
 291 
/* Operations for field negate of union OFFSET */
292 
 
 292 
 
293 
#define off_negate_tag			( ( unsigned ) 8 )
 293 
#define off_negate_tag			((unsigned)8)
294 
#define IS_off_negate( P )		( CHECK_NULL ( P )->ag_tag == 8 )
 294 
#define IS_off_negate(P)		(CHECK_NULL(P)->ag_tag == 8)
295 
 
 295 
 
296 
#define off_negate_arg( P )		( CHECK_TAG ( ( P ), 8 ) + 1 )
 296 
#define off_negate_arg(P)		(CHECK_TAG((P), 8) + 1)
297 
 
 297 
 
298 
#define MAKE_off_negate( arg_, c_class_off )\
 298 
#define MAKE_off_negate(arg_, c_class_off)\
299 
    {\
 299 
    {\
300 
	c_class *x802_ = GEN_c_class ( 2, TYPEID_off ) ;\
 300 
	c_class *x802_ = GEN_c_class(2, TYPEID_off);\
301 
	x802_->ag_tag = 8 ;\
 301 
	x802_->ag_tag = 8;\
302 
	COPY_off ( x802_ + 1, ( arg_ ) ) ;\
 302 
	COPY_off(x802_ + 1, (arg_));\
303 
	( c_class_off ) = x802_ ;\
 303 
	(c_class_off) = x802_;\
304 
    }
 304 
    }
305 
 
 305 
 
306 
#define DECONS_off_negate( arg_, c_class_off )\
 306 
#define DECONS_off_negate(arg_, c_class_off)\
307 
    {\
 307 
    {\
308 
	c_class *x803_ = CHECK_TAG ( ( c_class_off ), 8 ) ;\
 308 
	c_class *x803_ = CHECK_TAG((c_class_off), 8);\
309 
	( arg_ ) = DEREF_off ( x803_ + 1 ) ;\
 309 
	(arg_) = DEREF_off(x803_ + 1);\
310 
    }
 310 
    }
311 
 
 311 
 
312 
#define DESTROY_off_negate( destroyer_, arg_, c_class_off )\
 312 
#define DESTROY_off_negate(destroyer_, arg_, c_class_off)\
313 
    {\
 313 
    {\
314 
	c_class *x804_ = CHECK_TAG ( ( c_class_off ), 8 ) ;\
 314 
	c_class *x804_ = CHECK_TAG((c_class_off), 8);\
315 
	( arg_ ) = DEREF_off ( x804_ + 1 ) ;\
 315 
	(arg_) = DEREF_off(x804_ + 1);\
316 
	( destroyer_ ) ( x804_, ( unsigned ) 2 ) ;\
 316 
	(destroyer_)(x804_, (unsigned)2);\
317 
    }
 317 
    }
318 
 
 318 
 
319 
 
 319 
 
320 
/* Operations for field plus of union OFFSET */
 320 
/* Operations for field plus of union OFFSET */
321 
 
 321 
 
322 
#define off_plus_tag			( ( unsigned ) 9 )
 322 
#define off_plus_tag			((unsigned)9)
323 
#define IS_off_plus( P )		( CHECK_NULL ( P )->ag_tag == 9 )
 323 
#define IS_off_plus(P)			(CHECK_NULL(P)->ag_tag == 9)
324 
 
 324 
 
325 
#define off_plus_arg1( P )		( CHECK_TAG ( ( P ), 9 ) + 1 )
 325 
#define off_plus_arg1(P)		(CHECK_TAG((P), 9) + 1)
326 
#define off_plus_arg2( P )		( CHECK_TAG ( ( P ), 9 ) + 2 )
 326 
#define off_plus_arg2(P)		(CHECK_TAG((P), 9) + 2)
327 
 
 327 
 
328 
#define MAKE_off_plus( arg1_, arg2_, c_class_off )\
 328 
#define MAKE_off_plus(arg1_, arg2_, c_class_off)\
329 
    {\
 329 
    {\
330 
	c_class *x805_ = GEN_c_class ( 3, TYPEID_off ) ;\
 330 
	c_class *x805_ = GEN_c_class(3, TYPEID_off);\
331 
	x805_->ag_tag = 9 ;\
 331 
	x805_->ag_tag = 9;\
332 
	COPY_off ( x805_ + 1, ( arg1_ ) ) ;\
 332 
	COPY_off(x805_ + 1, (arg1_));\
333 
	COPY_off ( x805_ + 2, ( arg2_ ) ) ;\
 333 
	COPY_off(x805_ + 2, (arg2_));\
334 
	( c_class_off ) = x805_ ;\
 334 
	(c_class_off) = x805_;\
335 
    }
 335 
    }
336 
 
 336 
 
337 
#define DECONS_off_plus( arg1_, arg2_, c_class_off )\
 337 
#define DECONS_off_plus(arg1_, arg2_, c_class_off)\
338 
    {\
 338 
    {\
339 
	c_class *x806_ = CHECK_TAG ( ( c_class_off ), 9 ) ;\
 339 
	c_class *x806_ = CHECK_TAG((c_class_off), 9);\
340 
	( arg1_ ) = DEREF_off ( x806_ + 1 ) ;\
 340 
	(arg1_) = DEREF_off(x806_ + 1);\
341 
	( arg2_ ) = DEREF_off ( x806_ + 2 ) ;\
 341 
	(arg2_) = DEREF_off(x806_ + 2);\
342 
    }
 342 
    }
343 
 
 343 
 
344 
#define DESTROY_off_plus( destroyer_, arg1_, arg2_, c_class_off )\
 344 
#define DESTROY_off_plus(destroyer_, arg1_, arg2_, c_class_off)\
345 
    {\
 345 
    {\
346 
	c_class *x807_ = CHECK_TAG ( ( c_class_off ), 9 ) ;\
 346 
	c_class *x807_ = CHECK_TAG((c_class_off), 9);\
347 
	( arg1_ ) = DEREF_off ( x807_ + 1 ) ;\
 347 
	(arg1_) = DEREF_off(x807_ + 1);\
348 
	( arg2_ ) = DEREF_off ( x807_ + 2 ) ;\
 348 
	(arg2_) = DEREF_off(x807_ + 2);\
349 
	( destroyer_ ) ( x807_, ( unsigned ) 3 ) ;\
 349 
	(destroyer_)(x807_, (unsigned)3);\
350 
    }
 350 
    }
351 
 
 351 
 
352 
 
 352 
 
353 
/* Operations for field mult of union OFFSET */
 353 
/* Operations for field mult of union OFFSET */
354 
 
 354 
 
355 
#define off_mult_tag			( ( unsigned ) 10 )
 355 
#define off_mult_tag			((unsigned)10)
356 
#define IS_off_mult( P )		( CHECK_NULL ( P )->ag_tag == 10 )
 356 
#define IS_off_mult(P)			(CHECK_NULL(P)->ag_tag == 10)
357 
 
 357 
 
358 
#define off_mult_arg1( P )		( CHECK_TAG ( ( P ), 10 ) + 1 )
 358 
#define off_mult_arg1(P)		(CHECK_TAG((P), 10) + 1)
359 
#define off_mult_arg2( P )		( CHECK_TAG ( ( P ), 10 ) + 2 )
 359 
#define off_mult_arg2(P)		(CHECK_TAG((P), 10) + 2)
360 
 
 360 
 
361 
#define MAKE_off_mult( arg1_, arg2_, c_class_off )\
 361 
#define MAKE_off_mult(arg1_, arg2_, c_class_off)\
362 
    {\
 362 
    {\
363 
	c_class *x808_ = GEN_c_class ( 3, TYPEID_off ) ;\
 363 
	c_class *x808_ = GEN_c_class(3, TYPEID_off);\
364 
	x808_->ag_tag = 10 ;\
 364 
	x808_->ag_tag = 10;\
365 
	COPY_off ( x808_ + 1, ( arg1_ ) ) ;\
 365 
	COPY_off(x808_ + 1, (arg1_));\
366 
	COPY_exp ( x808_ + 2, ( arg2_ ) ) ;\
 366 
	COPY_exp(x808_ + 2, (arg2_));\
367 
	( c_class_off ) = x808_ ;\
 367 
	(c_class_off) = x808_;\
368 
    }
 368 
    }
369 
 
 369 
 
370 
#define DECONS_off_mult( arg1_, arg2_, c_class_off )\
 370 
#define DECONS_off_mult(arg1_, arg2_, c_class_off)\
371 
    {\
 371 
    {\
372 
	c_class *x809_ = CHECK_TAG ( ( c_class_off ), 10 ) ;\
 372 
	c_class *x809_ = CHECK_TAG((c_class_off), 10);\
373 
	( arg1_ ) = DEREF_off ( x809_ + 1 ) ;\
 373 
	(arg1_) = DEREF_off(x809_ + 1);\
374 
	( arg2_ ) = DEREF_exp ( x809_ + 2 ) ;\
 374 
	(arg2_) = DEREF_exp(x809_ + 2);\
375 
    }
 375 
    }
376 
 
 376 
 
377 
#define DESTROY_off_mult( destroyer_, arg1_, arg2_, c_class_off )\
 377 
#define DESTROY_off_mult(destroyer_, arg1_, arg2_, c_class_off)\
378 
    {\
 378 
    {\
379 
	c_class *x810_ = CHECK_TAG ( ( c_class_off ), 10 ) ;\
 379 
	c_class *x810_ = CHECK_TAG((c_class_off), 10);\
380 
	( arg1_ ) = DEREF_off ( x810_ + 1 ) ;\
 380 
	(arg1_) = DEREF_off(x810_ + 1);\
381 
	( arg2_ ) = DEREF_exp ( x810_ + 2 ) ;\
 381 
	(arg2_) = DEREF_exp(x810_ + 2);\
382 
	( destroyer_ ) ( x810_, ( unsigned ) 3 ) ;\
 382 
	(destroyer_)(x810_, (unsigned)3);\
383 
    }
 383 
    }
384 
 
 384 
 
385 
 
 385 
 
386 
/* Operations for field ptr_diff of union OFFSET */
 386 
/* Operations for field ptr_diff of union OFFSET */
387 
 
 387 
 
388 
#define off_ptr_diff_tag		( ( unsigned ) 11 )
 388 
#define off_ptr_diff_tag		((unsigned)11)
389 
#define IS_off_ptr_diff( P )		( CHECK_NULL ( P )->ag_tag == 11 )
 389 
#define IS_off_ptr_diff(P)		(CHECK_NULL(P)->ag_tag == 11)
390 
 
 390 
 
391 
#define off_ptr_diff_ptr1( P )		( CHECK_TAG ( ( P ), 11 ) + 1 )
 391 
#define off_ptr_diff_ptr1(P)		(CHECK_TAG((P), 11) + 1)
392 
#define off_ptr_diff_ptr2( P )		( CHECK_TAG ( ( P ), 11 ) + 2 )
 392 
#define off_ptr_diff_ptr2(P)		(CHECK_TAG((P), 11) + 2)
393 
 
 393 
 
394 
#define MAKE_off_ptr_diff( ptr1_, ptr2_, c_class_off )\
 394 
#define MAKE_off_ptr_diff(ptr1_, ptr2_, c_class_off)\
395 
    {\
 395 
    {\
396 
	c_class *x811_ = GEN_c_class ( 3, TYPEID_off ) ;\
 396 
	c_class *x811_ = GEN_c_class(3, TYPEID_off);\
397 
	x811_->ag_tag = 11 ;\
 397 
	x811_->ag_tag = 11;\
398 
	COPY_exp ( x811_ + 1, ( ptr1_ ) ) ;\
 398 
	COPY_exp(x811_ + 1, (ptr1_));\
399 
	COPY_exp ( x811_ + 2, ( ptr2_ ) ) ;\
 399 
	COPY_exp(x811_ + 2, (ptr2_));\
400 
	( c_class_off ) = x811_ ;\
 400 
	(c_class_off) = x811_;\
401 
    }
 401 
    }
402 
 
 402 
 
403 
#define DECONS_off_ptr_diff( ptr1_, ptr2_, c_class_off )\
 403 
#define DECONS_off_ptr_diff(ptr1_, ptr2_, c_class_off)\
404 
    {\
 404 
    {\
405 
	c_class *x812_ = CHECK_TAG ( ( c_class_off ), 11 ) ;\
 405 
	c_class *x812_ = CHECK_TAG((c_class_off), 11);\
406 
	( ptr1_ ) = DEREF_exp ( x812_ + 1 ) ;\
 406 
	(ptr1_) = DEREF_exp(x812_ + 1);\
407 
	( ptr2_ ) = DEREF_exp ( x812_ + 2 ) ;\
 407 
	(ptr2_) = DEREF_exp(x812_ + 2);\
408 
    }
 408 
    }
409 
 
 409 
 
410 
#define DESTROY_off_ptr_diff( destroyer_, ptr1_, ptr2_, c_class_off )\
 410 
#define DESTROY_off_ptr_diff(destroyer_, ptr1_, ptr2_, c_class_off)\
411 
    {\
 411 
    {\
412 
	c_class *x813_ = CHECK_TAG ( ( c_class_off ), 11 ) ;\
 412 
	c_class *x813_ = CHECK_TAG((c_class_off), 11);\
413 
	( ptr1_ ) = DEREF_exp ( x813_ + 1 ) ;\
 413 
	(ptr1_) = DEREF_exp(x813_ + 1);\
414 
	( ptr2_ ) = DEREF_exp ( x813_ + 2 ) ;\
 414 
	(ptr2_) = DEREF_exp(x813_ + 2);\
415 
	( destroyer_ ) ( x813_, ( unsigned ) 3 ) ;\
 415 
	(destroyer_)(x813_, (unsigned)3);\
416 
    }
 416 
    }
417 
 
 417 
 
418 
 
 418 
 
419 
/* Operations for field token of union OFFSET */
 419 
/* Operations for field token of union OFFSET */
420 
 
 420 
 
421 
#define off_token_tag			( ( unsigned ) 12 )
 421 
#define off_token_tag			((unsigned)12)
422 
#define IS_off_token( P )		( CHECK_NULL ( P )->ag_tag == 12 )
 422 
#define IS_off_token(P)			(CHECK_NULL(P)->ag_tag == 12)
423 
 
 423 
 
424 
#define off_token_tok( P )		( CHECK_TAG ( ( P ), 12 ) + 1 )
 424 
#define off_token_tok(P)		(CHECK_TAG((P), 12) + 1)
425 
#define off_token_args( P )		( CHECK_TAG ( ( P ), 12 ) + 2 )
 425 
#define off_token_args(P)		(CHECK_TAG((P), 12) + 2)
426 
 
 426 
 
427 
#define MAKE_off_token( tok_, args_, c_class_off )\
 427 
#define MAKE_off_token(tok_, args_, c_class_off)\
428 
    {\
 428 
    {\
429 
	c_class *x814_ = GEN_c_class ( 3, TYPEID_off ) ;\
 429 
	c_class *x814_ = GEN_c_class(3, TYPEID_off);\
430 
	x814_->ag_tag = 12 ;\
 430 
	x814_->ag_tag = 12;\
431 
	COPY_id ( x814_ + 1, ( tok_ ) ) ;\
 431 
	COPY_id(x814_ + 1, (tok_));\
432 
	COPY_list ( x814_ + 2, ( args_ ) ) ;\
 432 
	COPY_list(x814_ + 2, (args_));\
433 
	( c_class_off ) = x814_ ;\
 433 
	(c_class_off) = x814_;\
434 
    }
 434 
    }
435 
 
 435 
 
436 
#define DECONS_off_token( tok_, args_, c_class_off )\
 436 
#define DECONS_off_token(tok_, args_, c_class_off)\
437 
    {\
 437 
    {\
438 
	c_class *x815_ = CHECK_TAG ( ( c_class_off ), 12 ) ;\
 438 
	c_class *x815_ = CHECK_TAG((c_class_off), 12);\
439 
	( tok_ ) = DEREF_id ( x815_ + 1 ) ;\
 439 
	(tok_) = DEREF_id(x815_ + 1);\
440 
	( args_ ) = DEREF_list ( x815_ + 2 ) ;\
 440 
	(args_) = DEREF_list(x815_ + 2);\
441 
    }
 441 
    }
442 
 
 442 
 
443 
#define DESTROY_off_token( destroyer_, tok_, args_, c_class_off )\
 443 
#define DESTROY_off_token(destroyer_, tok_, args_, c_class_off)\
444 
    {\
 444 
    {\
445 
	c_class *x816_ = CHECK_TAG ( ( c_class_off ), 12 ) ;\
 445 
	c_class *x816_ = CHECK_TAG((c_class_off), 12);\
446 
	( tok_ ) = DEREF_id ( x816_ + 1 ) ;\
 446 
	(tok_) = DEREF_id(x816_ + 1);\
447 
	( args_ ) = DEREF_list ( x816_ + 2 ) ;\
 447 
	(args_) = DEREF_list(x816_ + 2);\
448 
	( destroyer_ ) ( x816_, ( unsigned ) 3 ) ;\
 448 
	(destroyer_)(x816_, (unsigned)3);\
449 
    }
 449 
    }
450 
 
 450 
 
451 
 
 451 
 
452 
#endif
 452 
#endif