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 size of union TYPE */
 43 
/* Operations for component size of union TYPE */
44 
 
 44 
 
45 
#define type_size( P )			( CHECK_NULL ( P ) + 1 )
 45 
#define type_size(P)			(CHECK_NULL(P) + 1)
46 
 
 46 
 
47 
 
 47 
 
48 
/* Operations for field primitive of union TYPE */
 48 
/* Operations for field primitive of union TYPE */
49 
 
 49 
 
50 
#define type_primitive_tag		( ( unsigned ) 0 )
 50 
#define type_primitive_tag		((unsigned)0)
51 
#define IS_type_primitive( P )		( CHECK_NULL ( P )->ag_tag == 0 )
 51 
#define IS_type_primitive(P)		(CHECK_NULL(P)->ag_tag == 0)
52 
 
 52 
 
53 
#define type_primitive_prim( P )	( CHECK_TAG ( ( P ), 0 ) + 2 )
 53 
#define type_primitive_prim(P)		(CHECK_TAG((P), 0) + 2)
54 
 
 54 
 
55 
#define MAKE_type_primitive( size_, prim_, calculus_type )\
 55 
#define MAKE_type_primitive(size_, prim_, calculus_type)\
56 
    {\
 56 
    {\
57 
	calculus *x136_ = GEN_calculus ( 4, TYPEID_type ) ;\
 57 
	calculus *x136_ = GEN_calculus(4, TYPEID_type);\
58 
	x136_->ag_tag = 0 ;\
 58 
	x136_->ag_tag = 0;\
59 
	COPY_int ( x136_ + 1, ( size_ ) ) ;\
 59 
	COPY_int(x136_ + 1, (size_));\
60 
	COPY_ptr ( x136_ + 2, ( prim_ ) ) ;\
 60 
	COPY_ptr(x136_ + 2, (prim_));\
61 
	x136_ [3].ag_tag = 0 ;\
 61 
	x136_[3].ag_tag = 0;\
62 
	( calculus_type ) = x136_ ;\
 62 
	(calculus_type) = x136_;\
63 
    }
 63 
    }
64 
 
 64 
 
65 
#define DECONS_type_primitive( size_, prim_, calculus_type )\
 65 
#define DECONS_type_primitive(size_, prim_, calculus_type)\
66 
    {\
 66 
    {\
67 
	calculus *x137_ = CHECK_TAG ( ( calculus_type ), 0 ) ;\
 67 
	calculus *x137_ = CHECK_TAG((calculus_type), 0);\
68 
	( size_ ) = DEREF_int ( x137_ + 1 ) ;\
 68 
	(size_) = DEREF_int(x137_ + 1);\
69 
	( prim_ ) = DEREF_ptr ( x137_ + 2 ) ;\
 69 
	(prim_) = DEREF_ptr(x137_ + 2);\
70 
    }
 70 
    }
71 
 
 71 
 
72 
#define DESTROY_type_primitive( destroyer_, size_, prim_, calculus_type )\
 72 
#define DESTROY_type_primitive(destroyer_, size_, prim_, calculus_type)\
73 
    {\
 73 
    {\
74 
	calculus *x138_ = CHECK_TAG ( ( calculus_type ), 0 ) ;\
 74 
	calculus *x138_ = CHECK_TAG((calculus_type), 0);\
75 
	( size_ ) = DEREF_int ( x138_ + 1 ) ;\
 75 
	(size_) = DEREF_int(x138_ + 1);\
76 
	( prim_ ) = DEREF_ptr ( x138_ + 2 ) ;\
 76 
	(prim_) = DEREF_ptr(x138_ + 2);\
77 
	( destroyer_ ) ( x138_, ( unsigned ) 4 ) ;\
 77 
	(destroyer_)(x138_, (unsigned)4);\
78 
    }
 78 
    }
79 
 
 79 
 
80 
#ifdef calculus_IO_ROUTINES
 80 
#ifdef calculus_IO_ROUTINES
81 
 
 81 
 
82 
#define NEW_ALIAS_type_primitive( P, N )\
 82 
#define NEW_ALIAS_type_primitive(P, N)\
83 
    {\
 83 
    {\
84 
	calculus *x139_ = GEN_calculus ( 4, TYPEID_list ) ;\
 84 
	calculus *x139_ = GEN_calculus(4, TYPEID_list);\
85 
	unsigned a139_ = ( N ) ;\
 85 
	unsigned a139_ = (N);\
86 
	x139_->ag_tag = 0 ;\
 86 
	x139_->ag_tag = 0;\
87 
	x139_ [3].ag_tag = a139_ ;\
 87 
	x139_[3].ag_tag = a139_;\
88 
	set_calculus_alias ( x139_ + 3, a139_ ) ;\
 88 
	set_calculus_alias(x139_ + 3, a139_);\
89 
	( P ) = x139_ ;\
 89 
	(P) = x139_;\
90 
    }
 90 
    }
91 
 
 91 
 
92 
#define GET_ALIAS_type_primitive( P )	( ( CHECK_NULL ( P ) + 3 )->ag_tag )
 92 
#define GET_ALIAS_type_primitive(P)	((CHECK_NULL(P) + 3)->ag_tag)
93 
#define SET_ALIAS_type_primitive( P, N )set_calculus_alias ( CHECK_NULL ( P ) + 3, ( N ) )
 93 
#define SET_ALIAS_type_primitive(P, N)	set_calculus_alias(CHECK_NULL(P) + 3, (N))
94 
#define FIND_ALIAS_type_primitive( N )	( find_calculus_alias ( N ) - 3 )
 94 
#define FIND_ALIAS_type_primitive(N)	(find_calculus_alias(N) - 3)
95 
 
 95 
 
96 
#endif
 96 
#endif
97 
 
 97 
 
98 
 
 98 
 
99 
/* Operations for field ident of union TYPE */
 99 
/* Operations for field ident of union TYPE */
100 
 
 100 
 
101 
#define type_ident_tag			( ( unsigned ) 1 )
 101 
#define type_ident_tag			((unsigned)1)
102 
#define IS_type_ident( P )		( CHECK_NULL ( P )->ag_tag == 1 )
 102 
#define IS_type_ident(P)		(CHECK_NULL(P)->ag_tag == 1)
103 
 
 103 
 
104 
#define type_ident_id( P )		( CHECK_TAG ( ( P ), 1 ) + 2 )
 104 
#define type_ident_id(P)		(CHECK_TAG((P), 1) + 2)
105 
 
 105 
 
106 
#define MAKE_type_ident( size_, id_, calculus_type )\
 106 
#define MAKE_type_ident(size_, id_, calculus_type)\
107 
    {\
 107 
    {\
108 
	calculus *x140_ = GEN_calculus ( 4, TYPEID_type ) ;\
 108 
	calculus *x140_ = GEN_calculus(4, TYPEID_type);\
109 
	x140_->ag_tag = 1 ;\
 109 
	x140_->ag_tag = 1;\
110 
	COPY_int ( x140_ + 1, ( size_ ) ) ;\
 110 
	COPY_int(x140_ + 1, (size_));\
111 
	COPY_ptr ( x140_ + 2, ( id_ ) ) ;\
 111 
	COPY_ptr(x140_ + 2, (id_));\
112 
	x140_ [3].ag_tag = 0 ;\
 112 
	x140_[3].ag_tag = 0;\
113 
	( calculus_type ) = x140_ ;\
 113 
	(calculus_type) = x140_;\
114 
    }
 114 
    }
115 
 
 115 
 
116 
#define DECONS_type_ident( size_, id_, calculus_type )\
 116 
#define DECONS_type_ident(size_, id_, calculus_type)\
117 
    {\
 117 
    {\
118 
	calculus *x141_ = CHECK_TAG ( ( calculus_type ), 1 ) ;\
 118 
	calculus *x141_ = CHECK_TAG((calculus_type), 1);\
119 
	( size_ ) = DEREF_int ( x141_ + 1 ) ;\
 119 
	(size_) = DEREF_int(x141_ + 1);\
120 
	( id_ ) = DEREF_ptr ( x141_ + 2 ) ;\
 120 
	(id_) = DEREF_ptr(x141_ + 2);\
121 
    }
 121 
    }
122 
 
 122 
 
