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 ITYPE_OPS_H_INCLUDED
 35 
#ifndef ITYPE_OPS_H_INCLUDED
36 
#define ITYPE_OPS_H_INCLUDED
 36 
#define ITYPE_OPS_H_INCLUDED
37 
 
 37 
 
38 
/* Operations for union INT_TYPE */
 38 
/* Operations for union INT_TYPE */
39 
 
 39 
 
40 
#define TAG_itype( P )			( CHECK_NULL ( P )->ag_tag )
 40 
#define TAG_itype(P)			(CHECK_NULL(P)->ag_tag)
41 
 
 41 
 
42 
 
 42 
 
43 
/* Operations for component prom of union INT_TYPE */
 43 
/* Operations for component prom of union INT_TYPE */
44 
 
 44 
 
45 
#define itype_prom( P )			( CHECK_NULL ( P ) + 1 )
 45 
#define itype_prom(P)			(CHECK_NULL(P) + 1)
46 
 
 46 
 
47 
 
 47 
 
48 
/* Operations for component cases of union INT_TYPE */
 48 
/* Operations for component cases of union INT_TYPE */
49 
 
 49 
 
50 
#define itype_cases( P )		( CHECK_NULL ( P ) + 2 )
 50 
#define itype_cases(P)			(CHECK_NULL(P) + 2)
51 
 
 51 
 
52 
 
 52 
 
53 
/* Operations for component unprom of union INT_TYPE */
 53 
/* Operations for component unprom of union INT_TYPE */
54 
 
 54 
 
55 
#define itype_unprom( P )		( CHECK_NULL ( P ) + 3 )
 55 
#define itype_unprom(P)			(CHECK_NULL(P) + 3)
56 
 
 56 
 
57 
 
 57 
 
58 
/* Operations for component itok of union INT_TYPE */
 58 
/* Operations for component itok of union INT_TYPE */
59 
 
 59 
 
60 
#define itype_itok( P )			( CHECK_NULL ( P ) + 4 )
 60 
#define itype_itok(P)			(CHECK_NULL(P) + 4)
61 
 
 61 
 
62 
 
 62 
 
63 
/* Operations for component ntok of union INT_TYPE */
 63 
/* Operations for component ntok of union INT_TYPE */
64 
 
 64 
 
65 
#define itype_ntok( P )			( CHECK_NULL ( P ) + 5 )
 65 
#define itype_ntok(P)			(CHECK_NULL(P) + 5)
66 
 
 66 
 
67 
 
 67 
 
68 
/* Operations for component diag of union INT_TYPE */
 68 
/* Operations for component diag of union INT_TYPE */
69 
 
 69 
 
70 
#define itype_diag( P )			( CHECK_NULL ( P ) + 6 )
 70 
#define itype_diag(P)			(CHECK_NULL(P) + 6)
71 
 
 71 
 
72 
 
 72 
 
73 
/* Operations for field basic of union INT_TYPE */
 73 
/* Operations for field basic of union INT_TYPE */
74 
 
 74 
 
75 
#define itype_basic_tag			( ( unsigned ) 0 )
 75 
#define itype_basic_tag			((unsigned)0)
76 
#define IS_itype_basic( P )		( CHECK_NULL ( P )->ag_tag == 0 )
 76 
#define IS_itype_basic(P)		(CHECK_NULL(P)->ag_tag == 0)
77 
 
 77 
 
78 
#define itype_basic_rep( P )		( CHECK_TAG ( ( P ), 0 ) + 7 )
 78 
#define itype_basic_rep(P)		(CHECK_TAG((P), 0) + 7)
79 
#define itype_basic_no( P )		( CHECK_TAG ( ( P ), 0 ) + 8 )
 79 
#define itype_basic_no(P)		(CHECK_TAG((P), 0) + 8)
80 
 
 80 
 
81 
#define MAKE_itype_basic( prom_, cases_, rep_, no_, c_class_itype )\
 81 
#define MAKE_itype_basic(prom_, cases_, rep_, no_, c_class_itype)\
82 
    {\
 82 
    {\
83 
	c_class *x169_ = GEN_c_class ( 9, TYPEID_itype ) ;\
 83 
	c_class *x169_ = GEN_c_class(9, TYPEID_itype);\
84 
	x169_->ag_tag = 0 ;\
 84 
	x169_->ag_tag = 0;\
85 
	COPY_type ( x169_ + 1, ( prom_ ) ) ;\
 85 
	COPY_type(x169_ + 1, (prom_));\
86 
	COPY_list ( x169_ + 2, ( cases_ ) ) ;\
 86 
	COPY_list(x169_ + 2, (cases_));\
87 
	COPY_ntype ( x169_ + 3, ntype_none ) ;\
 87 
	COPY_ntype(x169_ + 3, ntype_none);\
88 
	COPY_ulong ( x169_ + 4, LINK_NONE ) ;\
 88 
	COPY_ulong(x169_ + 4, LINK_NONE);\
89 
	COPY_ulong ( x169_ + 5, LINK_NONE ) ;\
 89 
	COPY_ulong(x169_ + 5, LINK_NONE);\
90 
	COPY_ulong ( x169_ + 6, LINK_NONE ) ;\
 90 
	COPY_ulong(x169_ + 6, LINK_NONE);\
91 
	COPY_btype ( x169_ + 7, ( rep_ ) ) ;\
 91 
	COPY_btype(x169_ + 7, (rep_));\
92 
	COPY_ntype ( x169_ + 8, ( no_ ) ) ;\
 92 
	COPY_ntype(x169_ + 8, (no_));\
93 
	( c_class_itype ) = x169_ ;\
 93 
	(c_class_itype) = x169_;\
94 
    }
 94 
    }
95 
 
 95 
 
