Subversion Repositories tendra.SVN

Rev

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

Rev Author Line No. Line
2 7u83 1 
/*
2 
    		 Crown Copyright (c) 1997, 1998
3 
 
4 
    This TenDRA(r) Computer Program is subject to Copyright
5 
    owned by the United Kingdom Secretary of State for Defence
6 
    acting through the Defence Evaluation and Research Agency
7 
    (DERA).  It is made available to Recipients with a
8 
    royalty-free licence for its use, reproduction, transfer
9 
    to other parties and amendment for any purpose not excluding
10 
    product development provided that any such use et cetera
11 
    shall be deemed to be acceptance of the following conditions:-
12 
 
13 
        (1) Its Recipients shall ensure that this Notice is
14 
        reproduced upon any copies or amended versions of it;
15 
 
16 
        (2) Any amended version of it shall be clearly marked to
17 
        show both the nature of and the organisation responsible
18 
        for the relevant amendment or amendments;
19 
 
20 
        (3) Its onward transfer from a recipient to another
21 
        party shall be deemed to be that party's acceptance of
22 
        these conditions;
23 
 
24 
        (4) DERA gives no warranty or assurance as to its
25 
        quality or suitability for any purpose and DERA accepts
26 
        no liability whatsoever in relation to any use to which
27 
        it may be put.
28 
*/
29 
 
30 
/*
31 
    AUTOMATICALLY GENERATED FROM ALGEBRA c_class (VERSION 1.1)
32 
    BY calculus (VERSION 1.2)
33 
*/
34 
 
35 
#ifndef ITYPE_OPS_H_INCLUDED
36 
#define ITYPE_OPS_H_INCLUDED
37 
 
38 
/* Operations for union INT_TYPE */
39 
 
6 7u83 40 
#define TAG_itype(P)			(CHECK_NULL(P)->ag_tag)
2 7u83 41 
 
42 
 
43 
/* Operations for component prom of union INT_TYPE */
44 
 
6 7u83 45 
#define itype_prom(P)			(CHECK_NULL(P) + 1)
2 7u83 46 
 
47 
 
48 
/* Operations for component cases of union INT_TYPE */
49 
 
6 7u83 50 
#define itype_cases(P)			(CHECK_NULL(P) + 2)
2 7u83 51 
 
52 
 
53 
/* Operations for component unprom of union INT_TYPE */
54 
 
6 7u83 55 
#define itype_unprom(P)			(CHECK_NULL(P) + 3)
2 7u83 56 
 
57 
 
58 
/* Operations for component itok of union INT_TYPE */
59 
 
6 7u83 60 
#define itype_itok(P)			(CHECK_NULL(P) + 4)
2 7u83 61 
 
62 
 
63 
/* Operations for component ntok of union INT_TYPE */
64 
 
6 7u83 65 
#define itype_ntok(P)			(CHECK_NULL(P) + 5)
2 7u83 66 
 
67 
 
68 
/* Operations for component diag of union INT_TYPE */
69 
 
6 7u83 70 
#define itype_diag(P)			(CHECK_NULL(P) + 6)
2 7u83 71 
 
72 
 
73 
/* Operations for field basic of union INT_TYPE */
74 
 
6 7u83 75 
#define itype_basic_tag			((unsigned)0)
76 
#define IS_itype_basic(P)		(CHECK_NULL(P)->ag_tag == 0)
2 7u83 77 
 
6 7u83 78 
#define itype_basic_rep(P)		(CHECK_TAG((P), 0) + 7)
79 
#define itype_basic_no(P)		(CHECK_TAG((P), 0) + 8)
2 7u83 80 
 