123 
#define DESTROY_type_ident( destroyer_, size_, id_, calculus_type )\
 123 
#define DESTROY_type_ident(destroyer_, size_, id_, calculus_type)\
124 
    {\
 124 
    {\
125 
	calculus *x142_ = CHECK_TAG ( ( calculus_type ), 1 ) ;\
 125 
	calculus *x142_ = CHECK_TAG((calculus_type), 1);\
126 
	( size_ ) = DEREF_int ( x142_ + 1 ) ;\
 126 
	(size_) = DEREF_int(x142_ + 1);\
127 
	( id_ ) = DEREF_ptr ( x142_ + 2 ) ;\
 127 
	(id_) = DEREF_ptr(x142_ + 2);\
128 
	( destroyer_ ) ( x142_, ( unsigned ) 4 ) ;\
 128 
	(destroyer_)(x142_, (unsigned)4);\
129 
    }
 129 
    }
130 
 
 130 
 
131 
#ifdef calculus_IO_ROUTINES
 131 
#ifdef calculus_IO_ROUTINES
132 
 
 132 
 
133 
#define NEW_ALIAS_type_ident( P, N )\
 133 
#define NEW_ALIAS_type_ident(P, N)\
134 
    {\
 134 
    {\
135 
	calculus *x143_ = GEN_calculus ( 4, TYPEID_list ) ;\
 135 
	calculus *x143_ = GEN_calculus(4, TYPEID_list);\
136 
	unsigned a143_ = ( N ) ;\
 136 
	unsigned a143_ = (N);\
137 
	x143_->ag_tag = 1 ;\
 137 
	x143_->ag_tag = 1;\
138 
	x143_ [3].ag_tag = a143_ ;\
 138 
	x143_[3].ag_tag = a143_;\
139 
	set_calculus_alias ( x143_ + 3, a143_ ) ;\
 139 
	set_calculus_alias(x143_ + 3, a143_);\
140 
	( P ) = x143_ ;\
 140 
	(P) = x143_;\
141 
    }
 141 
    }
142 
 
 142 
 
143 
#define GET_ALIAS_type_ident( P )	( ( CHECK_NULL ( P ) + 3 )->ag_tag )
 143 
#define GET_ALIAS_type_ident(P)		((CHECK_NULL(P) + 3)->ag_tag)
144 
#define SET_ALIAS_type_ident( P, N )	set_calculus_alias ( CHECK_NULL ( P ) + 3, ( N ) )
 144 
#define SET_ALIAS_type_ident(P, N)	set_calculus_alias(CHECK_NULL(P) + 3, (N))
145 
#define FIND_ALIAS_type_ident( N )	( find_calculus_alias ( N ) - 3 )
 145 
#define FIND_ALIAS_type_ident(N)	(find_calculus_alias(N) - 3)
146 
 
 146 
 
147 
#endif
 147 
#endif
148 
 
 148 
 
149 
 
 149 
 
150 
/* Operations for field enumeration of union TYPE */
 150 
/* Operations for field enumeration of union TYPE */
151 
 
 151 
 
152 
#define type_enumeration_tag		( ( unsigned ) 2 )
 152 
#define type_enumeration_tag		((unsigned)2)
153 
#define IS_type_enumeration( P )	( CHECK_NULL ( P )->ag_tag == 2 )
 153 
#define IS_type_enumeration(P)		(CHECK_NULL(P)->ag_tag == 2)
154 
 
 154 
 
155 
#define type_enumeration_en( P )	( CHECK_TAG ( ( P ), 2 ) + 2 )
 155 
#define type_enumeration_en(P)		(CHECK_TAG((P), 2) + 2)
156 
 
 156 
 
157 
#define MAKE_type_enumeration( size_, en_, calculus_type )\
 157 
#define MAKE_type_enumeration(size_, en_, calculus_type)\
158 
    {\
 158 
    {\
159 
	calculus *x144_ = GEN_calculus ( 4, TYPEID_type ) ;\
 159 
	calculus *x144_ = GEN_calculus(4, TYPEID_type);\
160 
	x144_->ag_tag = 2 ;\
 160 
	x144_->ag_tag = 2;\
161 
	COPY_int ( x144_ + 1, ( size_ ) ) ;\
 161 
	COPY_int(x144_ + 1, (size_));\
162 
	COPY_ptr ( x144_ + 2, ( en_ ) ) ;\
 162 
	COPY_ptr(x144_ + 2, (en_));\
163 
	x144_ [3].ag_tag = 0 ;\
 163 
	x144_[3].ag_tag = 0;\
164 
	( calculus_type ) = x144_ ;\
 164 
	(calculus_type) = x144_;\
165 
    }
 165 
    }
166 
 
 166 
 
167 
#define DECONS_type_enumeration( size_, en_, calculus_type )\
 167 
#define DECONS_type_enumeration(size_, en_, calculus_type)\
168 
    {\
 168 
    {\
169 
	calculus *x145_ = CHECK_TAG ( ( calculus_type ), 2 ) ;\
 169 
	calculus *x145_ = CHECK_TAG((calculus_type), 2);\
170 
	( size_ ) = DEREF_int ( x145_ + 1 ) ;\
 170 
	(size_) = DEREF_int(x145_ + 1);\
171 
	( en_ ) = DEREF_ptr ( x145_ + 2 ) ;\
 171 
	(en_) = DEREF_ptr(x145_ + 2);\
172 
    }
 172 
    }
173 
 
 173 
 
174 
#define DESTROY_type_enumeration( destroyer_, size_, en_, calculus_type )\
 174 
#define DESTROY_type_enumeration(destroyer_, size_, en_, calculus_type)\
175 
    {\
 175 
    {\
176 
	calculus *x146_ = CHECK_TAG ( ( calculus_type ), 2 ) ;\
 176 
	calculus *x146_ = CHECK_TAG((calculus_type), 2);\
177 
	( size_ ) = DEREF_int ( x146_ + 1 ) ;\
 177 
	(size_) = DEREF_int(x146_ + 1);\
178 
	( en_ ) = DEREF_ptr ( x146_ + 2 ) ;\
 178 
	(en_) = DEREF_ptr(x146_ + 2);\
179 
	( destroyer_ ) ( x146_, ( unsigned ) 4 ) ;\
 179 
	(destroyer_)(x146_, (unsigned)4);\
180 
    }
 180 
    }
181 
 
 181 
 
182 
#ifdef calculus_IO_ROUTINES
 182 
#ifdef calculus_IO_ROUTINES
183 
 
 183 
 
184 
#define NEW_ALIAS_type_enumeration( P, N )\
 184 
#define NEW_ALIAS_type_enumeration(P, N)\
185 
    {\
 185 
    {\
186 
	calculus *x147_ = GEN_calculus ( 4, TYPEID_list ) ;\
 186 
	calculus *x147_ = GEN_calculus(4, TYPEID_list);\
187 
	unsigned a147_ = ( N ) ;\
 187 
	unsigned a147_ = (N);\
188 
	x147_->ag_tag = 2 ;\
 188 
	x147_->ag_tag = 2;\
189 
	x147_ [3].ag_tag = a147_ ;\
 189 
	x147_[3].ag_tag = a147_;\
190 
	set_calculus_alias ( x147_ + 3, a147_ ) ;\
 190 
	set_calculus_alias(x147_ + 3, a147_);\
191 
	( P ) = x147_ ;\
 191 
	(P) = x147_;\
192 
    }
 192 
    }
193 
 
 193 
 
194 
#define GET_ALIAS_type_enumeration( P )	( ( CHECK_NULL ( P ) + 3 )->ag_tag )
 194 
#define GET_ALIAS_type_enumeration(P)	((CHECK_NULL(P) + 3)->ag_tag)
195 
#define SET_ALIAS_type_enumeration( P, N )set_calculus_alias ( CHECK_NULL ( P ) + 3, ( N ) )
 195 
#define SET_ALIAS_type_enumeration(P, N)set_calculus_alias(CHECK_NULL(P) + 3, (N))
196 
#define FIND_ALIAS_type_enumeration( N )( find_calculus_alias ( N ) - 3 )
 196 
#define FIND_ALIAS_type_enumeration(N)	(find_calculus_alias(N) - 3)
197 
 
 197 
 