96 
#define DECONS_itype_basic( prom_, cases_, unprom_, itok_, ntok_, diag_, rep_, no_, c_class_itype )\
 96 
#define DECONS_itype_basic(prom_, cases_, unprom_, itok_, ntok_, diag_, rep_, no_, c_class_itype)\
97 
    {\
 97 
    {\
98 
	c_class *x170_ = CHECK_TAG ( ( c_class_itype ), 0 ) ;\
 98 
	c_class *x170_ = CHECK_TAG((c_class_itype), 0);\
99 
	( prom_ ) = DEREF_type ( x170_ + 1 ) ;\
 99 
	(prom_) = DEREF_type(x170_ + 1);\
100 
	( cases_ ) = DEREF_list ( x170_ + 2 ) ;\
 100 
	(cases_) = DEREF_list(x170_ + 2);\
101 
	( unprom_ ) = DEREF_ntype ( x170_ + 3 ) ;\
 101 
	(unprom_) = DEREF_ntype(x170_ + 3);\
102 
	( itok_ ) = DEREF_ulong ( x170_ + 4 ) ;\
 102 
	(itok_) = DEREF_ulong(x170_ + 4);\
103 
	( ntok_ ) = DEREF_ulong ( x170_ + 5 ) ;\
 103 
	(ntok_) = DEREF_ulong(x170_ + 5);\
104 
	( diag_ ) = DEREF_ulong ( x170_ + 6 ) ;\
 104 
	(diag_) = DEREF_ulong(x170_ + 6);\
105 
	( rep_ ) = DEREF_btype ( x170_ + 7 ) ;\
 105 
	(rep_) = DEREF_btype(x170_ + 7);\
106 
	( no_ ) = DEREF_ntype ( x170_ + 8 ) ;\
 106 
	(no_) = DEREF_ntype(x170_ + 8);\
107 
    }
 107 
    }
108 
 
 108 
 
109 
#define DESTROY_itype_basic( destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, rep_, no_, c_class_itype )\
 109 
#define DESTROY_itype_basic(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, rep_, no_, c_class_itype)\
110 
    {\
 110 
    {\
111 
	c_class *x171_ = CHECK_TAG ( ( c_class_itype ), 0 ) ;\
 111 
	c_class *x171_ = CHECK_TAG((c_class_itype), 0);\
112 
	( prom_ ) = DEREF_type ( x171_ + 1 ) ;\
 112 
	(prom_) = DEREF_type(x171_ + 1);\
113 
	( cases_ ) = DEREF_list ( x171_ + 2 ) ;\
 113 
	(cases_) = DEREF_list(x171_ + 2);\
114 
	( unprom_ ) = DEREF_ntype ( x171_ + 3 ) ;\
 114 
	(unprom_) = DEREF_ntype(x171_ + 3);\
115 
	( itok_ ) = DEREF_ulong ( x171_ + 4 ) ;\
 115 
	(itok_) = DEREF_ulong(x171_ + 4);\
116 
	( ntok_ ) = DEREF_ulong ( x171_ + 5 ) ;\
 116 
	(ntok_) = DEREF_ulong(x171_ + 5);\
117 
	( diag_ ) = DEREF_ulong ( x171_ + 6 ) ;\
 117 
	(diag_) = DEREF_ulong(x171_ + 6);\
118 
	( rep_ ) = DEREF_btype ( x171_ + 7 ) ;\
 118 
	(rep_) = DEREF_btype(x171_ + 7);\
119 
	( no_ ) = DEREF_ntype ( x171_ + 8 ) ;\
 119 
	(no_) = DEREF_ntype(x171_ + 8);\
120 
	( destroyer_ ) ( x171_, ( unsigned ) 9 ) ;\
 120 
	(destroyer_)(x171_, (unsigned)9);\
121 
    }
 121 
    }
122 
 
 122 
 
123 
 
 123 
 
124 
/* Operations for field bitfield of union INT_TYPE */
 124 
/* Operations for field bitfield of union INT_TYPE */
125 
 
 125 
 
126 
#define itype_bitfield_tag		( ( unsigned ) 1 )
 126 
#define itype_bitfield_tag		((unsigned)1)
127 
#define IS_itype_bitfield( P )		( CHECK_NULL ( P )->ag_tag == 1 )
 127 
#define IS_itype_bitfield(P)		(CHECK_NULL(P)->ag_tag == 1)
128 
 
 128 
 
129 
#define itype_bitfield_sub( P )		( CHECK_TAG ( ( P ), 1 ) + 7 )
 129 
#define itype_bitfield_sub(P)		(CHECK_TAG((P), 1) + 7)
130 
#define itype_bitfield_rep( P )		( CHECK_TAG ( ( P ), 1 ) + 8 )
 130 
#define itype_bitfield_rep(P)		(CHECK_TAG((P), 1) + 8)
131 
#define itype_bitfield_size( P )	( CHECK_TAG ( ( P ), 1 ) + 9 )
 131 
#define itype_bitfield_size(P)		(CHECK_TAG((P), 1) + 9)
132 
#define itype_bitfield_info( P )	( CHECK_TAG ( ( P ), 1 ) + 10 )
 132 
#define itype_bitfield_info(P)		(CHECK_TAG((P), 1) + 10)
133 
 
 133 
 
134 
#define MAKE_itype_bitfield( prom_, cases_, sub_, rep_, size_, info_, c_class_itype )\
 134 