6 7u83 81 
#define MAKE_itype_basic(prom_, cases_, rep_, no_, c_class_itype)\
2 7u83 82 
    {\
6 7u83 83 
	c_class *x169_ = GEN_c_class(9, TYPEID_itype);\
84 
	x169_->ag_tag = 0;\
85 
	COPY_type(x169_ + 1, (prom_));\
86 
	COPY_list(x169_ + 2, (cases_));\
87 
	COPY_ntype(x169_ + 3, ntype_none);\
88 
	COPY_ulong(x169_ + 4, LINK_NONE);\
89 
	COPY_ulong(x169_ + 5, LINK_NONE);\
90 
	COPY_ulong(x169_ + 6, LINK_NONE);\
91 
	COPY_btype(x169_ + 7, (rep_));\
92 
	COPY_ntype(x169_ + 8, (no_));\
93 
	(c_class_itype) = x169_;\
2 7u83 94 
    }
95 
 
6 7u83 96 
#define DECONS_itype_basic(prom_, cases_, unprom_, itok_, ntok_, diag_, rep_, no_, c_class_itype)\
2 7u83 97 
    {\
6 7u83 98 
	c_class *x170_ = CHECK_TAG((c_class_itype), 0);\
99 
	(prom_) = DEREF_type(x170_ + 1);\
100 
	(cases_) = DEREF_list(x170_ + 2);\
101 
	(unprom_) = DEREF_ntype(x170_ + 3);\
102 
	(itok_) = DEREF_ulong(x170_ + 4);\
103 
	(ntok_) = DEREF_ulong(x170_ + 5);\
104 
	(diag_) = DEREF_ulong(x170_ + 6);\
105 
	(rep_) = DEREF_btype(x170_ + 7);\
106 
	(no_) = DEREF_ntype(x170_ + 8);\
2 7u83 107 
    }
108 
 
6 7u83 109 
#define DESTROY_itype_basic(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, rep_, no_, c_class_itype)\
2 7u83 110 
    {\
6 7u83 111 
	c_class *x171_ = CHECK_TAG((c_class_itype), 0);\
112 
	(prom_) = DEREF_type(x171_ + 1);\
113 
	(cases_) = DEREF_list(x171_ + 2);\
114 
	(unprom_) = DEREF_ntype(x171_ + 3);\
115 
	(itok_) = DEREF_ulong(x171_ + 4);\
116 
	(ntok_) = DEREF_ulong(x171_ + 5);\
117 
	(diag_) = DEREF_ulong(x171_ + 6);\
118 
	(rep_) = DEREF_btype(x171_ + 7);\
119 
	(no_) = DEREF_ntype(x171_ + 8);\
120 
	(destroyer_)(x171_, (unsigned)9);\
2 7u83 121 
    }
122 
 
123 
 
124 
/* Operations for field bitfield of union INT_TYPE */
125 
 
6 7u83 126 
#define itype_bitfield_tag		((unsigned)1)
127 
#define IS_itype_bitfield(P)		(CHECK_NULL(P)->ag_tag == 1)
2 7u83 128 
 
6 7u83 129 
#define itype_bitfield_sub(P)		(CHECK_TAG((P), 1) + 7)
130 
#define itype_bitfield_rep(P)		(CHECK_TAG((P), 1) + 8)
131 
#define itype_bitfield_size(P)		(CHECK_TAG((P), 1) + 9)
132 
#define itype_bitfield_info(P)		(CHECK_TAG((P), 1) + 10)
2 7u83 133 
 
6 7u83 134 
#define MAKE_itype_bitfield(prom_, cases_, sub_, rep_, size_, info_, c_class_itype)\
2 7u83 135 
    {\
6 7u83 136 
	c_class *x172_ = GEN_c_class(11, TYPEID_itype);\
137 
	x172_->ag_tag = 1;\
138 
	COPY_type(x172_ + 1, (prom_));\
139 
	COPY_list(x172_ + 2, (cases_));\
140 
	COPY_ntype(x172_ + 3, ntype_none);\
141 
	COPY_ulong(x172_ + 4, LINK_NONE);\
142 
	COPY_ulong(x172_ + 5, LINK_NONE);\
143 
	COPY_ulong(x172_ + 6, LINK_NONE);\
144 
	COPY_type(x172_ + 7, (sub_));\
145 
	COPY_btype(x172_ + 8, (rep_));\
146 
	COPY_nat(x172_ + 9, (size_));\
147 
	COPY_dspec(x172_ + 10, (info_));\
148 
	(c_class_itype) = x172_;\
2 7u83 149 
    }