198 
#endif
 198 
#endif
199 
 
 199 
 
200 
 
 200 
 
201 
/* Operations for field structure of union TYPE */
 201 
/* Operations for field structure of union TYPE */
202 
 
 202 
 
203 
#define type_structure_tag		( ( unsigned ) 3 )
 203 
#define type_structure_tag		((unsigned)3)
204 
#define IS_type_structure( P )		( CHECK_NULL ( P )->ag_tag == 3 )
 204 
#define IS_type_structure(P)		(CHECK_NULL(P)->ag_tag == 3)
205 
 
 205 
 
206 
#define type_structure_struc( P )	( CHECK_TAG ( ( P ), 3 ) + 2 )
 206 
#define type_structure_struc(P)		(CHECK_TAG((P), 3) + 2)
207 
 
 207 
 
208 
#define MAKE_type_structure( size_, struc_, calculus_type )\
 208 
#define MAKE_type_structure(size_, struc_, calculus_type)\
209 
    {\
 209 
    {\
210 
	calculus *x148_ = GEN_calculus ( 4, TYPEID_type ) ;\
 210 
	calculus *x148_ = GEN_calculus(4, TYPEID_type);\
211 
	x148_->ag_tag = 3 ;\
 211 
	x148_->ag_tag = 3;\
212 
	COPY_int ( x148_ + 1, ( size_ ) ) ;\
 212 
	COPY_int(x148_ + 1, (size_));\
213 
	COPY_ptr ( x148_ + 2, ( struc_ ) ) ;\
 213 
	COPY_ptr(x148_ + 2, (struc_));\
214 
	x148_ [3].ag_tag = 0 ;\
 214 
	x148_[3].ag_tag = 0;\
215 
	( calculus_type ) = x148_ ;\
 215 
	(calculus_type) = x148_;\
216 
    }
 216 
    }
217 
 
 217 
 
218 
#define DECONS_type_structure( size_, struc_, calculus_type )\
 218 
#define DECONS_type_structure(size_, struc_, calculus_type)\
219 
    {\
 219 
    {\
220 
	calculus *x149_ = CHECK_TAG ( ( calculus_type ), 3 ) ;\
 220 
	calculus *x149_ = CHECK_TAG((calculus_type), 3);\
221 
	( size_ ) = DEREF_int ( x149_ + 1 ) ;\
 221 
	(size_) = DEREF_int(x149_ + 1);\
222 
	( struc_ ) = DEREF_ptr ( x149_ + 2 ) ;\
 222 
	(struc_) = DEREF_ptr(x149_ + 2);\
223 
    }
 223 
    }
224 
 
 224 
 
225 
#define DESTROY_type_structure( destroyer_, size_, struc_, calculus_type )\
 225 
#define DESTROY_type_structure(destroyer_, size_, struc_, calculus_type)\
226 
    {\
 226 
    {\
227 
	calculus *x150_ = CHECK_TAG ( ( calculus_type ), 3 ) ;\
 227 
	calculus *x150_ = CHECK_TAG((calculus_type), 3);\
228 
	( size_ ) = DEREF_int ( x150_ + 1 ) ;\
 228 
	(size_) = DEREF_int(x150_ + 1);\
229 
	( struc_ ) = DEREF_ptr ( x150_ + 2 ) ;\
 229 
	(struc_) = DEREF_ptr(x150_ + 2);\
230 
	( destroyer_ ) ( x150_, ( unsigned ) 4 ) ;\
 230 
	(destroyer_)(x150_, (unsigned)4);\
231 
    }
 231 
    }
232 
 
 232 
 
233 
#ifdef calculus_IO_ROUTINES
 233 
#ifdef calculus_IO_ROUTINES
234 
 
 234 
 
235 
#define NEW_ALIAS_type_structure( P, N )\
 235 
#define NEW_ALIAS_type_structure(P, N)\
236 
    {\
 236 
    {\
237 
	calculus *x151_ = GEN_calculus ( 4, TYPEID_list ) ;\
 237 
	calculus *x151_ = GEN_calculus(4, TYPEID_list);\
238 
	unsigned a151_ = ( N ) ;\
 238 
	unsigned a151_ = (N);\
239 
	x151_->ag_tag = 3 ;\
 239 
	x151_->ag_tag = 3;\
240 
	x151_ [3].ag_tag = a151_ ;\
 240 
	x151_[3].ag_tag = a151_;\
241 
	set_calculus_alias ( x151_ + 3, a151_ ) ;\
 241 
	set_calculus_alias(x151_ + 3, a151_);\
242 
	( P ) = x151_ ;\
 242 
	(P) = x151_;\
243 
    }
 243 
    }
244 
 
 244 
 
245 
#define GET_ALIAS_type_structure( P )	( ( CHECK_NULL ( P ) + 3 )->ag_tag )
 245 
#define GET_ALIAS_type_structure(P)	((CHECK_NULL(P) + 3)->ag_tag)
246 
#define SET_ALIAS_type_structure( P, N )set_calculus_alias ( CHECK_NULL ( P ) + 3, ( N ) )
 246 
#define SET_ALIAS_type_structure(P, N)	set_calculus_alias(CHECK_NULL(P) + 3, (N))
247 
#define FIND_ALIAS_type_structure( N )	( find_calculus_alias ( N ) - 3 )
 247 
#define FIND_ALIAS_type_structure(N)	(find_calculus_alias(N) - 3)
248 
 
 248 
 
249 
#endif
 249 
#endif
250 
 
 250 
 
251 
 
 251 
 
252 
/* Operations for field onion of union TYPE */
 252 
/* Operations for field onion of union TYPE */
253 
 
 253 
 
254 
#define type_onion_tag			( ( unsigned ) 4 )
 254 
#define type_onion_tag			((unsigned)4)
255 
#define IS_type_onion( P )		( CHECK_NULL ( P )->ag_tag == 4 )
 255 
#define IS_type_onion(P)		(CHECK_NULL(P)->ag_tag == 4)
256 
 
 256 
 
257 
#define type_onion_un( P )		( CHECK_TAG ( ( P ), 4 ) + 2 )
 257 
#define type_onion_un(P)		(CHECK_TAG((P), 4) + 2)
258 
 
 258 
 
259 
#define MAKE_type_onion( size_, un_, calculus_type )\
 259 
#define MAKE_type_onion(size_, un_, calculus_type)\
260 
    {\
 260 
    {\
261 
	calculus *x152_ = GEN_calculus ( 4, TYPEID_type ) ;\
 261 
	calculus *x152_ = GEN_calculus(4, TYPEID_type);\
262 
	x152_->ag_tag = 4 ;\
 262 
	x152_->ag_tag = 4;\
263 
	COPY_int ( x152_ + 1, ( size_ ) ) ;\
 263 
	COPY_int(x152_ + 1, (size_));\
264 
	COPY_ptr ( x152_ + 2, ( un_ ) ) ;\
 264 
	COPY_ptr(x152_ + 2, (un_));\
265 
	x152_ [3].ag_tag = 0 ;\
 265 
	x152_[3].ag_tag = 0;\
266 
	( calculus_type ) = x152_ ;\
 266 
	(calculus_type) = x152_;\
267 
    }
 267 
    }
268 
 
 268 
 
269 
#define DECONS_type_onion( size_, un_, calculus_type )\
 269 
#define DECONS_type_onion(size_, un_, calculus_type)\
270 
    {\
 270 
    {\
271 
	calculus *x153_ = CHECK_TAG ( ( calculus_type ), 4 ) ;\
 271 
	calculus *x153_ = CHECK_TAG((calculus_type), 4);\
272 
	( size_ ) = DEREF_int ( x153_ + 1 ) ;\
 272 
	(size_) = DEREF_int(x153_ + 1);\
273 
	( un_ ) = DEREF_ptr ( x153_ + 2 ) ;\
 273 
	(un_) = DEREF_ptr(x153_ + 2);\
274 
    }
 274 
    }
275 
 
 275 
 
276 
#define DESTROY_type_onion( destroyer_, size_, un_, calculus_type )\
 276 