#define MAKE_itype_bitfield(prom_, cases_, sub_, rep_, size_, info_, c_class_itype)\
135 
    {\
 135 
    {\
136 
	c_class *x172_ = GEN_c_class ( 11, TYPEID_itype ) ;\
 136 
	c_class *x172_ = GEN_c_class(11, TYPEID_itype);\
137 
	x172_->ag_tag = 1 ;\
 137 
	x172_->ag_tag = 1;\
138 
	COPY_type ( x172_ + 1, ( prom_ ) ) ;\
 138 
	COPY_type(x172_ + 1, (prom_));\
139 
	COPY_list ( x172_ + 2, ( cases_ ) ) ;\
 139 
	COPY_list(x172_ + 2, (cases_));\
140 
	COPY_ntype ( x172_ + 3, ntype_none ) ;\
 140 
	COPY_ntype(x172_ + 3, ntype_none);\
141 
	COPY_ulong ( x172_ + 4, LINK_NONE ) ;\
 141 
	COPY_ulong(x172_ + 4, LINK_NONE);\
142 
	COPY_ulong ( x172_ + 5, LINK_NONE ) ;\
 142 
	COPY_ulong(x172_ + 5, LINK_NONE);\
143 
	COPY_ulong ( x172_ + 6, LINK_NONE ) ;\
 143 
	COPY_ulong(x172_ + 6, LINK_NONE);\
144 
	COPY_type ( x172_ + 7, ( sub_ ) ) ;\
 144 
	COPY_type(x172_ + 7, (sub_));\
145 
	COPY_btype ( x172_ + 8, ( rep_ ) ) ;\
 145 
	COPY_btype(x172_ + 8, (rep_));\
146 
	COPY_nat ( x172_ + 9, ( size_ ) ) ;\
 146 
	COPY_nat(x172_ + 9, (size_));\
147 
	COPY_dspec ( x172_ + 10, ( info_ ) ) ;\
 147 
	COPY_dspec(x172_ + 10, (info_));\
148 
	( c_class_itype ) = x172_ ;\
 148 
	(c_class_itype) = x172_;\
149 
    }
 149 
    }
150 
 
 150 
 
151 
#define DECONS_itype_bitfield( prom_, cases_, unprom_, itok_, ntok_, diag_, sub_, rep_, size_, info_, c_class_itype )\
 151 
#define DECONS_itype_bitfield(prom_, cases_, unprom_, itok_, ntok_, diag_, sub_, rep_, size_, info_, c_class_itype)\
152 
    {\
 152 
    {\
153 
	c_class *x173_ = CHECK_TAG ( ( c_class_itype ), 1 ) ;\
 153 
	c_class *x173_ = CHECK_TAG((c_class_itype), 1);\
154 
	( prom_ ) = DEREF_type ( x173_ + 1 ) ;\
 154 
	(prom_) = DEREF_type(x173_ + 1);\
155 
	( cases_ ) = DEREF_list ( x173_ + 2 ) ;\
 155 
	(cases_) = DEREF_list(x173_ + 2);\
156 
	( unprom_ ) = DEREF_ntype ( x173_ + 3 ) ;\
 156 
	(unprom_) = DEREF_ntype(x173_ + 3);\
157 
	( itok_ ) = DEREF_ulong ( x173_ + 4 ) ;\
 157 
	(itok_) = DEREF_ulong(x173_ + 4);\
158 
	( ntok_ ) = DEREF_ulong ( x173_ + 5 ) ;\
 158 
	(ntok_) = DEREF_ulong(x173_ + 5);\
159 
	( diag_ ) = DEREF_ulong ( x173_ + 6 ) ;\
 159 
	(diag_) = DEREF_ulong(x173_ + 6);\
160 
	( sub_ ) = DEREF_type ( x173_ + 7 ) ;\
 160 
	(sub_) = DEREF_type(x173_ + 7);\
161 
	( rep_ ) = DEREF_btype ( x173_ + 8 ) ;\
 161 
	(rep_) = DEREF_btype(x173_ + 8);\
162 
	( size_ ) = DEREF_nat ( x173_ + 9 ) ;\
 162 
	(size_) = DEREF_nat(x173_ + 9);\
163 
	( info_ ) = DEREF_dspec ( x173_ + 10 ) ;\
 163 
	(info_) = DEREF_dspec(x173_ + 10);\
164 
    }
 164 
    }
165 
 
 165 
 
166 
#define DESTROY_itype_bitfield( destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, sub_, rep_, size_, info_, c_class_itype )\
 166 
#define DESTROY_itype_bitfield(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, sub_, rep_, size_, info_, c_class_itype)\
167 
    {\
 167 
    {\
168 
	c_class *x174_ = CHECK_TAG ( ( c_class_itype ), 1 ) ;\
 168 
	c_class *x174_ = CHECK_TAG((c_class_itype), 1);\
169 
	( prom_ ) = DEREF_type ( x174_ + 1 ) ;\
 169 
	(prom_) = DEREF_type(x174_ + 1);\
170 
	( cases_ ) = DEREF_list ( x174_ + 2 ) ;\
 170 
	(cases_) = DEREF_list(x174_ + 2);\
171 
	( unprom_ ) = DEREF_ntype ( x174_ + 3 ) ;\
 171 
	(unprom_) = DEREF_ntype(x174_ + 3);\
172 
	( itok_ ) = DEREF_ulong ( x174_ + 4 ) ;\
 172 
	(itok_) = DEREF_ulong(x174_ + 4);\
173 
	( ntok_ ) = DEREF_ulong ( x174_ + 5 ) ;\
 173 
	(ntok_) = DEREF_ulong(x174_ + 5);\
174 
	( diag_ ) = DEREF_ulong ( x174_ + 6 ) ;\
 174 
	(diag_) = DEREF_ulong(x174_ + 6);\
175 
	( sub_ ) = DEREF_type ( x174_ + 7 ) ;\
 175 
	(sub_) = DEREF_type(x174_ + 7);\
176 
	( rep_ ) = DEREF_btype ( x174_ + 8 ) ;\
 176 
	(rep_) = DEREF_btype(x174_ + 8);\
177 
	( size_ ) = DEREF_nat ( x174_ + 9 ) ;\
 177 
	(size_) = DEREF_nat(x174_ + 9);\
178 
	( info_ ) = DEREF_dspec ( x174_ + 10 ) ;\
 178 
	(info_) = DEREF_dspec(x174_ + 10);\
179 
	( destroyer_ ) ( x174_, ( unsigned ) 11 ) ;\
 179 
	(destroyer_)(x174_, (unsigned)11);\
180 
    }
 180 
    }