150 
 
6 7u83 151 
#define DECONS_itype_bitfield(prom_, cases_, unprom_, itok_, ntok_, diag_, sub_, rep_, size_, info_, c_class_itype)\
2 7u83 152 
    {\
6 7u83 153 
	c_class *x173_ = CHECK_TAG((c_class_itype), 1);\
154 
	(prom_) = DEREF_type(x173_ + 1);\
155 
	(cases_) = DEREF_list(x173_ + 2);\
156 
	(unprom_) = DEREF_ntype(x173_ + 3);\
157 
	(itok_) = DEREF_ulong(x173_ + 4);\
158 
	(ntok_) = DEREF_ulong(x173_ + 5);\
159 
	(diag_) = DEREF_ulong(x173_ + 6);\
160 
	(sub_) = DEREF_type(x173_ + 7);\
161 
	(rep_) = DEREF_btype(x173_ + 8);\
162 
	(size_) = DEREF_nat(x173_ + 9);\
163 
	(info_) = DEREF_dspec(x173_ + 10);\
2 7u83 164 
    }
165 
 
6 7u83 166 
#define DESTROY_itype_bitfield(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, sub_, rep_, size_, info_, c_class_itype)\
2 7u83 167 
    {\
6 7u83 168 
	c_class *x174_ = CHECK_TAG((c_class_itype), 1);\
169 
	(prom_) = DEREF_type(x174_ + 1);\
170 
	(cases_) = DEREF_list(x174_ + 2);\
171 
	(unprom_) = DEREF_ntype(x174_ + 3);\
172 
	(itok_) = DEREF_ulong(x174_ + 4);\
173 
	(ntok_) = DEREF_ulong(x174_ + 5);\
174 
	(diag_) = DEREF_ulong(x174_ + 6);\
175 
	(sub_) = DEREF_type(x174_ + 7);\
176 
	(rep_) = DEREF_btype(x174_ + 8);\
177 
	(size_) = DEREF_nat(x174_ + 9);\
178 
	(info_) = DEREF_dspec(x174_ + 10);\
179 
	(destroyer_)(x174_, (unsigned)11);\
2 7u83 180 
    }
181 
 
182 
 
183 
/* Operations for field promote of union INT_TYPE */
184 
 
6 7u83 185 
#define itype_promote_tag		((unsigned)2)
186 
#define IS_itype_promote(P)		(CHECK_NULL(P)->ag_tag == 2)
2 7u83 187 
 
6 7u83 188 
#define itype_promote_arg(P)		(CHECK_TAG((P), 2) + 7)
2 7u83 189 
 
6 7u83 190 
#define MAKE_itype_promote(prom_, cases_, arg_, c_class_itype)\
2 7u83 191 
    {\
6 7u83 192 
	c_class *x175_ = GEN_c_class(8, TYPEID_itype);\
193 
	x175_->ag_tag = 2;\
194 
	COPY_type(x175_ + 1, (prom_));\
195 
	COPY_list(x175_ + 2, (cases_));\
196 
	COPY_ntype(x175_ + 3, ntype_none);\
197 
	COPY_ulong(x175_ + 4, LINK_NONE);\
198 
	COPY_ulong(x175_ + 5, LINK_NONE);\
199 
	COPY_ulong(x175_ + 6, LINK_NONE);\
200 
	COPY_itype(x175_ + 7, (arg_));\
201 
	(c_class_itype) = x175_;\
2 7u83 202 
    }
203 
 
6 7u83 204 
#define DECONS_itype_promote(prom_, cases_, unprom_, itok_, ntok_, diag_, arg_, c_class_itype)\
2 7u83 205 
    {\
6 7u83 206 
	c_class *x176_ = CHECK_TAG((c_class_itype), 2);\
207 
	(prom_) = DEREF_type(x176_ + 1);\
208 
	(cases_) = DEREF_list(x176_ + 2);\
209 
	(unprom_) = DEREF_ntype(x176_ + 3);\
210 
	(itok_) = DEREF_ulong(x176_ + 4);\
211 
	(ntok_) = DEREF_ulong(x176_ + 5);\
212 
	(diag_) = DEREF_ulong(x176_ + 6);\
213 
	(arg_) = DEREF_itype(x176_ + 7);\
2 7u83 214 
    }