#define DESTROY_type_onion(destroyer_, size_, un_, calculus_type)\
277 
    {\
 277 
    {\
278 
	calculus *x154_ = CHECK_TAG ( ( calculus_type ), 4 ) ;\
 278 
	calculus *x154_ = CHECK_TAG((calculus_type), 4);\
279 
	( size_ ) = DEREF_int ( x154_ + 1 ) ;\
 279 
	(size_) = DEREF_int(x154_ + 1);\
280 
	( un_ ) = DEREF_ptr ( x154_ + 2 ) ;\
 280 
	(un_) = DEREF_ptr(x154_ + 2);\
281 
	( destroyer_ ) ( x154_, ( unsigned ) 4 ) ;\
 281 
	(destroyer_)(x154_, (unsigned)4);\
282 
    }
 282 
    }
283 
 
 283 
 
284 
#ifdef calculus_IO_ROUTINES
 284 
#ifdef calculus_IO_ROUTINES
285 
 
 285 
 
286 
#define NEW_ALIAS_type_onion( P, N )\
 286 
#define NEW_ALIAS_type_onion(P, N)\
287 
    {\
 287 
    {\
288 
	calculus *x155_ = GEN_calculus ( 4, TYPEID_list ) ;\
 288 
	calculus *x155_ = GEN_calculus(4, TYPEID_list);\
289 
	unsigned a155_ = ( N ) ;\
 289 
	unsigned a155_ = (N);\
290 
	x155_->ag_tag = 4 ;\
 290 
	x155_->ag_tag = 4;\
291 
	x155_ [3].ag_tag = a155_ ;\
 291 
	x155_[3].ag_tag = a155_;\
292 
	set_calculus_alias ( x155_ + 3, a155_ ) ;\
 292 
	set_calculus_alias(x155_ + 3, a155_);\
293 
	( P ) = x155_ ;\
 293 
	(P) = x155_;\
294 
    }
 294 
    }
295 
 
 295 
 
296 
#define GET_ALIAS_type_onion( P )	( ( CHECK_NULL ( P ) + 3 )->ag_tag )
 296 
#define GET_ALIAS_type_onion(P)		((CHECK_NULL(P) + 3)->ag_tag)
297 
#define SET_ALIAS_type_onion( P, N )	set_calculus_alias ( CHECK_NULL ( P ) + 3, ( N ) )
 297 
#define SET_ALIAS_type_onion(P, N)	set_calculus_alias(CHECK_NULL(P) + 3, (N))
298 
#define FIND_ALIAS_type_onion( N )	( find_calculus_alias ( N ) - 3 )
 298 
#define FIND_ALIAS_type_onion(N)	(find_calculus_alias(N) - 3)
299 
 
 299 
 
300 
#endif
 300 
#endif
301 
 
 301 
 
302 
 
 302 
 
303 
/* Operations for field set ptr_etc of union TYPE */
 303 
/* Operations for field set ptr_etc of union TYPE */
304 
 
 304 
 
305 
#define type_ptr_etc_tag		( ( unsigned ) 10 )
 305 
#define type_ptr_etc_tag		((unsigned)10)
306 
#define IS_type_ptr_etc( P )		( ( unsigned ) ( CHECK_NULL ( P )->ag_tag - 5 ) < ( unsigned ) 5 )
 306 
#define IS_type_ptr_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 5) < (unsigned)5)
307 
 
 307 
 
308 
#define type_ptr_etc_sub( P )		( CHECK_TAG_ETC ( ( P ), 5, 10 ) + 2 )
 308 
#define type_ptr_etc_sub(P)		(CHECK_TAG_ETC((P), 5, 10) + 2)
309 
 
 309 
 
310 
#define MAKE_type_ptr_etc( tag, size_, sub_, calculus_type )\
 310 
#define MAKE_type_ptr_etc(tag, size_, sub_, calculus_type)\
311 
    {\
 311 
    {\
312 
	calculus *x156_ = GEN_calculus ( 4, TYPEID_type ) ;\
 312 
	calculus *x156_ = GEN_calculus(4, TYPEID_type);\
313 
	x156_->ag_tag = ( tag ) ;\
 313 
	x156_->ag_tag = (tag);\
314 
	COPY_int ( x156_ + 1, ( size_ ) ) ;\
 314 
	COPY_int(x156_ + 1, (size_));\
315 
	COPY_ptr ( x156_ + 2, ( sub_ ) ) ;\
 315 
	COPY_ptr(x156_ + 2, (sub_));\
316 
	x156_ [3].ag_tag = 0 ;\
 316 
	x156_[3].ag_tag = 0;\
317 
	( calculus_type ) = CHECK_TAG_ETC ( x156_, 5, 10 ) ;\
 317 
	(calculus_type) = CHECK_TAG_ETC(x156_, 5, 10);\
318 
    }
 318 
    }
319 
 
 319 
 
320 
#define MODIFY_type_ptr_etc( tag, calculus_type )\
 320 
#define MODIFY_type_ptr_etc(tag, calculus_type)\
321 
    {\
 321 
    {\
322 
	calculus *x157_ = CHECK_TAG_ETC ( ( calculus_type ), 5, 10 ) ;\
 322 
	calculus *x157_ = CHECK_TAG_ETC ((calculus_type), 5, 10);\
323 
	x157_->ag_tag = ( tag ) ;\
 323 
	x157_->ag_tag = (tag);\
324 
	( void ) CHECK_TAG_ETC ( x157_, 5, 10 ) ;\
 324 
	(void) CHECK_TAG_ETC (x157_, 5, 10);\
325 
    }
 325 
    }
326 
 
 326 
 
327 
#define DECONS_type_ptr_etc( size_, sub_, calculus_type )\
 327 
#define DECONS_type_ptr_etc(size_, sub_, calculus_type)\
328 
    {\
 328 
    {\
329 
	calculus *x158_ = CHECK_TAG_ETC ( ( calculus_type ), 5, 10 ) ;\
 329 
	calculus *x158_ = CHECK_TAG_ETC((calculus_type), 5, 10);\
330 
	( size_ ) = DEREF_int ( x158_ + 1 ) ;\
 330 
	(size_) = DEREF_int(x158_ + 1);\
331 
	( sub_ ) = DEREF_ptr ( x158_ + 2 ) ;\
 331 
	(sub_) = DEREF_ptr(x158_ + 2);\
332 
    }
 332 
    }
333 
 
 333 
 
334 
#define DESTROY_type_ptr_etc( destroyer_, size_, sub_, calculus_type )\
 334 
#define DESTROY_type_ptr_etc(destroyer_, size_, sub_, calculus_type)\
335 
    {\
 335 
    {\
336 
	calculus *x159_ = CHECK_TAG_ETC ( ( calculus_type ), 5, 10 ) ;\
 336 
	calculus *x159_ = CHECK_TAG_ETC((calculus_type), 5, 10);\
337 
	( size_ ) = DEREF_int ( x159_ + 1 ) ;\
 337 
	(size_) = DEREF_int(x159_ + 1);\
338 
	( sub_ ) = DEREF_ptr ( x159_ + 2 ) ;\
 338 
	(sub_) = DEREF_ptr(x159_ + 2);\
339 
	( destroyer_ ) ( x159_, ( unsigned ) 4 ) ;\
 339 
	(destroyer_)(x159_, (unsigned)4);\
340 
    }
 340 
    }
341 
 
 341 
 
342 
 
 342 
 
343 
/* Operations for field ptr of union TYPE */
 343 
/* Operations for field ptr of union TYPE */
344 
 
 344 
 
345 
#define type_ptr_tag			( ( unsigned ) 5 )
 345 
#define type_ptr_tag			((unsigned)5)
346 
#define IS_type_ptr( P )		( CHECK_NULL ( P )->ag_tag == 5 )
 346 
#define IS_type_ptr(P)			(CHECK_NULL(P)->ag_tag == 5)
347 
 
 347 
 
348 
#define type_ptr_sub( P )		( CHECK_TAG ( ( P ), 5 ) + 2 )
 348 
#define type_ptr_sub(P)			(CHECK_TAG((P), 5) + 2)
349 
 
 349 
 
350 
#define MAKE_type_ptr( size_, sub_, calculus_type )\
 350 