181 
 
 181 
 
182 
 
 182 
 
183 
/* Operations for field promote of union INT_TYPE */
 183 
/* Operations for field promote of union INT_TYPE */
184 
 
 184 
 
185 
#define itype_promote_tag		( ( unsigned ) 2 )
 185 
#define itype_promote_tag		((unsigned)2)
186 
#define IS_itype_promote( P )		( CHECK_NULL ( P )->ag_tag == 2 )
 186 
#define IS_itype_promote(P)		(CHECK_NULL(P)->ag_tag == 2)
187 
 
 187 
 
188 
#define itype_promote_arg( P )		( CHECK_TAG ( ( P ), 2 ) + 7 )
 188 
#define itype_promote_arg(P)		(CHECK_TAG((P), 2) + 7)
189 
 
 189 
 
190 
#define MAKE_itype_promote( prom_, cases_, arg_, c_class_itype )\
 190 
#define MAKE_itype_promote(prom_, cases_, arg_, c_class_itype)\
191 
    {\
 191 
    {\
192 
	c_class *x175_ = GEN_c_class ( 8, TYPEID_itype ) ;\
 192 
	c_class *x175_ = GEN_c_class(8, TYPEID_itype);\
193 
	x175_->ag_tag = 2 ;\
 193 
	x175_->ag_tag = 2;\
194 
	COPY_type ( x175_ + 1, ( prom_ ) ) ;\
 194 
	COPY_type(x175_ + 1, (prom_));\
195 
	COPY_list ( x175_ + 2, ( cases_ ) ) ;\
 195 
	COPY_list(x175_ + 2, (cases_));\
196 
	COPY_ntype ( x175_ + 3, ntype_none ) ;\
 196 
	COPY_ntype(x175_ + 3, ntype_none);\
197 
	COPY_ulong ( x175_ + 4, LINK_NONE ) ;\
 197 
	COPY_ulong(x175_ + 4, LINK_NONE);\
198 
	COPY_ulong ( x175_ + 5, LINK_NONE ) ;\
 198 
	COPY_ulong(x175_ + 5, LINK_NONE);\
199 
	COPY_ulong ( x175_ + 6, LINK_NONE ) ;\
 199 
	COPY_ulong(x175_ + 6, LINK_NONE);\
200 
	COPY_itype ( x175_ + 7, ( arg_ ) ) ;\
 200 
	COPY_itype(x175_ + 7, (arg_));\
201 
	( c_class_itype ) = x175_ ;\
 201 
	(c_class_itype) = x175_;\
202 
    }
 202 
    }
203 
 
 203 
 
204 
#define DECONS_itype_promote( prom_, cases_, unprom_, itok_, ntok_, diag_, arg_, c_class_itype )\
 204 
#define DECONS_itype_promote(prom_, cases_, unprom_, itok_, ntok_, diag_, arg_, c_class_itype)\
205 
    {\
 205 
    {\
206 
	c_class *x176_ = CHECK_TAG ( ( c_class_itype ), 2 ) ;\
 206 
	c_class *x176_ = CHECK_TAG((c_class_itype), 2);\
207 
	( prom_ ) = DEREF_type ( x176_ + 1 ) ;\
 207 
	(prom_) = DEREF_type(x176_ + 1);\
208 
	( cases_ ) = DEREF_list ( x176_ + 2 ) ;\
 208 
	(cases_) = DEREF_list(x176_ + 2);\
209 
	( unprom_ ) = DEREF_ntype ( x176_ + 3 ) ;\
 209 
	(unprom_) = DEREF_ntype(x176_ + 3);\
210 
	( itok_ ) = DEREF_ulong ( x176_ + 4 ) ;\
 210 
	(itok_) = DEREF_ulong(x176_ + 4);\
211 
	( ntok_ ) = DEREF_ulong ( x176_ + 5 ) ;\
 211 
	(ntok_) = DEREF_ulong(x176_ + 5);\
212 
	( diag_ ) = DEREF_ulong ( x176_ + 6 ) ;\
 212 
	(diag_) = DEREF_ulong(x176_ + 6);\
213 
	( arg_ ) = DEREF_itype ( x176_ + 7 ) ;\
 213 
	(arg_) = DEREF_itype(x176_ + 7);\
214 
    }
 214 
    }
215 
 
 215 
 
216 
#define DESTROY_itype_promote( destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, arg_, c_class_itype )\
 216 
#define DESTROY_itype_promote(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, arg_, c_class_itype)\
217 
    {\
 217 
    {\
218 
	c_class *x177_ = CHECK_TAG ( ( c_class_itype ), 2 ) ;\
 218 
	c_class *x177_ = CHECK_TAG((c_class_itype), 2);\
219 
	( prom_ ) = DEREF_type ( x177_ + 1 ) ;\
 219 
	(prom_) = DEREF_type(x177_ + 1);\
220 
	( cases_ ) = DEREF_list ( x177_ + 2 ) ;\
 220 
	(cases_) = DEREF_list(x177_ + 2);\
221 
	( unprom_ ) = DEREF_ntype ( x177_ + 3 ) ;\
 221 
	(unprom_) = DEREF_ntype(x177_ + 3);\
222 
	( itok_ ) = DEREF_ulong ( x177_ + 4 ) ;\
 222 
	(itok_) = DEREF_ulong(x177_ + 4);\
223 
	( ntok_ ) = DEREF_ulong ( x177_ + 5 ) ;\
 223 
	(ntok_) = DEREF_ulong(x177_ + 5);\
224 
	( diag_ ) = DEREF_ulong ( x177_ + 6 ) ;\
 224 
	(diag_) = DEREF_ulong(x177_ + 6);\
225 
	( arg_ ) = DEREF_itype ( x177_ + 7 ) ;\
 225 
	(arg_) = DEREF_itype(x177_ + 7);\
226 
	( destroyer_ ) ( x177_, ( unsigned ) 8 ) ;\
 226 
	(destroyer_)(x177_, (unsigned)8);\
227 
    }
 227 
    }