215 
 
6 7u83 216 
#define DESTROY_itype_promote(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, arg_, c_class_itype)\
2 7u83 217 
    {\
6 7u83 218 
	c_class *x177_ = CHECK_TAG((c_class_itype), 2);\
219 
	(prom_) = DEREF_type(x177_ + 1);\
220 
	(cases_) = DEREF_list(x177_ + 2);\
221 
	(unprom_) = DEREF_ntype(x177_ + 3);\
222 
	(itok_) = DEREF_ulong(x177_ + 4);\
223 
	(ntok_) = DEREF_ulong(x177_ + 5);\
224 
	(diag_) = DEREF_ulong(x177_ + 6);\
225 
	(arg_) = DEREF_itype(x177_ + 7);\
226 
	(destroyer_)(x177_, (unsigned)8);\
2 7u83 227 
    }
228 
 
229 
 
230 
/* Operations for field arith of union INT_TYPE */
231 
 
6 7u83 232 
#define itype_arith_tag			((unsigned)3)
233 
#define IS_itype_arith(P)		(CHECK_NULL(P)->ag_tag == 3)
2 7u83 234 
 
6 7u83 235 
#define itype_arith_arg1(P)		(CHECK_TAG((P), 3) + 7)
236 
#define itype_arith_arg2(P)		(CHECK_TAG((P), 3) + 8)
2 7u83 237 
 
6 7u83 238 
#define MAKE_itype_arith(prom_, cases_, arg1_, arg2_, c_class_itype)\
2 7u83 239 
    {\
6 7u83 240 
	c_class *x178_ = GEN_c_class(9, TYPEID_itype);\
241 
	x178_->ag_tag = 3;\
242 
	COPY_type(x178_ + 1, (prom_));\
243 
	COPY_list(x178_ + 2, (cases_));\
244 
	COPY_ntype(x178_ + 3, ntype_none);\
245 
	COPY_ulong(x178_ + 4, LINK_NONE);\
246 
	COPY_ulong(x178_ + 5, LINK_NONE);\
247 
	COPY_ulong(x178_ + 6, LINK_NONE);\
248 
	COPY_itype(x178_ + 7, (arg1_));\
249 
	COPY_itype(x178_ + 8, (arg2_));\
250 
	(c_class_itype) = x178_;\
2 7u83 251 
    }
252 
 
6 7u83 253 
#define DECONS_itype_arith(prom_, cases_, unprom_, itok_, ntok_, diag_, arg1_, arg2_, c_class_itype)\
2 7u83 254 
    {\
6 7u83 255 
	c_class *x179_ = CHECK_TAG((c_class_itype), 3);\
256 
	(prom_) = DEREF_type(x179_ + 1);\
257 
	(cases_) = DEREF_list(x179_ + 2);\
258 
	(unprom_) = DEREF_ntype(x179_ + 3);\
259 
	(itok_) = DEREF_ulong(x179_ + 4);\
260 
	(ntok_) = DEREF_ulong(x179_ + 5);\
261 
	(diag_) = DEREF_ulong(x179_ + 6);\
262 
	(arg1_) = DEREF_itype(x179_ + 7);\
263 
	(arg2_) = DEREF_itype(x179_ + 8);\
2 7u83 264 
    }
265 
 