#define MAKE_type_ptr(size_, sub_, calculus_type)\
351 
    {\
 351 
    {\
352 
	calculus *x160_ = GEN_calculus ( 4, TYPEID_type ) ;\
 352 
	calculus *x160_ = GEN_calculus(4, TYPEID_type);\
353 
	x160_->ag_tag = 5 ;\
 353 
	x160_->ag_tag = 5;\
354 
	COPY_int ( x160_ + 1, ( size_ ) ) ;\
 354 
	COPY_int(x160_ + 1, (size_));\
355 
	COPY_ptr ( x160_ + 2, ( sub_ ) ) ;\
 355 
	COPY_ptr(x160_ + 2, (sub_));\
356 
	x160_ [3].ag_tag = 0 ;\
 356 
	x160_[3].ag_tag = 0;\
357 
	( calculus_type ) = x160_ ;\
 357 
	(calculus_type) = x160_;\
358 
    }
 358 
    }
359 
 
 359 
 
360 
#define DECONS_type_ptr( size_, sub_, calculus_type )\
 360 
#define DECONS_type_ptr(size_, sub_, calculus_type)\
361 
    {\
 361 
    {\
362 
	calculus *x161_ = CHECK_TAG ( ( calculus_type ), 5 ) ;\
 362 
	calculus *x161_ = CHECK_TAG((calculus_type), 5);\
363 
	( size_ ) = DEREF_int ( x161_ + 1 ) ;\
 363 
	(size_) = DEREF_int(x161_ + 1);\
364 
	( sub_ ) = DEREF_ptr ( x161_ + 2 ) ;\
 364 
	(sub_) = DEREF_ptr(x161_ + 2);\
365 
    }
 365 
    }
366 
 
 366 
 
367 
#define DESTROY_type_ptr( destroyer_, size_, sub_, calculus_type )\
 367 
#define DESTROY_type_ptr(destroyer_, size_, sub_, calculus_type)\
368 
    {\
 368 
    {\
369 
	calculus *x162_ = CHECK_TAG ( ( calculus_type ), 5 ) ;\
 369 
	calculus *x162_ = CHECK_TAG((calculus_type), 5);\
370 
	( size_ ) = DEREF_int ( x162_ + 1 ) ;\
 370 
	(size_) = DEREF_int(x162_ + 1);\
371 
	( sub_ ) = DEREF_ptr ( x162_ + 2 ) ;\
 371 
	(sub_) = DEREF_ptr(x162_ + 2);\
372 
	( destroyer_ ) ( x162_, ( unsigned ) 4 ) ;\
 372 
	(destroyer_)(x162_, (unsigned)4);\
373 
    }
 373 
    }
374 
 
 374 
 
375 
#ifdef calculus_IO_ROUTINES
 375 
#ifdef calculus_IO_ROUTINES
376 
 
 376 
 
377 
#define NEW_ALIAS_type_ptr( P, N )\
 377 
#define NEW_ALIAS_type_ptr(P, N)\
378 
    {\
 378 
    {\
379 
	calculus *x163_ = GEN_calculus ( 4, TYPEID_list ) ;\
 379 
	calculus *x163_ = GEN_calculus(4, TYPEID_list);\
380 
	unsigned a163_ = ( N ) ;\
 380 
	unsigned a163_ = (N);\
381 
	x163_->ag_tag = 5 ;\
 381 
	x163_->ag_tag = 5;\
382 
	x163_ [3].ag_tag = a163_ ;\
 382 
	x163_[3].ag_tag = a163_;\
383 
	set_calculus_alias ( x163_ + 3, a163_ ) ;\
 383 
	set_calculus_alias(x163_ + 3, a163_);\
384 
	( P ) = x163_ ;\
 384 
	(P) = x163_;\
385 
    }
 385 
    }
386 
 
 386 
 
387 
#define GET_ALIAS_type_ptr( P )		( ( CHECK_NULL ( P ) + 3 )->ag_tag )
 387 
#define GET_ALIAS_type_ptr(P)		((CHECK_NULL(P) + 3)->ag_tag)
388 
#define SET_ALIAS_type_ptr( P, N )	set_calculus_alias ( CHECK_NULL ( P ) + 3, ( N ) )
 388 
#define SET_ALIAS_type_ptr(P, N)	set_calculus_alias(CHECK_NULL(P) + 3, (N))
389 
#define FIND_ALIAS_type_ptr( N )	( find_calculus_alias ( N ) - 3 )
 389 
#define FIND_ALIAS_type_ptr(N)		(find_calculus_alias(N) - 3)
390 
 
 390 
 
391 
#endif
 391 
#endif
392 
 
 392 
 
393 
 
 393 
 
394 
/* Operations for field list of union TYPE */
 394 
/* Operations for field list of union TYPE */
395 
 
 395 
 
396 
#define type_list_tag			( ( unsigned ) 6 )
 396 
#define type_list_tag			((unsigned)6)
397 
#define IS_type_list( P )		( CHECK_NULL ( P )->ag_tag == 6 )
 397 
#define IS_type_list(P)			(CHECK_NULL(P)->ag_tag == 6)
398 
 
 398 
 
399 
#define type_list_sub( P )		( CHECK_TAG ( ( P ), 6 ) + 2 )
 399 
#define type_list_sub(P)		(CHECK_TAG((P), 6) + 2)
400 
 
 400 
 
401 
#define MAKE_type_list( size_, sub_, calculus_type )\
 401 
#define MAKE_type_list(size_, sub_, calculus_type)\
402 
    {\
 402 
    {\
403 
	calculus *x164_ = GEN_calculus ( 4, TYPEID_type ) ;\
 403 
	calculus *x164_ = GEN_calculus(4, TYPEID_type);\
404 
	x164_->ag_tag = 6 ;\
 404 
	x164_->ag_tag = 6;\
405 
	COPY_int ( x164_ + 1, ( size_ ) ) ;\
 405 
	COPY_int(x164_ + 1, (size_));\
406 
	COPY_ptr ( x164_ + 2, ( sub_ ) ) ;\
 406 
	COPY_ptr(x164_ + 2, (sub_));\
407 
	x164_ [3].ag_tag = 0 ;\
 407 
	x164_[3].ag_tag = 0;\
408 
	( calculus_type ) = x164_ ;\
 408 
	(calculus_type) = x164_;\
409 
    }
 409 
    }
410 
 
 410 
 
411 
#define DECONS_type_list( size_, sub_, calculus_type )\
 411 
#define DECONS_type_list(size_, sub_, calculus_type)\
412 
    {\
 412 
    {\
413 
	calculus *x165_ = CHECK_TAG ( ( calculus_type ), 6 ) ;\
 413 
	calculus *x165_ = CHECK_TAG((calculus_type), 6);\
414 
	( size_ ) = DEREF_int ( x165_ + 1 ) ;\
 414 
	(size_) = DEREF_int(x165_ + 1);\
415 
	( sub_ ) = DEREF_ptr ( x165_ + 2 ) ;\
 415 
	(sub_) = DEREF_ptr(x165_ + 2);\
416 
    }
 416 
    }
417 
 
 417 
 
418 
#define DESTROY_type_list( destroyer_, size_, sub_, calculus_type )\
 418 
#define DESTROY_type_list(destroyer_, size_, sub_, calculus_type)\
419 
    {\
 419 
    {\
420 
	calculus *x166_ = CHECK_TAG ( ( calculus_type ), 6 ) ;\
 420 
	calculus *x166_ = CHECK_TAG((calculus_type), 6);\
421 
	( size_ ) = DEREF_int ( x166_ + 1 ) ;\
 421 
	(size_) = DEREF_int(x166_ + 1);\
422 
	( sub_ ) = DEREF_ptr ( x166_ + 2 ) ;\
 422 
	(sub_) = DEREF_ptr(x166_ + 2);\
423 
	( destroyer_ ) ( x166_, ( unsigned ) 4 ) ;\
 423 
	(destroyer_)(x166_, (unsigned)4);\
424 
    }
 424 
    }
425 
 
 425 
 
426 
#ifdef calculus_IO_ROUTINES
 426 
#ifdef calculus_IO_ROUTINES
427 
 
 427 
 
428 
#define NEW_ALIAS_type_list( P, N )\
 428 