228 
 
 228 
 
229 
 
 229 
 
230 
/* Operations for field arith of union INT_TYPE */
 230 
/* Operations for field arith of union INT_TYPE */
231 
 
 231 
 
232 
#define itype_arith_tag			( ( unsigned ) 3 )
 232 
#define itype_arith_tag			((unsigned)3)
233 
#define IS_itype_arith( P )		( CHECK_NULL ( P )->ag_tag == 3 )
 233 
#define IS_itype_arith(P)		(CHECK_NULL(P)->ag_tag == 3)
234 
 
 234 
 
235 
#define itype_arith_arg1( P )		( CHECK_TAG ( ( P ), 3 ) + 7 )
 235 
#define itype_arith_arg1(P)		(CHECK_TAG((P), 3) + 7)
236 
#define itype_arith_arg2( P )		( CHECK_TAG ( ( P ), 3 ) + 8 )
 236 
#define itype_arith_arg2(P)		(CHECK_TAG((P), 3) + 8)
237 
 
 237 
 
238 
#define MAKE_itype_arith( prom_, cases_, arg1_, arg2_, c_class_itype )\
 238 
#define MAKE_itype_arith(prom_, cases_, arg1_, arg2_, c_class_itype)\
239 
    {\
 239 
    {\
240 
	c_class *x178_ = GEN_c_class ( 9, TYPEID_itype ) ;\
 240 
	c_class *x178_ = GEN_c_class(9, TYPEID_itype);\
241 
	x178_->ag_tag = 3 ;\
 241 
	x178_->ag_tag = 3;\
242 
	COPY_type ( x178_ + 1, ( prom_ ) ) ;\
 242 
	COPY_type(x178_ + 1, (prom_));\
243 
	COPY_list ( x178_ + 2, ( cases_ ) ) ;\
 243 
	COPY_list(x178_ + 2, (cases_));\
244 
	COPY_ntype ( x178_ + 3, ntype_none ) ;\
 244 
	COPY_ntype(x178_ + 3, ntype_none);\
245 
	COPY_ulong ( x178_ + 4, LINK_NONE ) ;\
 245 
	COPY_ulong(x178_ + 4, LINK_NONE);\
246 
	COPY_ulong ( x178_ + 5, LINK_NONE ) ;\
 246 
	COPY_ulong(x178_ + 5, LINK_NONE);\
247 
	COPY_ulong ( x178_ + 6, LINK_NONE ) ;\
 247 
	COPY_ulong(x178_ + 6, LINK_NONE);\
248 
	COPY_itype ( x178_ + 7, ( arg1_ ) ) ;\
 248 
	COPY_itype(x178_ + 7, (arg1_));\
249 
	COPY_itype ( x178_ + 8, ( arg2_ ) ) ;\
 249 
	COPY_itype(x178_ + 8, (arg2_));\
250 
	( c_class_itype ) = x178_ ;\
 250 
	(c_class_itype) = x178_;\
251 
    }
 251 
    }
252 
 
 252 
 
253 
#define DECONS_itype_arith( prom_, cases_, unprom_, itok_, ntok_, diag_, arg1_, arg2_, c_class_itype )\
 253 
#define DECONS_itype_arith(prom_, cases_, unprom_, itok_, ntok_, diag_, arg1_, arg2_, c_class_itype)\
254 
    {\
 254 
    {\
255 
	c_class *x179_ = CHECK_TAG ( ( c_class_itype ), 3 ) ;\
 255 
	c_class *x179_ = CHECK_TAG((c_class_itype), 3);\
256 
	( prom_ ) = DEREF_type ( x179_ + 1 ) ;\
 256 
	(prom_) = DEREF_type(x179_ + 1);\
257 
	( cases_ ) = DEREF_list ( x179_ + 2 ) ;\
 257 
	(cases_) = DEREF_list(x179_ + 2);\
258 
	( unprom_ ) = DEREF_ntype ( x179_ + 3 ) ;\
 258 
	(unprom_) = DEREF_ntype(x179_ + 3);\
259 
	( itok_ ) = DEREF_ulong ( x179_ + 4 ) ;\
 259 
	(itok_) = DEREF_ulong(x179_ + 4);\
260 
	( ntok_ ) = DEREF_ulong ( x179_ + 5 ) ;\
 260 
	(ntok_) = DEREF_ulong(x179_ + 5);\
261 
	( diag_ ) = DEREF_ulong ( x179_ + 6 ) ;\
 261 
	(diag_) = DEREF_ulong(x179_ + 6);\
262 
	( arg1_ ) = DEREF_itype ( x179_ + 7 ) ;\
 262 
	(arg1_) = DEREF_itype(x179_ + 7);\
263 
	( arg2_ ) = DEREF_itype ( x179_ + 8 ) ;\
 263 
	(arg2_) = DEREF_itype(x179_ + 8);\
264 
    }
 264 
    }
265 
 
 265 
 
266 
#define DESTROY_itype_arith( destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, arg1_, arg2_, c_class_itype )\
 266 