6 7u83 266 
#define DESTROY_itype_arith(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, arg1_, arg2_, c_class_itype)\
2 7u83 267 
    {\
6 7u83 268 
	c_class *x180_ = CHECK_TAG((c_class_itype), 3);\
269 
	(prom_) = DEREF_type(x180_ + 1);\
270 
	(cases_) = DEREF_list(x180_ + 2);\
271 
	(unprom_) = DEREF_ntype(x180_ + 3);\
272 
	(itok_) = DEREF_ulong(x180_ + 4);\
273 
	(ntok_) = DEREF_ulong(x180_ + 5);\
274 
	(diag_) = DEREF_ulong(x180_ + 6);\
275 
	(arg1_) = DEREF_itype(x180_ + 7);\
276 
	(arg2_) = DEREF_itype(x180_ + 8);\
277 
	(destroyer_)(x180_, (unsigned)9);\
2 7u83 278 
    }
279 
 
280 
 
281 
/* Operations for field literal of union INT_TYPE */
282 
 
6 7u83 283 
#define itype_literal_tag		((unsigned)4)
284 
#define IS_itype_literal(P)		(CHECK_NULL(P)->ag_tag == 4)
2 7u83 285 
 
6 7u83 286 
#define itype_literal_nat(P)		(CHECK_TAG((P), 4) + 7)
287 
#define itype_literal_spec(P)		(CHECK_TAG((P), 4) + 8)
288 
#define itype_literal_form(P)		(CHECK_TAG((P), 4) + 9)
289 
#define itype_literal_suff(P)		(CHECK_TAG((P), 4) + 10)
290 
#define itype_literal_tok(P)		(CHECK_TAG((P), 4) + 11)
2 7u83 291 
 
6 7u83 292 
#define MAKE_itype_literal(prom_, cases_, nat_, spec_, form_, suff_, tok_, c_class_itype)\
2 7u83 293 
    {\
6 7u83 294 
	c_class *x181_ = GEN_c_class(12, TYPEID_itype);\
295 
	x181_->ag_tag = 4;\
296 
	COPY_type(x181_ + 1, (prom_));\
297 
	COPY_list(x181_ + 2, (cases_));\
298 
	COPY_ntype(x181_ + 3, ntype_none);\
299 
	COPY_ulong(x181_ + 4, LINK_NONE);\
300 
	COPY_ulong(x181_ + 5, LINK_NONE);\
301 
	COPY_ulong(x181_ + 6, LINK_NONE);\
302 
	COPY_nat(x181_ + 7, (nat_));\
303 
	COPY_int(x181_ + 8, (spec_));\
304 
	COPY_int(x181_ + 9, (form_));\
305 
	COPY_int(x181_ + 10, (suff_));\
306 
	COPY_id(x181_ + 11, (tok_));\
307 
	(c_class_itype) = x181_;\
2 7u83 308 
    }
309 
 
6 7u83 310 
#define DECONS_itype_literal(prom_, cases_, unprom_, itok_, ntok_, diag_, nat_, spec_, form_, suff_, tok_, c_class_itype)\
2 7u83 311 
    {\
6 7u83 312 
	c_class *x182_ = CHECK_TAG((c_class_itype), 4);\
313 
	(prom_) = DEREF_type(x182_ + 1);\
314 
	(cases_) = DEREF_list(x182_ + 2);\
315 
	(unprom_) = DEREF_ntype(x182_ + 3);\
316 
	(itok_) = DEREF_ulong(x182_ + 4);\
317 
	(ntok_) = DEREF_ulong(x182_ + 5);\
318 
	(diag_) = DEREF_ulong(x182_ + 6);\
319 
	(nat_) = DEREF_nat(x182_ + 7);\
320 
	(spec_) = DEREF_int(x182_ + 8);\
321 
	(form_) = DEREF_int(x182_ + 9);\
322 
	(suff_) = DEREF_int(x182_ + 10);\
323 
	(tok_) = DEREF_id(x182_ + 11);\
2 7u83 324 
    }
325 
 