#define NEW_ALIAS_type_list(P, N)\
429 
    {\
 429 
    {\
430 
	calculus *x167_ = GEN_calculus ( 4, TYPEID_list ) ;\
 430 
	calculus *x167_ = GEN_calculus(4, TYPEID_list);\
431 
	unsigned a167_ = ( N ) ;\
 431 
	unsigned a167_ = (N);\
432 
	x167_->ag_tag = 6 ;\
 432 
	x167_->ag_tag = 6;\
433 
	x167_ [3].ag_tag = a167_ ;\
 433 
	x167_[3].ag_tag = a167_;\
434 
	set_calculus_alias ( x167_ + 3, a167_ ) ;\
 434 
	set_calculus_alias(x167_ + 3, a167_);\
435 
	( P ) = x167_ ;\
 435 
	(P) = x167_;\
436 
    }
 436 
    }
437 
 
 437 
 
438 
#define GET_ALIAS_type_list( P )	( ( CHECK_NULL ( P ) + 3 )->ag_tag )
 438 
#define GET_ALIAS_type_list(P)		((CHECK_NULL(P) + 3)->ag_tag)
439 
#define SET_ALIAS_type_list( P, N )	set_calculus_alias ( CHECK_NULL ( P ) + 3, ( N ) )
 439 
#define SET_ALIAS_type_list(P, N)	set_calculus_alias(CHECK_NULL(P) + 3, (N))
440 
#define FIND_ALIAS_type_list( N )	( find_calculus_alias ( N ) - 3 )
 440 
#define FIND_ALIAS_type_list(N)		(find_calculus_alias(N) - 3)
441 
 
 441 
 
442 
#endif
 442 
#endif
443 
 
 443 
 
444 
 
 444 
 
445 
/* Operations for field stack of union TYPE */
 445 
/* Operations for field stack of union TYPE */
446 
 
 446 
 
447 
#define type_stack_tag			( ( unsigned ) 7 )
 447 
#define type_stack_tag			((unsigned)7)
448 
#define IS_type_stack( P )		( CHECK_NULL ( P )->ag_tag == 7 )
 448 
#define IS_type_stack(P)		(CHECK_NULL(P)->ag_tag == 7)
449 
 
 449 
 
450 
#define type_stack_sub( P )		( CHECK_TAG ( ( P ), 7 ) + 2 )
 450 
#define type_stack_sub(P)		(CHECK_TAG((P), 7) + 2)
451 
 
 451 
 
452 
#define MAKE_type_stack( size_, sub_, calculus_type )\
 452 
#define MAKE_type_stack(size_, sub_, calculus_type)\
453 
    {\
 453 
    {\
454 
	calculus *x168_ = GEN_calculus ( 4, TYPEID_type ) ;\
 454 
	calculus *x168_ = GEN_calculus(4, TYPEID_type);\
455 
	x168_->ag_tag = 7 ;\
 455 
	x168_->ag_tag = 7;\
456 
	COPY_int ( x168_ + 1, ( size_ ) ) ;\
 456 
	COPY_int(x168_ + 1, (size_));\
457 
	COPY_ptr ( x168_ + 2, ( sub_ ) ) ;\
 457 
	COPY_ptr(x168_ + 2, (sub_));\
458 
	x168_ [3].ag_tag = 0 ;\
 458 
	x168_[3].ag_tag = 0;\
459 
	( calculus_type ) = x168_ ;\
 459 
	(calculus_type) = x168_;\
460 
    }
 460 
    }
461 
 
 461 
 
462 
#define DECONS_type_stack( size_, sub_, calculus_type )\
 462 
#define DECONS_type_stack(size_, sub_, calculus_type)\
463 
    {\
 463 
    {\
464 
	calculus *x169_ = CHECK_TAG ( ( calculus_type ), 7 ) ;\
 464 
	calculus *x169_ = CHECK_TAG((calculus_type), 7);\
465 
	( size_ ) = DEREF_int ( x169_ + 1 ) ;\
 465 
	(size_) = DEREF_int(x169_ + 1);\
466 
	( sub_ ) = DEREF_ptr ( x169_ + 2 ) ;\
 466 
	(sub_) = DEREF_ptr(x169_ + 2);\
467 
    }
 467 
    }
468 
 
 468 
 
469 
#define DESTROY_type_stack( destroyer_, size_, sub_, calculus_type )\
 469 
#define DESTROY_type_stack(destroyer_, size_, sub_, calculus_type)\
470 
    {\
 470 
    {\
471 
	calculus *x170_ = CHECK_TAG ( ( calculus_type ), 7 ) ;\
 471 
	calculus *x170_ = CHECK_TAG((calculus_type), 7);\
472 
	( size_ ) = DEREF_int ( x170_ + 1 ) ;\
 472 
	(size_) = DEREF_int(x170_ + 1);\
473 
	( sub_ ) = DEREF_ptr ( x170_ + 2 ) ;\
 473 
	(sub_) = DEREF_ptr(x170_ + 2);\
474 
	( destroyer_ ) ( x170_, ( unsigned ) 4 ) ;\
 474 
	(destroyer_)(x170_, (unsigned)4);\
475 
    }
 475 
    }
476 
 
 476 
 
477 
#ifdef calculus_IO_ROUTINES
 477 
#ifdef calculus_IO_ROUTINES
478 
 
 478 
 
479 
#define NEW_ALIAS_type_stack( P, N )\
 479 
#define NEW_ALIAS_type_stack(P, N)\
480 
    {\
 480 
    {\
481 
	calculus *x171_ = GEN_calculus ( 4, TYPEID_list ) ;\
 481 
	calculus *x171_ = GEN_calculus(4, TYPEID_list);\
482 
	unsigned a171_ = ( N ) ;\
 482 
	unsigned a171_ = (N);\
483 
	x171_->ag_tag = 7 ;\
 483 
	x171_->ag_tag = 7;\
484 
	x171_ [3].ag_tag = a171_ ;\
 484 
	x171_[3].ag_tag = a171_;\
485 
	set_calculus_alias ( x171_ + 3, a171_ ) ;\
 485 
	set_calculus_alias(x171_ + 3, a171_);\
486 
	( P ) = x171_ ;\
 486 
	(P) = x171_;\
487 
    }
 487 
    }
488 
 
 488 
 
489 
#define GET_ALIAS_type_stack( P )	( ( CHECK_NULL ( P ) + 3 )->ag_tag )
 489 
#define GET_ALIAS_type_stack(P)		((CHECK_NULL(P) + 3)->ag_tag)
490 
#define SET_ALIAS_type_stack( P, N )	set_calculus_alias ( CHECK_NULL ( P ) + 3, ( N ) )
 490 
#define SET_ALIAS_type_stack(P, N)	set_calculus_alias(CHECK_NULL(P) + 3, (N))
491 
#define FIND_ALIAS_type_stack( N )	( find_calculus_alias ( N ) - 3 )
 491 
#define FIND_ALIAS_type_stack(N)	(find_calculus_alias(N) - 3)
492 
 
 492 
 
493 
#endif
 493 
#endif
494 
 
 494 
 
495 
 
 495 
 
496 
/* Operations for field vec of union TYPE */
 496 
/* Operations for field vec of union TYPE */
497 
 
 497 
 
498 
#define type_vec_tag			( ( unsigned ) 8 )
 498 
#define type_vec_tag			((unsigned)8)
499 
#define IS_type_vec( P )		( CHECK_NULL ( P )->ag_tag == 8 )
 499 
#define IS_type_vec(P)			(CHECK_NULL(P)->ag_tag == 8)
500 
 
 500 
 
501 
#define type_vec_sub( P )		( CHECK_TAG ( ( P ), 8 ) + 2 )
 501 
#define type_vec_sub(P)			(CHECK_TAG((P), 8) + 2)
502 
 
 502 
 
503 
#define MAKE_type_vec( size_, sub_, calculus_type )\
 503 