#define DESTROY_itype_arith(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, arg1_, arg2_, c_class_itype)\
267 
    {\
 267 
    {\
268 
	c_class *x180_ = CHECK_TAG ( ( c_class_itype ), 3 ) ;\
 268 
	c_class *x180_ = CHECK_TAG((c_class_itype), 3);\
269 
	( prom_ ) = DEREF_type ( x180_ + 1 ) ;\
 269 
	(prom_) = DEREF_type(x180_ + 1);\
270 
	( cases_ ) = DEREF_list ( x180_ + 2 ) ;\
 270 
	(cases_) = DEREF_list(x180_ + 2);\
271 
	( unprom_ ) = DEREF_ntype ( x180_ + 3 ) ;\
 271 
	(unprom_) = DEREF_ntype(x180_ + 3);\
272 
	( itok_ ) = DEREF_ulong ( x180_ + 4 ) ;\
 272 
	(itok_) = DEREF_ulong(x180_ + 4);\
273 
	( ntok_ ) = DEREF_ulong ( x180_ + 5 ) ;\
 273 
	(ntok_) = DEREF_ulong(x180_ + 5);\
274 
	( diag_ ) = DEREF_ulong ( x180_ + 6 ) ;\
 274 
	(diag_) = DEREF_ulong(x180_ + 6);\
275 
	( arg1_ ) = DEREF_itype ( x180_ + 7 ) ;\
 275 
	(arg1_) = DEREF_itype(x180_ + 7);\
276 
	( arg2_ ) = DEREF_itype ( x180_ + 8 ) ;\
 276 
	(arg2_) = DEREF_itype(x180_ + 8);\
277 
	( destroyer_ ) ( x180_, ( unsigned ) 9 ) ;\
 277 
	(destroyer_)(x180_, (unsigned)9);\
278 
    }
 278 
    }
279 
 
 279 
 
280 
 
 280 
 
281 
/* Operations for field literal of union INT_TYPE */
 281 
/* Operations for field literal of union INT_TYPE */
282 
 
 282 
 
283 
#define itype_literal_tag		( ( unsigned ) 4 )
 283 
#define itype_literal_tag		((unsigned)4)
284 
#define IS_itype_literal( P )		( CHECK_NULL ( P )->ag_tag == 4 )
 284 
#define IS_itype_literal(P)		(CHECK_NULL(P)->ag_tag == 4)
285 
 
 285 
 
286 
#define itype_literal_nat( P )		( CHECK_TAG ( ( P ), 4 ) + 7 )
 286 
#define itype_literal_nat(P)		(CHECK_TAG((P), 4) + 7)
287 
#define itype_literal_spec( P )		( CHECK_TAG ( ( P ), 4 ) + 8 )
 287 
#define itype_literal_spec(P)		(CHECK_TAG((P), 4) + 8)
288 
#define itype_literal_form( P )		( CHECK_TAG ( ( P ), 4 ) + 9 )
 288 
#define itype_literal_form(P)		(CHECK_TAG((P), 4) + 9)
289 
#define itype_literal_suff( P )		( CHECK_TAG ( ( P ), 4 ) + 10 )
 289 
#define itype_literal_suff(P)		(CHECK_TAG((P), 4) + 10)
290 
#define itype_literal_tok( P )		( CHECK_TAG ( ( P ), 4 ) + 11 )
 290 
#define itype_literal_tok(P)		(CHECK_TAG((P), 4) + 11)
291 
 
 291 
 
292 
#define MAKE_itype_literal( prom_, cases_, nat_, spec_, form_, suff_, tok_, c_class_itype )\
 292 
#define MAKE_itype_literal(prom_, cases_, nat_, spec_, form_, suff_, tok_, c_class_itype)\
293 
    {\
 293 
    {\
294 
	c_class *x181_ = GEN_c_class ( 12, TYPEID_itype ) ;\
 294 
	c_class *x181_ = GEN_c_class(12, TYPEID_itype);\
295 
	x181_->ag_tag = 4 ;\
 295 
	x181_->ag_tag = 4;\
296 
	COPY_type ( x181_ + 1, ( prom_ ) ) ;\
 296 
	COPY_type(x181_ + 1, (prom_));\
297 
	COPY_list ( x181_ + 2, ( cases_ ) ) ;\
 297 
	COPY_list(x181_ + 2, (cases_));\
298 
	COPY_ntype ( x181_ + 3, ntype_none ) ;\
 298 
	COPY_ntype(x181_ + 3, ntype_none);\
299 
	COPY_ulong ( x181_ + 4, LINK_NONE ) ;\
 299 
	COPY_ulong(x181_ + 4, LINK_NONE);\
300 
	COPY_ulong ( x181_ + 5, LINK_NONE ) ;\
 300 
	COPY_ulong(x181_ + 5, LINK_NONE);\
301 
	COPY_ulong ( x181_ + 6, LINK_NONE ) ;\
 301 
	COPY_ulong(x181_ + 6, LINK_NONE);\
302 
	COPY_nat ( x181_ + 7, ( nat_ ) ) ;\
 302 
	COPY_nat(x181_ + 7, (nat_));\
303 
	COPY_int ( x181_ + 8, ( spec_ ) ) ;\
 303 
	COPY_int(x181_ + 8, (spec_));\
304 
	COPY_int ( x181_ + 9, ( form_ ) ) ;\
 304 
	COPY_int(x181_ + 9, (form_));\
305 
	COPY_int ( x181_ + 10, ( suff_ ) ) ;\
 305 
	COPY_int(x181_ + 10, (suff_));\
306 
	COPY_id ( x181_ + 11, ( tok_ ) ) ;\
 306 
	COPY_id(x181_ + 11, (tok_));\
307 
	( c_class_itype ) = x181_ ;\
 307 
	(c_class_itype) = x181_;\
308 
    }
 308 
    }
309 
 
 309 
 