6 7u83 326 
#define DESTROY_itype_literal(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, nat_, spec_, form_, suff_, tok_, c_class_itype)\
2 7u83 327 
    {\
6 7u83 328 
	c_class *x183_ = CHECK_TAG((c_class_itype), 4);\
329 
	(prom_) = DEREF_type(x183_ + 1);\
330 
	(cases_) = DEREF_list(x183_ + 2);\
331 
	(unprom_) = DEREF_ntype(x183_ + 3);\
332 
	(itok_) = DEREF_ulong(x183_ + 4);\
333 
	(ntok_) = DEREF_ulong(x183_ + 5);\
334 
	(diag_) = DEREF_ulong(x183_ + 6);\
335 
	(nat_) = DEREF_nat(x183_ + 7);\
336 
	(spec_) = DEREF_int(x183_ + 8);\
337 
	(form_) = DEREF_int(x183_ + 9);\
338 
	(suff_) = DEREF_int(x183_ + 10);\
339 
	(tok_) = DEREF_id(x183_ + 11);\
340 
	(destroyer_)(x183_, (unsigned)12);\
2 7u83 341 
    }
342 
 
343 
 
344 
/* Operations for field token of union INT_TYPE */
345 
 
6 7u83 346 
#define itype_token_tag			((unsigned)5)
347 
#define IS_itype_token(P)		(CHECK_NULL(P)->ag_tag == 5)
2 7u83 348 
 
6 7u83 349 
#define itype_token_tok(P)		(CHECK_TAG((P), 5) + 7)
350 
#define itype_token_args(P)		(CHECK_TAG((P), 5) + 8)
2 7u83 351 
 
6 7u83 352 
#define MAKE_itype_token(prom_, cases_, tok_, args_, c_class_itype)\
2 7u83 353 
    {\
6 7u83 354 
	c_class *x184_ = GEN_c_class(9, TYPEID_itype);\
355 
	x184_->ag_tag = 5;\
356 
	COPY_type(x184_ + 1, (prom_));\
357 
	COPY_list(x184_ + 2, (cases_));\
358 
	COPY_ntype(x184_ + 3, ntype_none);\
359 
	COPY_ulong(x184_ + 4, LINK_NONE);\
360 
	COPY_ulong(x184_ + 5, LINK_NONE);\
361 
	COPY_ulong(x184_ + 6, LINK_NONE);\
362 
	COPY_id(x184_ + 7, (tok_));\
363 
	COPY_list(x184_ + 8, (args_));\
364 
	(c_class_itype) = x184_;\
2 7u83 365 
    }
366 
 
6 7u83 367 
#define DECONS_itype_token(prom_, cases_, unprom_, itok_, ntok_, diag_, tok_, args_, c_class_itype)\
2 7u83 368 
    {\
6 7u83 369 
	c_class *x185_ = CHECK_TAG((c_class_itype), 5);\
370 
	(prom_) = DEREF_type(x185_ + 1);\
371 
	(cases_) = DEREF_list(x185_ + 2);\
372 
	(unprom_) = DEREF_ntype(x185_ + 3);\
373 
	(itok_) = DEREF_ulong(x185_ + 4);\
374 
	(ntok_) = DEREF_ulong(x185_ + 5);\
375 
	(diag_) = DEREF_ulong(x185_ + 6);\
376 
	(tok_) = DEREF_id(x185_ + 7);\
377 
	(args_) = DEREF_list(x185_ + 8);\
2 7u83 378 
    }
379 
 
6 7u83 380 
#define DESTROY_itype_token(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, tok_, args_, c_class_itype)\
2 7u83 381 
    {\
6 7u83 382 
	c_class *x186_ = CHECK_TAG((c_class_itype), 5);\
383 
	(prom_) = DEREF_type(x186_ + 1);\
384 
	(cases_) = DEREF_list(x186_ + 2);\
385 
	(unprom_) = DEREF_ntype(x186_ + 3);\
386 
	(itok_) = DEREF_ulong(x186_ + 4);\
387 
	(ntok_) = DEREF_ulong(x186_ + 5);\
388 
	(diag_) = DEREF_ulong(x186_ + 6);\
389 
	(tok_) = DEREF_id(x186_ + 7);\
390 
	(args_) = DEREF_list(x186_ + 8);\
391 
	(destroyer_)(x186_, (unsigned)9);\
2 7u83 392 
    }
393 
 
394 
 
395 
#endif