#define MAKE_type_vec(size_, sub_, calculus_type)\
504 
    {\
 504 
    {\
505 
	calculus *x172_ = GEN_calculus ( 4, TYPEID_type ) ;\
 505 
	calculus *x172_ = GEN_calculus(4, TYPEID_type);\
506 
	x172_->ag_tag = 8 ;\
 506 
	x172_->ag_tag = 8;\
507 
	COPY_int ( x172_ + 1, ( size_ ) ) ;\
 507 
	COPY_int(x172_ + 1, (size_));\
508 
	COPY_ptr ( x172_ + 2, ( sub_ ) ) ;\
 508 
	COPY_ptr(x172_ + 2, (sub_));\
509 
	x172_ [3].ag_tag = 0 ;\
 509 
	x172_[3].ag_tag = 0;\
510 
	( calculus_type ) = x172_ ;\
 510 
	(calculus_type) = x172_;\
511 
    }
 511 
    }
512 
 
 512 
 
513 
#define DECONS_type_vec( size_, sub_, calculus_type )\
 513 
#define DECONS_type_vec(size_, sub_, calculus_type)\
514 
    {\
 514 
    {\
515 
	calculus *x173_ = CHECK_TAG ( ( calculus_type ), 8 ) ;\
 515 
	calculus *x173_ = CHECK_TAG((calculus_type), 8);\
516 
	( size_ ) = DEREF_int ( x173_ + 1 ) ;\
 516 
	(size_) = DEREF_int(x173_ + 1);\
517 
	( sub_ ) = DEREF_ptr ( x173_ + 2 ) ;\
 517 
	(sub_) = DEREF_ptr(x173_ + 2);\
518 
    }
 518 
    }
519 
 
 519 
 
520 
#define DESTROY_type_vec( destroyer_, size_, sub_, calculus_type )\
 520 
#define DESTROY_type_vec(destroyer_, size_, sub_, calculus_type)\
521 
    {\
 521 
    {\
522 
	calculus *x174_ = CHECK_TAG ( ( calculus_type ), 8 ) ;\
 522 
	calculus *x174_ = CHECK_TAG((calculus_type), 8);\
523 
	( size_ ) = DEREF_int ( x174_ + 1 ) ;\
 523 
	(size_) = DEREF_int(x174_ + 1);\
524 
	( sub_ ) = DEREF_ptr ( x174_ + 2 ) ;\
 524 
	(sub_) = DEREF_ptr(x174_ + 2);\
525 
	( destroyer_ ) ( x174_, ( unsigned ) 4 ) ;\
 525 
	(destroyer_)(x174_, (unsigned)4);\
526 
    }
 526 
    }
527 
 
 527 
 
528 
#ifdef calculus_IO_ROUTINES
 528 
#ifdef calculus_IO_ROUTINES
529 
 
 529 
 
530 
#define NEW_ALIAS_type_vec( P, N )\
 530 
#define NEW_ALIAS_type_vec(P, N)\
531 
    {\
 531 
    {\
532 
	calculus *x175_ = GEN_calculus ( 4, TYPEID_list ) ;\
 532 
	calculus *x175_ = GEN_calculus(4, TYPEID_list);\
533 
	unsigned a175_ = ( N ) ;\
 533 
	unsigned a175_ = (N);\
534 
	x175_->ag_tag = 8 ;\
 534 
	x175_->ag_tag = 8;\
535 
	x175_ [3].ag_tag = a175_ ;\
 535 
	x175_[3].ag_tag = a175_;\
536 
	set_calculus_alias ( x175_ + 3, a175_ ) ;\
 536 
	set_calculus_alias(x175_ + 3, a175_);\
537 
	( P ) = x175_ ;\
 537 
	(P) = x175_;\
538 
    }
 538 
    }
539 
 
 539 
 
540 
#define GET_ALIAS_type_vec( P )		( ( CHECK_NULL ( P ) + 3 )->ag_tag )
 540 
#define GET_ALIAS_type_vec(P)		((CHECK_NULL(P) + 3)->ag_tag)
541 
#define SET_ALIAS_type_vec( P, N )	set_calculus_alias ( CHECK_NULL ( P ) + 3, ( N ) )
 541 
#define SET_ALIAS_type_vec(P, N)	set_calculus_alias(CHECK_NULL(P) + 3, (N))
542 
#define FIND_ALIAS_type_vec( N )	( find_calculus_alias ( N ) - 3 )
 542 
#define FIND_ALIAS_type_vec(N)		(find_calculus_alias(N) - 3)
543 
 
 543 
 
544 
#endif
 544 
#endif
545 
 
 545 
 
546 
 
 546 
 
547 
/* Operations for field vec_ptr of union TYPE */
 547 
/* Operations for field vec_ptr of union TYPE */
548 
 
 548 
 
549 
#define type_vec_ptr_tag		( ( unsigned ) 9 )
 549 
#define type_vec_ptr_tag		((unsigned)9)
550 
#define IS_type_vec_ptr( P )		( CHECK_NULL ( P )->ag_tag == 9 )
 550 
#define IS_type_vec_ptr(P)		(CHECK_NULL(P)->ag_tag == 9)
551 
 
 551 
 
552 
#define type_vec_ptr_sub( P )		( CHECK_TAG ( ( P ), 9 ) + 2 )
 552 
#define type_vec_ptr_sub(P)		(CHECK_TAG((P), 9) + 2)
553 
 
 553 
 
554 
#define MAKE_type_vec_ptr( size_, sub_, calculus_type )\
 554 
#define MAKE_type_vec_ptr(size_, sub_, calculus_type)\
555 
    {\
 555 
    {\
556 
	calculus *x176_ = GEN_calculus ( 4, TYPEID_type ) ;\
 556 
	calculus *x176_ = GEN_calculus(4, TYPEID_type);\
557 
	x176_->ag_tag = 9 ;\
 557 
	x176_->ag_tag = 9;\
558 
	COPY_int ( x176_ + 1, ( size_ ) ) ;\
 558 
	COPY_int(x176_ + 1, (size_));\
559 
	COPY_ptr ( x176_ + 2, ( sub_ ) ) ;\
 559 
	COPY_ptr(x176_ + 2, (sub_));\
560 
	x176_ [3].ag_tag = 0 ;\
 560 
	x176_[3].ag_tag = 0;\
561 
	( calculus_type ) = x176_ ;\
 561 
	(calculus_type) = x176_;\
562 
    }
 562 
    }
563 
 
 563 
 
564 
#define DECONS_type_vec_ptr( size_, sub_, calculus_type )\
 564 
#define DECONS_type_vec_ptr(size_, sub_, calculus_type)\
565 
    {\
 565 
    {\
566 
	calculus *x177_ = CHECK_TAG ( ( calculus_type ), 9 ) ;\
 566 
	calculus *x177_ = CHECK_TAG((calculus_type), 9);\
567 
	( size_ ) = DEREF_int ( x177_ + 1 ) ;\
 567 
	(size_) = DEREF_int(x177_ + 1);\
568 
	( sub_ ) = DEREF_ptr ( x177_ + 2 ) ;\
 568 
	(sub_) = DEREF_ptr(x177_ + 2);\
569 
    }
 569 
    }
570 
 
 570 
 
571 
#define DESTROY_type_vec_ptr( destroyer_, size_, sub_, calculus_type )\
 571 
#define DESTROY_type_vec_ptr(destroyer_, size_, sub_, calculus_type)\
572 
    {\
 572 
    {\
573 
	calculus *x178_ = CHECK_TAG ( ( calculus_type ), 9 ) ;\
 573 
	calculus *x178_ = CHECK_TAG((calculus_type), 9);\
574 
	( size_ ) = DEREF_int ( x178_ + 1 ) ;\
 574 
	(size_) = DEREF_int(x178_ + 1);\
575 
	( sub_ ) = DEREF_ptr ( x178_ + 2 ) ;\
 575 
	(sub_) = DEREF_ptr(x178_ + 2);\
576 
	( destroyer_ ) ( x178_, ( unsigned ) 4 ) ;\
 576 
	(destroyer_)(x178_, (unsigned)4);\
577 
    }
 577 
    }
578 
 
 578 
 
579 
#ifdef calculus_IO_ROUTINES
 579 
#ifdef calculus_IO_ROUTINES
580 
 
 580 
 
581 
#define NEW_ALIAS_type_vec_ptr( P, N )\
 581 