310 
#define DECONS_itype_literal( prom_, cases_, unprom_, itok_, ntok_, diag_, nat_, spec_, form_, suff_, tok_, c_class_itype )\
 310 
#define DECONS_itype_literal(prom_, cases_, unprom_, itok_, ntok_, diag_, nat_, spec_, form_, suff_, tok_, c_class_itype)\
311 
    {\
 311 
    {\
312 
	c_class *x182_ = CHECK_TAG ( ( c_class_itype ), 4 ) ;\
 312 
	c_class *x182_ = CHECK_TAG((c_class_itype), 4);\
313 
	( prom_ ) = DEREF_type ( x182_ + 1 ) ;\
 313 
	(prom_) = DEREF_type(x182_ + 1);\
314 
	( cases_ ) = DEREF_list ( x182_ + 2 ) ;\
 314 
	(cases_) = DEREF_list(x182_ + 2);\
315 
	( unprom_ ) = DEREF_ntype ( x182_ + 3 ) ;\
 315 
	(unprom_) = DEREF_ntype(x182_ + 3);\
316 
	( itok_ ) = DEREF_ulong ( x182_ + 4 ) ;\
 316 
	(itok_) = DEREF_ulong(x182_ + 4);\
317 
	( ntok_ ) = DEREF_ulong ( x182_ + 5 ) ;\
 317 
	(ntok_) = DEREF_ulong(x182_ + 5);\
318 
	( diag_ ) = DEREF_ulong ( x182_ + 6 ) ;\
 318 
	(diag_) = DEREF_ulong(x182_ + 6);\
319 
	( nat_ ) = DEREF_nat ( x182_ + 7 ) ;\
 319 
	(nat_) = DEREF_nat(x182_ + 7);\
320 
	( spec_ ) = DEREF_int ( x182_ + 8 ) ;\
 320 
	(spec_) = DEREF_int(x182_ + 8);\
321 
	( form_ ) = DEREF_int ( x182_ + 9 ) ;\
 321 
	(form_) = DEREF_int(x182_ + 9);\
322 
	( suff_ ) = DEREF_int ( x182_ + 10 ) ;\
 322 
	(suff_) = DEREF_int(x182_ + 10);\
323 
	( tok_ ) = DEREF_id ( x182_ + 11 ) ;\
 323 
	(tok_) = DEREF_id(x182_ + 11);\
324 
    }
 324 
    }
325 
 
 325 
 
326 
#define DESTROY_itype_literal( destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, nat_, spec_, form_, suff_, tok_, c_class_itype )\
 326 
#define DESTROY_itype_literal(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, nat_, spec_, form_, suff_, tok_, c_class_itype)\
327 
    {\
 327 
    {\
328 
	c_class *x183_ = CHECK_TAG ( ( c_class_itype ), 4 ) ;\
 328 
	c_class *x183_ = CHECK_TAG((c_class_itype), 4);\
329 
	( prom_ ) = DEREF_type ( x183_ + 1 ) ;\
 329 
	(prom_) = DEREF_type(x183_ + 1);\
330 
	( cases_ ) = DEREF_list ( x183_ + 2 ) ;\
 330 
	(cases_) = DEREF_list(x183_ + 2);\
331 
	( unprom_ ) = DEREF_ntype ( x183_ + 3 ) ;\
 331 
	(unprom_) = DEREF_ntype(x183_ + 3);\
332 
	( itok_ ) = DEREF_ulong ( x183_ + 4 ) ;\
 332 
	(itok_) = DEREF_ulong(x183_ + 4);\
333 
	( ntok_ ) = DEREF_ulong ( x183_ + 5 ) ;\
 333 
	(ntok_) = DEREF_ulong(x183_ + 5);\
334 
	( diag_ ) = DEREF_ulong ( x183_ + 6 ) ;\
 334 
	(diag_) = DEREF_ulong(x183_ + 6);\
335 
	( nat_ ) = DEREF_nat ( x183_ + 7 ) ;\
 335 
	(nat_) = DEREF_nat(x183_ + 7);\
336 
	( spec_ ) = DEREF_int ( x183_ + 8 ) ;\
 336 
	(spec_) = DEREF_int(x183_ + 8);\
337 
	( form_ ) = DEREF_int ( x183_ + 9 ) ;\
 337 
	(form_) = DEREF_int(x183_ + 9);\
338 
	( suff_ ) = DEREF_int ( x183_ + 10 ) ;\
 338 
	(suff_) = DEREF_int(x183_ + 10);\
339 
	( tok_ ) = DEREF_id ( x183_ + 11 ) ;\
 339 
	(tok_) = DEREF_id(x183_ + 11);\
340 
	( destroyer_ ) ( x183_, ( unsigned ) 12 ) ;\
 340 
	(destroyer_)(x183_, (unsigned)12);\
341 
    }
 341 
    }
342 
 
 342 
 
343 
 
 343 
 
344 
/* Operations for field token of union INT_TYPE */
 344 
/* Operations for field token of union INT_TYPE */
345 
 
 345 
 
346 
#define itype_token_tag			( ( unsigned ) 5 )
 346 
#define itype_token_tag			((unsigned)5)
347 
#define IS_itype_token( P )		( CHECK_NULL ( P )->ag_tag == 5 )
 347 
#define IS_itype_token(P)		(CHECK_NULL(P)->ag_tag == 5)
348 
 
 348 
 
349 
#define itype_token_tok( P )		( CHECK_TAG ( ( P ), 5 ) + 7 )
 349 
#define itype_token_tok(P)		(CHECK_TAG((P), 5) + 7)
350 
#define itype_token_args( P )		( CHECK_TAG ( ( P ), 5 ) + 8 )
 350 
#define itype_token_args(P)		(CHECK_TAG((P), 5) + 8)
351 
 
 351 
 