#define NEW_ALIAS_type_vec_ptr(P, N)\
582 
    {\
 582 
    {\
583 
	calculus *x179_ = GEN_calculus ( 4, TYPEID_list ) ;\
 583 
	calculus *x179_ = GEN_calculus(4, TYPEID_list);\
584 
	unsigned a179_ = ( N ) ;\
 584 
	unsigned a179_ = (N);\
585 
	x179_->ag_tag = 9 ;\
 585 
	x179_->ag_tag = 9;\
586 
	x179_ [3].ag_tag = a179_ ;\
 586 
	x179_[3].ag_tag = a179_;\
587 
	set_calculus_alias ( x179_ + 3, a179_ ) ;\
 587 
	set_calculus_alias(x179_ + 3, a179_);\
588 
	( P ) = x179_ ;\
 588 
	(P) = x179_;\
589 
    }
 589 
    }
590 
 
 590 
 
591 
#define GET_ALIAS_type_vec_ptr( P )	( ( CHECK_NULL ( P ) + 3 )->ag_tag )
 591 
#define GET_ALIAS_type_vec_ptr(P)	((CHECK_NULL(P) + 3)->ag_tag)
592 
#define SET_ALIAS_type_vec_ptr( P, N )	set_calculus_alias ( CHECK_NULL ( P ) + 3, ( N ) )
 592 
#define SET_ALIAS_type_vec_ptr(P, N)	set_calculus_alias(CHECK_NULL(P) + 3, (N))
593 
#define FIND_ALIAS_type_vec_ptr( N )	( find_calculus_alias ( N ) - 3 )
 593 
#define FIND_ALIAS_type_vec_ptr(N)	(find_calculus_alias(N) - 3)
594 
 
 594 
 
595 
#endif
 595 
#endif
596 
 
 596 
 
597 
 
 597 
 
598 
/* Operations for field quote of union TYPE */
 598 
/* Operations for field quote of union TYPE */
599 
 
 599 
 
600 
#define type_quote_tag			( ( unsigned ) 10 )
 600 
#define type_quote_tag			((unsigned)10)
601 
#define IS_type_quote( P )		( CHECK_NULL ( P )->ag_tag == 10 )
 601 
#define IS_type_quote(P)		(CHECK_NULL(P)->ag_tag == 10)
602 
 
 602 
 
603 
#define type_quote_defn( P )		( CHECK_TAG ( ( P ), 10 ) + 2 )
 603 
#define type_quote_defn(P)		(CHECK_TAG((P), 10) + 2)
604 
 
 604 
 
605 
#define MAKE_type_quote( size_, defn_, calculus_type )\
 605 
#define MAKE_type_quote(size_, defn_, calculus_type)\
606 
    {\
 606 
    {\
607 
	calculus *x180_ = GEN_calculus ( 3, TYPEID_type ) ;\
 607 
	calculus *x180_ = GEN_calculus(3, TYPEID_type);\
608 
	x180_->ag_tag = 10 ;\
 608 
	x180_->ag_tag = 10;\
609 
	COPY_int ( x180_ + 1, ( size_ ) ) ;\
 609 
	COPY_int(x180_ + 1, (size_));\
610 
	COPY_string ( x180_ + 2, ( defn_ ) ) ;\
 610 
	COPY_string(x180_ + 2, (defn_));\
611 
	( calculus_type ) = x180_ ;\
 611 
	(calculus_type) = x180_;\
612 
    }
 612 
    }
613 
 
 613 
 
614 
#define DECONS_type_quote( size_, defn_, calculus_type )\
 614 
#define DECONS_type_quote(size_, defn_, calculus_type)\
615 
    {\
 615 
    {\
616 
	calculus *x181_ = CHECK_TAG ( ( calculus_type ), 10 ) ;\
 616 
	calculus *x181_ = CHECK_TAG((calculus_type), 10);\
617 
	( size_ ) = DEREF_int ( x181_ + 1 ) ;\
 617 
	(size_) = DEREF_int(x181_ + 1);\
618 
	( defn_ ) = DEREF_string ( x181_ + 2 ) ;\
 618 
	(defn_) = DEREF_string(x181_ + 2);\
619 
    }
 619 
    }
620 
 
 620 
 
621 
#define DESTROY_type_quote( destroyer_, size_, defn_, calculus_type )\
 621 
#define DESTROY_type_quote(destroyer_, size_, defn_, calculus_type)\
622 
    {\
 622 
    {\
623 
	calculus *x182_ = CHECK_TAG ( ( calculus_type ), 10 ) ;\
 623 
	calculus *x182_ = CHECK_TAG((calculus_type), 10);\
624 
	( size_ ) = DEREF_int ( x182_ + 1 ) ;\
 624 
	(size_) = DEREF_int(x182_ + 1);\
625 
	( defn_ ) = DEREF_string ( x182_ + 2 ) ;\
 625 
	(defn_) = DEREF_string(x182_ + 2);\
626 
	( destroyer_ ) ( x182_, ( unsigned ) 3 ) ;\
 626 
	(destroyer_)(x182_, (unsigned)3);\
627 
    }
 627 
    }
628 
 
 628 
 
629 
 
 629 
 
630 
/* Operations for field undef of union TYPE */
 630 
/* Operations for field undef of union TYPE */
631 
 
 631 
 
632 
#define type_undef_tag			( ( unsigned ) 11 )
 632 
#define type_undef_tag			((unsigned)11)
633 
#define IS_type_undef( P )		( CHECK_NULL ( P )->ag_tag == 11 )
 633 
#define IS_type_undef(P)		(CHECK_NULL(P)->ag_tag == 11)
634 
 
 634 
 
635 
#define type_undef_name( P )		( CHECK_TAG ( ( P ), 11 ) + 2 )
 635 
#define type_undef_name(P)		(CHECK_TAG((P), 11) + 2)
636 
 
 636 
 
637 
#define MAKE_type_undef( size_, name_, calculus_type )\
 637 
#define MAKE_type_undef(size_, name_, calculus_type)\
638 
    {\
 638 
    {\
639 
	calculus *x183_ = GEN_calculus ( 3, TYPEID_type ) ;\
 639 
	calculus *x183_ = GEN_calculus(3, TYPEID_type);\
640 
	x183_->ag_tag = 11 ;\
 640 
	x183_->ag_tag = 11;\
641 
	COPY_int ( x183_ + 1, ( size_ ) ) ;\
 641 
	COPY_int(x183_ + 1, (size_));\
642 
	COPY_string ( x183_ + 2, ( name_ ) ) ;\
 642 
	COPY_string(x183_ + 2, (name_));\
643 
	( calculus_type ) = x183_ ;\
 643 
	(calculus_type) = x183_;\
644 
    }
 644 
    }
645 
 
 645 
 
646 
#define DECONS_type_undef( size_, name_, calculus_type )\
 646 
#define DECONS_type_undef(size_, name_, calculus_type)\
647 
    {\
 647 
    {\
648 
	calculus *x184_ = CHECK_TAG ( ( calculus_type ), 11 ) ;\
 648 
	calculus *x184_ = CHECK_TAG((calculus_type), 11);\
649 
	( size_ ) = DEREF_int ( x184_ + 1 ) ;\
 649 
	(size_) = DEREF_int(x184_ + 1);\
650 
	( name_ ) = DEREF_string ( x184_ + 2 ) ;\
 650 
	(name_) = DEREF_string(x184_ + 2);\
651 
    }
 651 
    }
652 
 
 652 
 
653 
#define DESTROY_type_undef( destroyer_, size_, name_, calculus_type )\
 653 
#define DESTROY_type_undef(destroyer_, size_, name_, calculus_type)\
654 
    {\
 654 
    {\
655 
	calculus *x185_ = CHECK_TAG ( ( calculus_type ), 11 ) ;\
 655 
	calculus *x185_ = CHECK_TAG((calculus_type), 11);\
656 
	( size_ ) = DEREF_int ( x185_ + 1 ) ;\
 656 
	(size_) = DEREF_int(x185_ + 1);\
657 
	( name_ ) = DEREF_string ( x185_ + 2 ) ;\
 657 
	(name_) = DEREF_string(x185_ + 2);\
658 
	( destroyer_ ) ( x185_, ( unsigned ) 3 ) ;\
 658 
	(destroyer_)(x185_, (unsigned)3);\
659 
    }
 659 
    }
660 
 
 660 
 
661 
 
 661 
 
662 
#endif
 662 
#endif