352 
#define MAKE_itype_token( prom_, cases_, tok_, args_, c_class_itype )\
 352 
#define MAKE_itype_token(prom_, cases_, tok_, args_, c_class_itype)\
353 
    {\
 353 
    {\
354 
	c_class *x184_ = GEN_c_class ( 9, TYPEID_itype ) ;\
 354 
	c_class *x184_ = GEN_c_class(9, TYPEID_itype);\
355 
	x184_->ag_tag = 5 ;\
 355 
	x184_->ag_tag = 5;\
356 
	COPY_type ( x184_ + 1, ( prom_ ) ) ;\
 356 
	COPY_type(x184_ + 1, (prom_));\
357 
	COPY_list ( x184_ + 2, ( cases_ ) ) ;\
 357 
	COPY_list(x184_ + 2, (cases_));\
358 
	COPY_ntype ( x184_ + 3, ntype_none ) ;\
 358 
	COPY_ntype(x184_ + 3, ntype_none);\
359 
	COPY_ulong ( x184_ + 4, LINK_NONE ) ;\
 359 
	COPY_ulong(x184_ + 4, LINK_NONE);\
360 
	COPY_ulong ( x184_ + 5, LINK_NONE ) ;\
 360 
	COPY_ulong(x184_ + 5, LINK_NONE);\
361 
	COPY_ulong ( x184_ + 6, LINK_NONE ) ;\
 361 
	COPY_ulong(x184_ + 6, LINK_NONE);\
362 
	COPY_id ( x184_ + 7, ( tok_ ) ) ;\
 362 
	COPY_id(x184_ + 7, (tok_));\
363 
	COPY_list ( x184_ + 8, ( args_ ) ) ;\
 363 
	COPY_list(x184_ + 8, (args_));\
364 
	( c_class_itype ) = x184_ ;\
 364 
	(c_class_itype) = x184_;\
365 
    }
 365 
    }
366 
 
 366 
 
367 
#define DECONS_itype_token( prom_, cases_, unprom_, itok_, ntok_, diag_, tok_, args_, c_class_itype )\
 367 
#define DECONS_itype_token(prom_, cases_, unprom_, itok_, ntok_, diag_, tok_, args_, c_class_itype)\
368 
    {\
 368 
    {\
369 
	c_class *x185_ = CHECK_TAG ( ( c_class_itype ), 5 ) ;\
 369 
	c_class *x185_ = CHECK_TAG((c_class_itype), 5);\
370 
	( prom_ ) = DEREF_type ( x185_ + 1 ) ;\
 370 
	(prom_) = DEREF_type(x185_ + 1);\
371 
	( cases_ ) = DEREF_list ( x185_ + 2 ) ;\
 371 
	(cases_) = DEREF_list(x185_ + 2);\
372 
	( unprom_ ) = DEREF_ntype ( x185_ + 3 ) ;\
 372 
	(unprom_) = DEREF_ntype(x185_ + 3);\
373 
	( itok_ ) = DEREF_ulong ( x185_ + 4 ) ;\
 373 
	(itok_) = DEREF_ulong(x185_ + 4);\
374 
	( ntok_ ) = DEREF_ulong ( x185_ + 5 ) ;\
 374 
	(ntok_) = DEREF_ulong(x185_ + 5);\
375 
	( diag_ ) = DEREF_ulong ( x185_ + 6 ) ;\
 375 
	(diag_) = DEREF_ulong(x185_ + 6);\
376 
	( tok_ ) = DEREF_id ( x185_ + 7 ) ;\
 376 
	(tok_) = DEREF_id(x185_ + 7);\
377 
	( args_ ) = DEREF_list ( x185_ + 8 ) ;\
 377 
	(args_) = DEREF_list(x185_ + 8);\
378 
    }
 378 
    }
379 
 
 379 
 
380 
#define DESTROY_itype_token( destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, tok_, args_, c_class_itype )\
 380 
#define DESTROY_itype_token(destroyer_, prom_, cases_, unprom_, itok_, ntok_, diag_, tok_, args_, c_class_itype)\
381 
    {\
 381 
    {\
382 
	c_class *x186_ = CHECK_TAG ( ( c_class_itype ), 5 ) ;\
 382 
	c_class *x186_ = CHECK_TAG((c_class_itype), 5);\
383 
	( prom_ ) = DEREF_type ( x186_ + 1 ) ;\
 383 
	(prom_) = DEREF_type(x186_ + 1);\
384 
	( cases_ ) = DEREF_list ( x186_ + 2 ) ;\
 384 
	(cases_) = DEREF_list(x186_ + 2);\
385 
	( unprom_ ) = DEREF_ntype ( x186_ + 3 ) ;\
 385 
	(unprom_) = DEREF_ntype(x186_ + 3);\
386 
	( itok_ ) = DEREF_ulong ( x186_ + 4 ) ;\
 386 
	(itok_) = DEREF_ulong(x186_ + 4);\
387 
	( ntok_ ) = DEREF_ulong ( x186_ + 5 ) ;\
 387 
	(ntok_) = DEREF_ulong(x186_ + 5);\
388 
	( diag_ ) = DEREF_ulong ( x186_ + 6 ) ;\
 388 
	(diag_) = DEREF_ulong(x186_ + 6);\
389 
	( tok_ ) = DEREF_id ( x186_ + 7 ) ;\
 389 
	(tok_) = DEREF_id(x186_ + 7);\
390 
	( args_ ) = DEREF_list ( x186_ + 8 ) ;\
 390 
	(args_) = DEREF_list(x186_ + 8);\
391 
	( destroyer_ ) ( x186_, ( unsigned ) 9 ) ;\
 391 
	(destroyer_)(x186_, (unsigned)9);\
392 
    }
 392 
    }
393 
 
 393 
 
394 
 
 394 
 
395 
#endif
 395 
#endif