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 ID_OPS_H_INCLUDED
36 
#define ID_OPS_H_INCLUDED
37 
 
38 
/* Operations for union IDENTIFIER */
39 
 
6 7u83 40 
#define TAG_id(P)			(CHECK_NULL(P)->ag_tag)
2 7u83 41 
 
42 
 
43 
/* Operations for component name of union IDENTIFIER */
44 
 
6 7u83 45 
#define id_name(P)			(CHECK_NULL(P) + 1)
2 7u83 46 
 
47 
 
48 
/* Operations for component storage of union IDENTIFIER */
49 
 
6 7u83 50 
#define id_storage(P)			(CHECK_NULL(P) + 2)
2 7u83 51 
 
52 
 
53 
/* Operations for component parent of union IDENTIFIER */
54 
 
6 7u83 55 
#define id_parent(P)			(CHECK_NULL(P) + 3)
2 7u83 56 
 
57 
 
58 
/* Operations for component loc of union IDENTIFIER */
59 
 
6 7u83 60 
#define id_loc(P)			(CHECK_NULL(P) + 4)
2 7u83 61 
 
62 
 
63 
/* Operations for component alias of union IDENTIFIER */
64 
 
6 7u83 65 
#define id_alias(P)			(CHECK_NULL(P) + 7)
2 7u83 66 
 
67 
 
68 
/* Operations for component no of union IDENTIFIER */
69 
 
6 7u83 70 
#define id_no(P)			(CHECK_NULL(P) + 8)
2 7u83 71 
 
72 
 
73 
/* Operations for component dump of union IDENTIFIER */
74 
 
6 7u83 75 
#define id_dump(P)			(CHECK_NULL(P) + 9)
2 7u83 76 
 
77 
 
78 
/* Operations for field dummy of union IDENTIFIER */
79 
 
6 7u83 80 
#define id_dummy_tag			((unsigned)0)
81 
#define IS_id_dummy(P)			(CHECK_NULL(P)->ag_tag == 0)
2 7u83 82 
 
83 
 
6 7u83 84 
#define MAKE_id_dummy(name_, storage_, parent_, loc_, c_class_id)\
2 7u83 85 
    {\
6 7u83 86 
	c_class *x317_ = GEN_c_class(10, TYPEID_id);\
87 
	x317_->ag_tag = 0;\
88 
	COPY_hashid(x317_ + 1, (name_));\
89 
	COPY_dspec(x317_ + 2, (storage_));\
90 
	COPY_nspace(x317_ + 3, (parent_));\
91 
	COPY_ulong(x317_ + 4, (loc_).line);\
92 
	COPY_ulong(x317_ + 5, (loc_).column);\
93 
	COPY_ptr(x317_ + 6, (loc_).posn);\
94 
	COPY_id(x317_ + 7, x317_);\
95 
	COPY_ulong(x317_ + 8, LINK_NONE);\
96 
	COPY_ulong(x317_ + 9, LINK_NONE);\
97 
	(c_class_id) = x317_;\
2 7u83 98 
    }
99 
 
6 7u83 100 
#define DECONS_id_dummy(name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 101 
    {\
6 7u83 102 
	c_class *x318_ = CHECK_TAG((c_class_id), 0);\
103 
	(name_) = DEREF_hashid(x318_ + 1);\
104 
	(storage_) = DEREF_dspec(x318_ + 2);\
105 
	(parent_) = DEREF_nspace(x318_ + 3);\
106 
	(loc_).line = DEREF_ulong(x318_ + 4);\
107 
	(loc_).column = DEREF_ulong(x318_ + 5);\
108 
	(loc_).posn = DEREF_ptr(x318_ + 6);\
109 
	(alias_) = DEREF_id(x318_ + 7);\
110 
	(no_) = DEREF_ulong(x318_ + 8);\
111 
	(dump_) = DEREF_ulong(x318_ + 9);\
2 7u83 112 
    }
113 
 
6 7u83 114 
#define DESTROY_id_dummy(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 115 
    {\
6 7u83 116 
	c_class *x319_ = CHECK_TAG((c_class_id), 0);\
117 
	(name_) = DEREF_hashid(x319_ + 1);\
118 
	(storage_) = DEREF_dspec(x319_ + 2);\
119 
	(parent_) = DEREF_nspace(x319_ + 3);\
120 
	(loc_).line = DEREF_ulong(x319_ + 4);\
121 
	(loc_).column = DEREF_ulong(x319_ + 5);\
122 
	(loc_).posn = DEREF_ptr(x319_ + 6);\
123 
	(alias_) = DEREF_id(x319_ + 7);\
124 
	(no_) = DEREF_ulong(x319_ + 8);\
125 
	(dump_) = DEREF_ulong(x319_ + 9);\
126 
	(destroyer_)(x319_, (unsigned)10);\
2 7u83 127 
    }
128 
 
129 
 
130 
/* Operations for field set keyword_etc of union IDENTIFIER */
131 
 
6 7u83 132 
#define id_keyword_etc_tag		((unsigned)4)
133 
#define IS_id_keyword_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 1) < (unsigned)3)
2 7u83 134 
 
135 
 
6 7u83 136 
#define MAKE_id_keyword_etc(tag, name_, storage_, parent_, loc_, c_class_id)\
2 7u83 137 
    {\
6 7u83 138 
	c_class *x320_ = GEN_c_class(10, TYPEID_id);\
139 
	x320_->ag_tag = (tag);\
140 
	COPY_hashid(x320_ + 1, (name_));\
141 
	COPY_dspec(x320_ + 2, (storage_));\
142 
	COPY_nspace(x320_ + 3, (parent_));\
143 
	COPY_ulong(x320_ + 4, (loc_).line);\
144 
	COPY_ulong(x320_ + 5, (loc_).column);\
145 
	COPY_ptr(x320_ + 6, (loc_).posn);\
146 
	COPY_id(x320_ + 7, x320_);\
147 
	COPY_ulong(x320_ + 8, LINK_NONE);\
148 
	COPY_ulong(x320_ + 9, LINK_NONE);\
149 
	(c_class_id) = CHECK_TAG_ETC(x320_, 1, 4);\
2 7u83 150 
    }
151 
 
6 7u83 152 
#define MODIFY_id_keyword_etc(tag, c_class_id)\
2 7u83 153 
    {\
6 7u83 154 
	c_class *x321_ = CHECK_TAG_ETC ((c_class_id), 1, 4);\
155 
	x321_->ag_tag = (tag);\
156 
	(void) CHECK_TAG_ETC (x321_, 1, 4);\
2 7u83 157 
    }
158 
 
6 7u83 159 
#define DECONS_id_keyword_etc(name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 160 
    {\
6 7u83 161 
	c_class *x322_ = CHECK_TAG_ETC((c_class_id), 1, 4);\
162 
	(name_) = DEREF_hashid(x322_ + 1);\
163 
	(storage_) = DEREF_dspec(x322_ + 2);\
164 
	(parent_) = DEREF_nspace(x322_ + 3);\
165 
	(loc_).line = DEREF_ulong(x322_ + 4);\
166 
	(loc_).column = DEREF_ulong(x322_ + 5);\
167 
	(loc_).posn = DEREF_ptr(x322_ + 6);\
168 
	(alias_) = DEREF_id(x322_ + 7);\
169 
	(no_) = DEREF_ulong(x322_ + 8);\
170 
	(dump_) = DEREF_ulong(x322_ + 9);\
2 7u83 171 
    }
172 
 
6 7u83 173 
#define DESTROY_id_keyword_etc(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 174 
    {\
6 7u83 175 
	c_class *x323_ = CHECK_TAG_ETC((c_class_id), 1, 4);\
176 
	(name_) = DEREF_hashid(x323_ + 1);\
177 
	(storage_) = DEREF_dspec(x323_ + 2);\
178 
	(parent_) = DEREF_nspace(x323_ + 3);\
179 
	(loc_).line = DEREF_ulong(x323_ + 4);\
180 
	(loc_).column = DEREF_ulong(x323_ + 5);\
181 
	(loc_).posn = DEREF_ptr(x323_ + 6);\
182 
	(alias_) = DEREF_id(x323_ + 7);\
183 
	(no_) = DEREF_ulong(x323_ + 8);\
184 
	(dump_) = DEREF_ulong(x323_ + 9);\
185 
	(destroyer_)(x323_, (unsigned)10);\
2 7u83 186 
    }
187 
 
188 
 
189 
/* Operations for field keyword of union IDENTIFIER */
190 
 
6 7u83 191 
#define id_keyword_tag			((unsigned)1)
192 
#define IS_id_keyword(P)		(CHECK_NULL(P)->ag_tag == 1)
2 7u83 193 
 
194 
 
6 7u83 195 
#define MAKE_id_keyword(name_, storage_, parent_, loc_, c_class_id)\
2 7u83 196 
    {\
6 7u83 197 
	c_class *x324_ = GEN_c_class(10, TYPEID_id);\
198 
	x324_->ag_tag = 1;\
199 
	COPY_hashid(x324_ + 1, (name_));\
200 
	COPY_dspec(x324_ + 2, (storage_));\
201 
	COPY_nspace(x324_ + 3, (parent_));\
202 
	COPY_ulong(x324_ + 4, (loc_).line);\
203 
	COPY_ulong(x324_ + 5, (loc_).column);\
204 
	COPY_ptr(x324_ + 6, (loc_).posn);\
205 
	COPY_id(x324_ + 7, x324_);\
206 
	COPY_ulong(x324_ + 8, LINK_NONE);\
207 
	COPY_ulong(x324_ + 9, LINK_NONE);\
208 
	(c_class_id) = x324_;\
2 7u83 209 
    }
210 
 
6 7u83 211 
#define DECONS_id_keyword(name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 212 
    {\
6 7u83 213 
	c_class *x325_ = CHECK_TAG((c_class_id), 1);\
214 
	(name_) = DEREF_hashid(x325_ + 1);\
215 
	(storage_) = DEREF_dspec(x325_ + 2);\
216 
	(parent_) = DEREF_nspace(x325_ + 3);\
217 
	(loc_).line = DEREF_ulong(x325_ + 4);\
218 
	(loc_).column = DEREF_ulong(x325_ + 5);\
219 
	(loc_).posn = DEREF_ptr(x325_ + 6);\
220 
	(alias_) = DEREF_id(x325_ + 7);\
221 
	(no_) = DEREF_ulong(x325_ + 8);\
222 
	(dump_) = DEREF_ulong(x325_ + 9);\
2 7u83 223 
    }
224 
 
6 7u83 225 
#define DESTROY_id_keyword(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 226 
    {\
6 7u83 227 
	c_class *x326_ = CHECK_TAG((c_class_id), 1);\
228 
	(name_) = DEREF_hashid(x326_ + 1);\
229 
	(storage_) = DEREF_dspec(x326_ + 2);\
230 
	(parent_) = DEREF_nspace(x326_ + 3);\
231 
	(loc_).line = DEREF_ulong(x326_ + 4);\
232 
	(loc_).column = DEREF_ulong(x326_ + 5);\
233 
	(loc_).posn = DEREF_ptr(x326_ + 6);\
234 
	(alias_) = DEREF_id(x326_ + 7);\
235 
	(no_) = DEREF_ulong(x326_ + 8);\
236 
	(dump_) = DEREF_ulong(x326_ + 9);\
237 
	(destroyer_)(x326_, (unsigned)10);\
2 7u83 238 
    }
239 
 
240 
 
241 
/* Operations for field iso_keyword of union IDENTIFIER */
242 
 
6 7u83 243 
#define id_iso_keyword_tag		((unsigned)2)
244 
#define IS_id_iso_keyword(P)		(CHECK_NULL(P)->ag_tag == 2)
2 7u83 245 
 
246 
 
6 7u83 247 
#define MAKE_id_iso_keyword(name_, storage_, parent_, loc_, c_class_id)\
2 7u83 248 
    {\
6 7u83 249 
	c_class *x327_ = GEN_c_class(10, TYPEID_id);\
250 
	x327_->ag_tag = 2;\
251 
	COPY_hashid(x327_ + 1, (name_));\
252 
	COPY_dspec(x327_ + 2, (storage_));\
253 
	COPY_nspace(x327_ + 3, (parent_));\
254 
	COPY_ulong(x327_ + 4, (loc_).line);\
255 
	COPY_ulong(x327_ + 5, (loc_).column);\
256 
	COPY_ptr(x327_ + 6, (loc_).posn);\
257 
	COPY_id(x327_ + 7, x327_);\
258 
	COPY_ulong(x327_ + 8, LINK_NONE);\
259 
	COPY_ulong(x327_ + 9, LINK_NONE);\
260 
	(c_class_id) = x327_;\
2 7u83 261 
    }
262 
 
6 7u83 263 
#define DECONS_id_iso_keyword(name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 264 
    {\
6 7u83 265 
	c_class *x328_ = CHECK_TAG((c_class_id), 2);\
266 
	(name_) = DEREF_hashid(x328_ + 1);\
267 
	(storage_) = DEREF_dspec(x328_ + 2);\
268 
	(parent_) = DEREF_nspace(x328_ + 3);\
269 
	(loc_).line = DEREF_ulong(x328_ + 4);\
270 
	(loc_).column = DEREF_ulong(x328_ + 5);\
271 
	(loc_).posn = DEREF_ptr(x328_ + 6);\
272 
	(alias_) = DEREF_id(x328_ + 7);\
273 
	(no_) = DEREF_ulong(x328_ + 8);\
274 
	(dump_) = DEREF_ulong(x328_ + 9);\
2 7u83 275 
    }
276 
 
6 7u83 277 
#define DESTROY_id_iso_keyword(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 278 
    {\
6 7u83 279 
	c_class *x329_ = CHECK_TAG((c_class_id), 2);\
280 
	(name_) = DEREF_hashid(x329_ + 1);\
281 
	(storage_) = DEREF_dspec(x329_ + 2);\
282 
	(parent_) = DEREF_nspace(x329_ + 3);\
283 
	(loc_).line = DEREF_ulong(x329_ + 4);\
284 
	(loc_).column = DEREF_ulong(x329_ + 5);\
285 
	(loc_).posn = DEREF_ptr(x329_ + 6);\
286 
	(alias_) = DEREF_id(x329_ + 7);\
287 
	(no_) = DEREF_ulong(x329_ + 8);\
288 
	(dump_) = DEREF_ulong(x329_ + 9);\
289 
	(destroyer_)(x329_, (unsigned)10);\
2 7u83 290 
    }
291 
 
292 
 
293 
/* Operations for field reserved of union IDENTIFIER */
294 
 
6 7u83 295 
#define id_reserved_tag			((unsigned)3)
296 
#define IS_id_reserved(P)		(CHECK_NULL(P)->ag_tag == 3)
2 7u83 297 
 
298 
 
6 7u83 299 
#define MAKE_id_reserved(name_, storage_, parent_, loc_, c_class_id)\
2 7u83 300 
    {\
6 7u83 301 
	c_class *x330_ = GEN_c_class(10, TYPEID_id);\
302 
	x330_->ag_tag = 3;\
303 
	COPY_hashid(x330_ + 1, (name_));\
304 
	COPY_dspec(x330_ + 2, (storage_));\
305 
	COPY_nspace(x330_ + 3, (parent_));\
306 
	COPY_ulong(x330_ + 4, (loc_).line);\
307 
	COPY_ulong(x330_ + 5, (loc_).column);\
308 
	COPY_ptr(x330_ + 6, (loc_).posn);\
309 
	COPY_id(x330_ + 7, x330_);\
310 
	COPY_ulong(x330_ + 8, LINK_NONE);\
311 
	COPY_ulong(x330_ + 9, LINK_NONE);\
312 
	(c_class_id) = x330_;\
2 7u83 313 
    }
314 
 
6 7u83 315 
#define DECONS_id_reserved(name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 316 
    {\
6 7u83 317 
	c_class *x331_ = CHECK_TAG((c_class_id), 3);\
318 
	(name_) = DEREF_hashid(x331_ + 1);\
319 
	(storage_) = DEREF_dspec(x331_ + 2);\
320 
	(parent_) = DEREF_nspace(x331_ + 3);\
321 
	(loc_).line = DEREF_ulong(x331_ + 4);\
322 
	(loc_).column = DEREF_ulong(x331_ + 5);\
323 
	(loc_).posn = DEREF_ptr(x331_ + 6);\
324 
	(alias_) = DEREF_id(x331_ + 7);\
325 
	(no_) = DEREF_ulong(x331_ + 8);\
326 
	(dump_) = DEREF_ulong(x331_ + 9);\
2 7u83 327 
    }
328 
 
6 7u83 329 
#define DESTROY_id_reserved(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 330 
    {\
6 7u83 331 
	c_class *x332_ = CHECK_TAG((c_class_id), 3);\
332 
	(name_) = DEREF_hashid(x332_ + 1);\
333 
	(storage_) = DEREF_dspec(x332_ + 2);\
334 
	(parent_) = DEREF_nspace(x332_ + 3);\
335 
	(loc_).line = DEREF_ulong(x332_ + 4);\
336 
	(loc_).column = DEREF_ulong(x332_ + 5);\
337 
	(loc_).posn = DEREF_ptr(x332_ + 6);\
338 
	(alias_) = DEREF_id(x332_ + 7);\
339 
	(no_) = DEREF_ulong(x332_ + 8);\
340 
	(dump_) = DEREF_ulong(x332_ + 9);\
341 
	(destroyer_)(x332_, (unsigned)10);\
2 7u83 342 
    }
343 
 
344 
 
345 
/* Operations for field builtin of union IDENTIFIER */
346 
 
6 7u83 347 
#define id_builtin_tag			((unsigned)4)
348 
#define IS_id_builtin(P)		(CHECK_NULL(P)->ag_tag == 4)
2 7u83 349 
 
6 7u83 350 
#define id_builtin_ret(P)		(CHECK_TAG((P), 4) + 10)
351 
#define id_builtin_ptypes(P)		(CHECK_TAG((P), 4) + 11)
2 7u83 352 
 
6 7u83 353 
#define MAKE_id_builtin(name_, storage_, parent_, loc_, ret_, ptypes_, c_class_id)\
2 7u83 354 
    {\
6 7u83 355 
	c_class *x333_ = GEN_c_class(12, TYPEID_id);\
356 
	x333_->ag_tag = 4;\
357 
	COPY_hashid(x333_ + 1, (name_));\
358 
	COPY_dspec(x333_ + 2, (storage_));\
359 
	COPY_nspace(x333_ + 3, (parent_));\
360 
	COPY_ulong(x333_ + 4, (loc_).line);\
361 
	COPY_ulong(x333_ + 5, (loc_).column);\
362 
	COPY_ptr(x333_ + 6, (loc_).posn);\
363 
	COPY_id(x333_ + 7, x333_);\
364 
	COPY_ulong(x333_ + 8, LINK_NONE);\
365 
	COPY_ulong(x333_ + 9, LINK_NONE);\
366 
	COPY_type(x333_ + 10, (ret_));\
367 
	COPY_list(x333_ + 11, (ptypes_));\
368 
	(c_class_id) = x333_;\
2 7u83 369 
    }
370 
 
6 7u83 371 
#define DECONS_id_builtin(name_, storage_, parent_, loc_, alias_, no_, dump_, ret_, ptypes_, c_class_id)\
2 7u83 372 
    {\
6 7u83 373 
	c_class *x334_ = CHECK_TAG((c_class_id), 4);\
374 
	(name_) = DEREF_hashid(x334_ + 1);\
375 
	(storage_) = DEREF_dspec(x334_ + 2);\
376 
	(parent_) = DEREF_nspace(x334_ + 3);\
377 
	(loc_).line = DEREF_ulong(x334_ + 4);\
378 
	(loc_).column = DEREF_ulong(x334_ + 5);\
379 
	(loc_).posn = DEREF_ptr(x334_ + 6);\
380 
	(alias_) = DEREF_id(x334_ + 7);\
381 
	(no_) = DEREF_ulong(x334_ + 8);\
382 
	(dump_) = DEREF_ulong(x334_ + 9);\
383 
	(ret_) = DEREF_type(x334_ + 10);\
384 
	(ptypes_) = DEREF_list(x334_ + 11);\
2 7u83 385 
    }
386 
 
6 7u83 387 
#define DESTROY_id_builtin(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, ret_, ptypes_, c_class_id)\
2 7u83 388 
    {\
6 7u83 389 
	c_class *x335_ = CHECK_TAG((c_class_id), 4);\
390 
	(name_) = DEREF_hashid(x335_ + 1);\
391 
	(storage_) = DEREF_dspec(x335_ + 2);\
392 
	(parent_) = DEREF_nspace(x335_ + 3);\
393 
	(loc_).line = DEREF_ulong(x335_ + 4);\
394 
	(loc_).column = DEREF_ulong(x335_ + 5);\
395 
	(loc_).posn = DEREF_ptr(x335_ + 6);\
396 
	(alias_) = DEREF_id(x335_ + 7);\
397 
	(no_) = DEREF_ulong(x335_ + 8);\
398 
	(dump_) = DEREF_ulong(x335_ + 9);\
399 
	(ret_) = DEREF_type(x335_ + 10);\
400 
	(ptypes_) = DEREF_list(x335_ + 11);\
401 
	(destroyer_)(x335_, (unsigned)12);\
2 7u83 402 
    }
403 
 
404 
 
405 
/* Operations for field obj_macro of union IDENTIFIER */
406 
 
6 7u83 407 
#define id_obj_macro_tag		((unsigned)5)
408 
#define IS_id_obj_macro(P)		(CHECK_NULL(P)->ag_tag == 5)
2 7u83 409 
 
6 7u83 410 
#define id_obj_macro_defn(P)		(CHECK_TAG((P), 5) + 10)
2 7u83 411 
 
6 7u83 412 
#define MAKE_id_obj_macro(name_, storage_, parent_, loc_, defn_, c_class_id)\
2 7u83 413 
    {\
6 7u83 414 
	c_class *x336_ = GEN_c_class(11, TYPEID_id);\
415 
	x336_->ag_tag = 5;\
416 
	COPY_hashid(x336_ + 1, (name_));\
417 
	COPY_dspec(x336_ + 2, (storage_));\
418 
	COPY_nspace(x336_ + 3, (parent_));\
419 
	COPY_ulong(x336_ + 4, (loc_).line);\
420 
	COPY_ulong(x336_ + 5, (loc_).column);\
421 
	COPY_ptr(x336_ + 6, (loc_).posn);\
422 
	COPY_id(x336_ + 7, x336_);\
423 
	COPY_ulong(x336_ + 8, LINK_NONE);\
424 
	COPY_ulong(x336_ + 9, LINK_NONE);\
425 
	COPY_pptok(x336_ + 10, (defn_));\
426 
	(c_class_id) = x336_;\
2 7u83 427 
    }
428 
 
6 7u83 429 
#define DECONS_id_obj_macro(name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, c_class_id)\
2 7u83 430 
    {\
6 7u83 431 
	c_class *x337_ = CHECK_TAG((c_class_id), 5);\
432 
	(name_) = DEREF_hashid(x337_ + 1);\
433 
	(storage_) = DEREF_dspec(x337_ + 2);\
434 
	(parent_) = DEREF_nspace(x337_ + 3);\
435 
	(loc_).line = DEREF_ulong(x337_ + 4);\
436 
	(loc_).column = DEREF_ulong(x337_ + 5);\
437 
	(loc_).posn = DEREF_ptr(x337_ + 6);\
438 
	(alias_) = DEREF_id(x337_ + 7);\
439 
	(no_) = DEREF_ulong(x337_ + 8);\
440 
	(dump_) = DEREF_ulong(x337_ + 9);\
441 
	(defn_) = DEREF_pptok(x337_ + 10);\
2 7u83 442 
    }
443 
 
6 7u83 444 
#define DESTROY_id_obj_macro(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, c_class_id)\
2 7u83 445 
    {\
6 7u83 446 
	c_class *x338_ = CHECK_TAG((c_class_id), 5);\
447 
	(name_) = DEREF_hashid(x338_ + 1);\
448 
	(storage_) = DEREF_dspec(x338_ + 2);\
449 
	(parent_) = DEREF_nspace(x338_ + 3);\
450 
	(loc_).line = DEREF_ulong(x338_ + 4);\
451 
	(loc_).column = DEREF_ulong(x338_ + 5);\
452 
	(loc_).posn = DEREF_ptr(x338_ + 6);\
453 
	(alias_) = DEREF_id(x338_ + 7);\
454 
	(no_) = DEREF_ulong(x338_ + 8);\
455 
	(dump_) = DEREF_ulong(x338_ + 9);\
456 
	(defn_) = DEREF_pptok(x338_ + 10);\
457 
	(destroyer_)(x338_, (unsigned)11);\
2 7u83 458 
    }
459 
 
460 
 
461 
/* Operations for field func_macro of union IDENTIFIER */
462 
 
6 7u83 463 
#define id_func_macro_tag		((unsigned)6)
464 
#define IS_id_func_macro(P)		(CHECK_NULL(P)->ag_tag == 6)
2 7u83 465 
 
6 7u83 466 
#define id_func_macro_defn(P)		(CHECK_TAG((P), 6) + 10)
467 
#define id_func_macro_params(P)		(CHECK_TAG((P), 6) + 11)
468 
#define id_func_macro_no_params(P)	(CHECK_TAG((P), 6) + 12)
2 7u83 469 
 
6 7u83 470 
#define MAKE_id_func_macro(name_, storage_, parent_, loc_, defn_, params_, no_params_, c_class_id)\
2 7u83 471 
    {\
6 7u83 472 
	c_class *x339_ = GEN_c_class(13, TYPEID_id);\
473 
	x339_->ag_tag = 6;\
474 
	COPY_hashid(x339_ + 1, (name_));\
475 
	COPY_dspec(x339_ + 2, (storage_));\
476 
	COPY_nspace(x339_ + 3, (parent_));\
477 
	COPY_ulong(x339_ + 4, (loc_).line);\
478 
	COPY_ulong(x339_ + 5, (loc_).column);\
479 
	COPY_ptr(x339_ + 6, (loc_).posn);\
480 
	COPY_id(x339_ + 7, x339_);\
481 
	COPY_ulong(x339_ + 8, LINK_NONE);\
482 
	COPY_ulong(x339_ + 9, LINK_NONE);\
483 
	COPY_pptok(x339_ + 10, (defn_));\
484 
	COPY_list(x339_ + 11, (params_));\
485 
	COPY_unsigned(x339_ + 12, (no_params_));\
486 
	(c_class_id) = x339_;\
2 7u83 487 
    }
488 
 
6 7u83 489 
#define DECONS_id_func_macro(name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, params_, no_params_, c_class_id)\
2 7u83 490 
    {\
6 7u83 491 
	c_class *x340_ = CHECK_TAG((c_class_id), 6);\
492 
	(name_) = DEREF_hashid(x340_ + 1);\
493 
	(storage_) = DEREF_dspec(x340_ + 2);\
494 
	(parent_) = DEREF_nspace(x340_ + 3);\
495 
	(loc_).line = DEREF_ulong(x340_ + 4);\
496 
	(loc_).column = DEREF_ulong(x340_ + 5);\
497 
	(loc_).posn = DEREF_ptr(x340_ + 6);\
498 
	(alias_) = DEREF_id(x340_ + 7);\
499 
	(no_) = DEREF_ulong(x340_ + 8);\
500 
	(dump_) = DEREF_ulong(x340_ + 9);\
501 
	(defn_) = DEREF_pptok(x340_ + 10);\
502 
	(params_) = DEREF_list(x340_ + 11);\
503 
	(no_params_) = DEREF_unsigned(x340_ + 12);\
2 7u83 504 
    }
505 
 
6 7u83 506 
#define DESTROY_id_func_macro(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, params_, no_params_, c_class_id)\
2 7u83 507 
    {\
6 7u83 508 
	c_class *x341_ = CHECK_TAG((c_class_id), 6);\
509 
	(name_) = DEREF_hashid(x341_ + 1);\
510 
	(storage_) = DEREF_dspec(x341_ + 2);\
511 
	(parent_) = DEREF_nspace(x341_ + 3);\
512 
	(loc_).line = DEREF_ulong(x341_ + 4);\
513 
	(loc_).column = DEREF_ulong(x341_ + 5);\
514 
	(loc_).posn = DEREF_ptr(x341_ + 6);\
515 
	(alias_) = DEREF_id(x341_ + 7);\
516 
	(no_) = DEREF_ulong(x341_ + 8);\
517 
	(dump_) = DEREF_ulong(x341_ + 9);\
518 
	(defn_) = DEREF_pptok(x341_ + 10);\
519 
	(params_) = DEREF_list(x341_ + 11);\
520 
	(no_params_) = DEREF_unsigned(x341_ + 12);\
521 
	(destroyer_)(x341_, (unsigned)13);\
2 7u83 522 
    }
523 
 
524 
 
525 
/* Operations for field predicate of union IDENTIFIER */
526 
 
6 7u83 527 
#define id_predicate_tag		((unsigned)7)
528 
#define IS_id_predicate(P)		(CHECK_NULL(P)->ag_tag == 7)
2 7u83 529 
 
6 7u83 530 
#define id_predicate_values(P)		(CHECK_TAG((P), 7) + 10)
2 7u83 531 
 
6 7u83 532 
#define MAKE_id_predicate(name_, storage_, parent_, loc_, c_class_id)\
2 7u83 533 
    {\
6 7u83 534 
	c_class *x342_ = GEN_c_class(11, TYPEID_id);\
535 
	x342_->ag_tag = 7;\
536 
	COPY_hashid(x342_ + 1, (name_));\
537 
	COPY_dspec(x342_ + 2, (storage_));\
538 
	COPY_nspace(x342_ + 3, (parent_));\
539 
	COPY_ulong(x342_ + 4, (loc_).line);\
540 
	COPY_ulong(x342_ + 5, (loc_).column);\
541 
	COPY_ptr(x342_ + 6, (loc_).posn);\
542 
	COPY_id(x342_ + 7, x342_);\
543 
	COPY_ulong(x342_ + 8, LINK_NONE);\
544 
	COPY_ulong(x342_ + 9, LINK_NONE);\
545 
	COPY_list(x342_ + 10, NULL_list ( PPTOKEN_P ));\
546 
	(c_class_id) = x342_;\
2 7u83 547 
    }
548 
 
6 7u83 549 
#define DECONS_id_predicate(name_, storage_, parent_, loc_, alias_, no_, dump_, values_, c_class_id)\
2 7u83 550 
    {\
6 7u83 551 
	c_class *x343_ = CHECK_TAG((c_class_id), 7);\
552 
	(name_) = DEREF_hashid(x343_ + 1);\
553 
	(storage_) = DEREF_dspec(x343_ + 2);\
554 
	(parent_) = DEREF_nspace(x343_ + 3);\
555 
	(loc_).line = DEREF_ulong(x343_ + 4);\
556 
	(loc_).column = DEREF_ulong(x343_ + 5);\
557 
	(loc_).posn = DEREF_ptr(x343_ + 6);\
558 
	(alias_) = DEREF_id(x343_ + 7);\
559 
	(no_) = DEREF_ulong(x343_ + 8);\
560 
	(dump_) = DEREF_ulong(x343_ + 9);\
561 
	(values_) = DEREF_list(x343_ + 10);\
2 7u83 562 
    }
563 
 
6 7u83 564 
#define DESTROY_id_predicate(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, values_, c_class_id)\
2 7u83 565 
    {\
6 7u83 566 
	c_class *x344_ = CHECK_TAG((c_class_id), 7);\
567 
	(name_) = DEREF_hashid(x344_ + 1);\
568 
	(storage_) = DEREF_dspec(x344_ + 2);\
569 
	(parent_) = DEREF_nspace(x344_ + 3);\
570 
	(loc_).line = DEREF_ulong(x344_ + 4);\
571 
	(loc_).column = DEREF_ulong(x344_ + 5);\
572 
	(loc_).posn = DEREF_ptr(x344_ + 6);\
573 
	(alias_) = DEREF_id(x344_ + 7);\
574 
	(no_) = DEREF_ulong(x344_ + 8);\
575 
	(dump_) = DEREF_ulong(x344_ + 9);\
576 
	(values_) = DEREF_list(x344_ + 10);\
577 
	(destroyer_)(x344_, (unsigned)11);\
2 7u83 578 
    }
579 
 
580 
 
581 
/* Operations for field set class_name_etc of union IDENTIFIER */
582 
 
6 7u83 583 
#define id_class_name_etc_tag		((unsigned)13)
584 
#define IS_id_class_name_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 8) < (unsigned)5)
2 7u83 585 
 
6 7u83 586 
#define id_class_name_etc_defn(P)	(CHECK_TAG_ETC((P), 8, 13) + 10)
587 
#define id_class_name_etc_rep(P)	(CHECK_TAG_ETC((P), 8, 13) + 11)
2 7u83 588 
 
6 7u83 589 
#define MAKE_id_class_name_etc(tag, name_, storage_, parent_, loc_, defn_, c_class_id)\
2 7u83 590 
    {\
6 7u83 591 
	c_class *x345_ = GEN_c_class(12, TYPEID_id);\
592 
	x345_->ag_tag = (tag);\
593 
	COPY_hashid(x345_ + 1, (name_));\
594 
	COPY_dspec(x345_ + 2, (storage_));\
595 
	COPY_nspace(x345_ + 3, (parent_));\
596 
	COPY_ulong(x345_ + 4, (loc_).line);\
597 
	COPY_ulong(x345_ + 5, (loc_).column);\
598 
	COPY_ptr(x345_ + 6, (loc_).posn);\
599 
	COPY_id(x345_ + 7, x345_);\
600 
	COPY_ulong(x345_ + 8, LINK_NONE);\
601 
	COPY_ulong(x345_ + 9, LINK_NONE);\
602 
	COPY_type(x345_ + 10, (defn_));\
603 
	COPY_btype(x345_ + 11, btype_none);\
604 
	(c_class_id) = CHECK_TAG_ETC(x345_, 8, 13);\
2 7u83 605 
    }
606 
 
6 7u83 607 
#define MODIFY_id_class_name_etc(tag, c_class_id)\
2 7u83 608 
    {\
6 7u83 609 
	c_class *x346_ = CHECK_TAG_ETC ((c_class_id), 8, 13);\
610 
	x346_->ag_tag = (tag);\
611 
	(void) CHECK_TAG_ETC (x346_, 8, 13);\
2 7u83 612 
    }
613 
 
6 7u83 614 
#define DECONS_id_class_name_etc(name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 615 
    {\
6 7u83 616 
	c_class *x347_ = CHECK_TAG_ETC((c_class_id), 8, 13);\
617 
	(name_) = DEREF_hashid(x347_ + 1);\
618 
	(storage_) = DEREF_dspec(x347_ + 2);\
619 
	(parent_) = DEREF_nspace(x347_ + 3);\
620 
	(loc_).line = DEREF_ulong(x347_ + 4);\
621 
	(loc_).column = DEREF_ulong(x347_ + 5);\
622 
	(loc_).posn = DEREF_ptr(x347_ + 6);\
623 
	(alias_) = DEREF_id(x347_ + 7);\
624 
	(no_) = DEREF_ulong(x347_ + 8);\
625 
	(dump_) = DEREF_ulong(x347_ + 9);\
626 
	(defn_) = DEREF_type(x347_ + 10);\
627 
	(rep_) = DEREF_btype(x347_ + 11);\
2 7u83 628 
    }
629 
 
6 7u83 630 
#define DESTROY_id_class_name_etc(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 631 
    {\
6 7u83 632 
	c_class *x348_ = CHECK_TAG_ETC((c_class_id), 8, 13);\
633 
	(name_) = DEREF_hashid(x348_ + 1);\
634 
	(storage_) = DEREF_dspec(x348_ + 2);\
635 
	(parent_) = DEREF_nspace(x348_ + 3);\
636 
	(loc_).line = DEREF_ulong(x348_ + 4);\
637 
	(loc_).column = DEREF_ulong(x348_ + 5);\
638 
	(loc_).posn = DEREF_ptr(x348_ + 6);\
639 
	(alias_) = DEREF_id(x348_ + 7);\
640 
	(no_) = DEREF_ulong(x348_ + 8);\
641 
	(dump_) = DEREF_ulong(x348_ + 9);\
642 
	(defn_) = DEREF_type(x348_ + 10);\
643 
	(rep_) = DEREF_btype(x348_ + 11);\
644 
	(destroyer_)(x348_, (unsigned)12);\
2 7u83 645 
    }
646 
 
647 
 
648 
/* Operations for field class_name of union IDENTIFIER */
649 
 
6 7u83 650 
#define id_class_name_tag		((unsigned)8)
651 
#define IS_id_class_name(P)		(CHECK_NULL(P)->ag_tag == 8)
2 7u83 652 
 
6 7u83 653 
#define id_class_name_defn(P)		(CHECK_TAG((P), 8) + 10)
654 
#define id_class_name_rep(P)		(CHECK_TAG((P), 8) + 11)
2 7u83 655 
 
6 7u83 656 
#define MAKE_id_class_name(name_, storage_, parent_, loc_, defn_, c_class_id)\
2 7u83 657 
    {\
6 7u83 658 
	c_class *x349_ = GEN_c_class(12, TYPEID_id);\
659 
	x349_->ag_tag = 8;\
660 
	COPY_hashid(x349_ + 1, (name_));\
661 
	COPY_dspec(x349_ + 2, (storage_));\
662 
	COPY_nspace(x349_ + 3, (parent_));\
663 
	COPY_ulong(x349_ + 4, (loc_).line);\
664 
	COPY_ulong(x349_ + 5, (loc_).column);\
665 
	COPY_ptr(x349_ + 6, (loc_).posn);\
666 
	COPY_id(x349_ + 7, x349_);\
667 
	COPY_ulong(x349_ + 8, LINK_NONE);\
668 
	COPY_ulong(x349_ + 9, LINK_NONE);\
669 
	COPY_type(x349_ + 10, (defn_));\
670 
	COPY_btype(x349_ + 11, btype_none);\
671 
	(c_class_id) = x349_;\
2 7u83 672 
    }
673 
 
6 7u83 674 
#define DECONS_id_class_name(name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 675 
    {\
6 7u83 676 
	c_class *x350_ = CHECK_TAG((c_class_id), 8);\
677 
	(name_) = DEREF_hashid(x350_ + 1);\
678 
	(storage_) = DEREF_dspec(x350_ + 2);\
679 
	(parent_) = DEREF_nspace(x350_ + 3);\
680 
	(loc_).line = DEREF_ulong(x350_ + 4);\
681 
	(loc_).column = DEREF_ulong(x350_ + 5);\
682 
	(loc_).posn = DEREF_ptr(x350_ + 6);\
683 
	(alias_) = DEREF_id(x350_ + 7);\
684 
	(no_) = DEREF_ulong(x350_ + 8);\
685 
	(dump_) = DEREF_ulong(x350_ + 9);\
686 
	(defn_) = DEREF_type(x350_ + 10);\
687 
	(rep_) = DEREF_btype(x350_ + 11);\
2 7u83 688 
    }
689 
 
6 7u83 690 
#define DESTROY_id_class_name(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 691 
    {\
6 7u83 692 
	c_class *x351_ = CHECK_TAG((c_class_id), 8);\
693 
	(name_) = DEREF_hashid(x351_ + 1);\
694 
	(storage_) = DEREF_dspec(x351_ + 2);\
695 
	(parent_) = DEREF_nspace(x351_ + 3);\
696 
	(loc_).line = DEREF_ulong(x351_ + 4);\
697 
	(loc_).column = DEREF_ulong(x351_ + 5);\
698 
	(loc_).posn = DEREF_ptr(x351_ + 6);\
699 
	(alias_) = DEREF_id(x351_ + 7);\
700 
	(no_) = DEREF_ulong(x351_ + 8);\
701 
	(dump_) = DEREF_ulong(x351_ + 9);\
702 
	(defn_) = DEREF_type(x351_ + 10);\
703 
	(rep_) = DEREF_btype(x351_ + 11);\
704 
	(destroyer_)(x351_, (unsigned)12);\
2 7u83 705 
    }
706 
 
707 
 
708 
/* Operations for field enum_name of union IDENTIFIER */
709 
 
6 7u83 710 
#define id_enum_name_tag		((unsigned)9)
711 
#define IS_id_enum_name(P)		(CHECK_NULL(P)->ag_tag == 9)
2 7u83 712 
 
6 7u83 713 
#define id_enum_name_defn(P)		(CHECK_TAG((P), 9) + 10)
714 
#define id_enum_name_rep(P)		(CHECK_TAG((P), 9) + 11)
2 7u83 715 
 
6 7u83 716 
#define MAKE_id_enum_name(name_, storage_, parent_, loc_, defn_, c_class_id)\
2 7u83 717 
    {\
6 7u83 718 
	c_class *x352_ = GEN_c_class(12, TYPEID_id);\
719 
	x352_->ag_tag = 9;\
720 
	COPY_hashid(x352_ + 1, (name_));\
721 
	COPY_dspec(x352_ + 2, (storage_));\
722 
	COPY_nspace(x352_ + 3, (parent_));\
723 
	COPY_ulong(x352_ + 4, (loc_).line);\
724 
	COPY_ulong(x352_ + 5, (loc_).column);\
725 
	COPY_ptr(x352_ + 6, (loc_).posn);\
726 
	COPY_id(x352_ + 7, x352_);\
727 
	COPY_ulong(x352_ + 8, LINK_NONE);\
728 
	COPY_ulong(x352_ + 9, LINK_NONE);\
729 
	COPY_type(x352_ + 10, (defn_));\
730 
	COPY_btype(x352_ + 11, btype_none);\
731 
	(c_class_id) = x352_;\
2 7u83 732 
    }
733 
 
6 7u83 734 
#define DECONS_id_enum_name(name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 735 
    {\
6 7u83 736 
	c_class *x353_ = CHECK_TAG((c_class_id), 9);\
737 
	(name_) = DEREF_hashid(x353_ + 1);\
738 
	(storage_) = DEREF_dspec(x353_ + 2);\
739 
	(parent_) = DEREF_nspace(x353_ + 3);\
740 
	(loc_).line = DEREF_ulong(x353_ + 4);\
741 
	(loc_).column = DEREF_ulong(x353_ + 5);\
742 
	(loc_).posn = DEREF_ptr(x353_ + 6);\
743 
	(alias_) = DEREF_id(x353_ + 7);\
744 
	(no_) = DEREF_ulong(x353_ + 8);\
745 
	(dump_) = DEREF_ulong(x353_ + 9);\
746 
	(defn_) = DEREF_type(x353_ + 10);\
747 
	(rep_) = DEREF_btype(x353_ + 11);\
2 7u83 748 
    }
749 
 
6 7u83 750 
#define DESTROY_id_enum_name(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 751 
    {\
6 7u83 752 
	c_class *x354_ = CHECK_TAG((c_class_id), 9);\
753 
	(name_) = DEREF_hashid(x354_ + 1);\
754 
	(storage_) = DEREF_dspec(x354_ + 2);\
755 
	(parent_) = DEREF_nspace(x354_ + 3);\
756 
	(loc_).line = DEREF_ulong(x354_ + 4);\
757 
	(loc_).column = DEREF_ulong(x354_ + 5);\
758 
	(loc_).posn = DEREF_ptr(x354_ + 6);\
759 
	(alias_) = DEREF_id(x354_ + 7);\
760 
	(no_) = DEREF_ulong(x354_ + 8);\
761 
	(dump_) = DEREF_ulong(x354_ + 9);\
762 
	(defn_) = DEREF_type(x354_ + 10);\
763 
	(rep_) = DEREF_btype(x354_ + 11);\
764 
	(destroyer_)(x354_, (unsigned)12);\
2 7u83 765 
    }
766 
 
767 
 
768 
/* Operations for field class_alias of union IDENTIFIER */
769 
 
6 7u83 770 
#define id_class_alias_tag		((unsigned)10)
771 
#define IS_id_class_alias(P)		(CHECK_NULL(P)->ag_tag == 10)
2 7u83 772 
 
6 7u83 773 
#define id_class_alias_defn(P)		(CHECK_TAG((P), 10) + 10)
774 
#define id_class_alias_rep(P)		(CHECK_TAG((P), 10) + 11)
2 7u83 775 
 
6 7u83 776 
#define MAKE_id_class_alias(name_, storage_, parent_, loc_, defn_, c_class_id)\
2 7u83 777 
    {\
6 7u83 778 
	c_class *x355_ = GEN_c_class(12, TYPEID_id);\
779 
	x355_->ag_tag = 10;\
780 
	COPY_hashid(x355_ + 1, (name_));\
781 
	COPY_dspec(x355_ + 2, (storage_));\
782 
	COPY_nspace(x355_ + 3, (parent_));\
783 
	COPY_ulong(x355_ + 4, (loc_).line);\
784 
	COPY_ulong(x355_ + 5, (loc_).column);\
785 
	COPY_ptr(x355_ + 6, (loc_).posn);\
786 
	COPY_id(x355_ + 7, x355_);\
787 
	COPY_ulong(x355_ + 8, LINK_NONE);\
788 
	COPY_ulong(x355_ + 9, LINK_NONE);\
789 
	COPY_type(x355_ + 10, (defn_));\
790 
	COPY_btype(x355_ + 11, btype_none);\
791 
	(c_class_id) = x355_;\
2 7u83 792 
    }
793 
 
6 7u83 794 
#define DECONS_id_class_alias(name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 795 
    {\
6 7u83 796 
	c_class *x356_ = CHECK_TAG((c_class_id), 10);\
797 
	(name_) = DEREF_hashid(x356_ + 1);\
798 
	(storage_) = DEREF_dspec(x356_ + 2);\
799 
	(parent_) = DEREF_nspace(x356_ + 3);\
800 
	(loc_).line = DEREF_ulong(x356_ + 4);\
801 
	(loc_).column = DEREF_ulong(x356_ + 5);\
802 
	(loc_).posn = DEREF_ptr(x356_ + 6);\
803 
	(alias_) = DEREF_id(x356_ + 7);\
804 
	(no_) = DEREF_ulong(x356_ + 8);\
805 
	(dump_) = DEREF_ulong(x356_ + 9);\
806 
	(defn_) = DEREF_type(x356_ + 10);\
807 
	(rep_) = DEREF_btype(x356_ + 11);\
2 7u83 808 
    }
809 
 
6 7u83 810 
#define DESTROY_id_class_alias(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 811 
    {\
6 7u83 812 
	c_class *x357_ = CHECK_TAG((c_class_id), 10);\
813 
	(name_) = DEREF_hashid(x357_ + 1);\
814 
	(storage_) = DEREF_dspec(x357_ + 2);\
815 
	(parent_) = DEREF_nspace(x357_ + 3);\
816 
	(loc_).line = DEREF_ulong(x357_ + 4);\
817 
	(loc_).column = DEREF_ulong(x357_ + 5);\
818 
	(loc_).posn = DEREF_ptr(x357_ + 6);\
819 
	(alias_) = DEREF_id(x357_ + 7);\
820 
	(no_) = DEREF_ulong(x357_ + 8);\
821 
	(dump_) = DEREF_ulong(x357_ + 9);\
822 
	(defn_) = DEREF_type(x357_ + 10);\
823 
	(rep_) = DEREF_btype(x357_ + 11);\
824 
	(destroyer_)(x357_, (unsigned)12);\
2 7u83 825 
    }
826 
 
827 
 
828 
/* Operations for field enum_alias of union IDENTIFIER */
829 
 
6 7u83 830 
#define id_enum_alias_tag		((unsigned)11)
831 
#define IS_id_enum_alias(P)		(CHECK_NULL(P)->ag_tag == 11)
2 7u83 832 
 
6 7u83 833 
#define id_enum_alias_defn(P)		(CHECK_TAG((P), 11) + 10)
834 
#define id_enum_alias_rep(P)		(CHECK_TAG((P), 11) + 11)
2 7u83 835 
 
6 7u83 836 
#define MAKE_id_enum_alias(name_, storage_, parent_, loc_, defn_, c_class_id)\
2 7u83 837 
    {\
6 7u83 838 
	c_class *x358_ = GEN_c_class(12, TYPEID_id);\
839 
	x358_->ag_tag = 11;\
840 
	COPY_hashid(x358_ + 1, (name_));\
841 
	COPY_dspec(x358_ + 2, (storage_));\
842 
	COPY_nspace(x358_ + 3, (parent_));\
843 
	COPY_ulong(x358_ + 4, (loc_).line);\
844 
	COPY_ulong(x358_ + 5, (loc_).column);\
845 
	COPY_ptr(x358_ + 6, (loc_).posn);\
846 
	COPY_id(x358_ + 7, x358_);\
847 
	COPY_ulong(x358_ + 8, LINK_NONE);\
848 
	COPY_ulong(x358_ + 9, LINK_NONE);\
849 
	COPY_type(x358_ + 10, (defn_));\
850 
	COPY_btype(x358_ + 11, btype_none);\
851 
	(c_class_id) = x358_;\
2 7u83 852 
    }
853 
 
6 7u83 854 
#define DECONS_id_enum_alias(name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 855 
    {\
6 7u83 856 
	c_class *x359_ = CHECK_TAG((c_class_id), 11);\
857 
	(name_) = DEREF_hashid(x359_ + 1);\
858 
	(storage_) = DEREF_dspec(x359_ + 2);\
859 
	(parent_) = DEREF_nspace(x359_ + 3);\
860 
	(loc_).line = DEREF_ulong(x359_ + 4);\
861 
	(loc_).column = DEREF_ulong(x359_ + 5);\
862 
	(loc_).posn = DEREF_ptr(x359_ + 6);\
863 
	(alias_) = DEREF_id(x359_ + 7);\
864 
	(no_) = DEREF_ulong(x359_ + 8);\
865 
	(dump_) = DEREF_ulong(x359_ + 9);\
866 
	(defn_) = DEREF_type(x359_ + 10);\
867 
	(rep_) = DEREF_btype(x359_ + 11);\
2 7u83 868 
    }
869 
 
6 7u83 870 
#define DESTROY_id_enum_alias(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 871 
    {\
6 7u83 872 
	c_class *x360_ = CHECK_TAG((c_class_id), 11);\
873 
	(name_) = DEREF_hashid(x360_ + 1);\
874 
	(storage_) = DEREF_dspec(x360_ + 2);\
875 
	(parent_) = DEREF_nspace(x360_ + 3);\
876 
	(loc_).line = DEREF_ulong(x360_ + 4);\
877 
	(loc_).column = DEREF_ulong(x360_ + 5);\
878 
	(loc_).posn = DEREF_ptr(x360_ + 6);\
879 
	(alias_) = DEREF_id(x360_ + 7);\
880 
	(no_) = DEREF_ulong(x360_ + 8);\
881 
	(dump_) = DEREF_ulong(x360_ + 9);\
882 
	(defn_) = DEREF_type(x360_ + 10);\
883 
	(rep_) = DEREF_btype(x360_ + 11);\
884 
	(destroyer_)(x360_, (unsigned)12);\
2 7u83 885 
    }
886 
 
887 
 
888 
/* Operations for field type_alias of union IDENTIFIER */
889 
 
6 7u83 890 
#define id_type_alias_tag		((unsigned)12)
891 
#define IS_id_type_alias(P)		(CHECK_NULL(P)->ag_tag == 12)
2 7u83 892 
 
6 7u83 893 
#define id_type_alias_defn(P)		(CHECK_TAG((P), 12) + 10)
894 
#define id_type_alias_rep(P)		(CHECK_TAG((P), 12) + 11)
2 7u83 895 
 
6 7u83 896 
#define MAKE_id_type_alias(name_, storage_, parent_, loc_, defn_, c_class_id)\
2 7u83 897 
    {\
6 7u83 898 
	c_class *x361_ = GEN_c_class(12, TYPEID_id);\
899 
	x361_->ag_tag = 12;\
900 
	COPY_hashid(x361_ + 1, (name_));\
901 
	COPY_dspec(x361_ + 2, (storage_));\
902 
	COPY_nspace(x361_ + 3, (parent_));\
903 
	COPY_ulong(x361_ + 4, (loc_).line);\
904 
	COPY_ulong(x361_ + 5, (loc_).column);\
905 
	COPY_ptr(x361_ + 6, (loc_).posn);\
906 
	COPY_id(x361_ + 7, x361_);\
907 
	COPY_ulong(x361_ + 8, LINK_NONE);\
908 
	COPY_ulong(x361_ + 9, LINK_NONE);\
909 
	COPY_type(x361_ + 10, (defn_));\
910 
	COPY_btype(x361_ + 11, btype_none);\
911 
	(c_class_id) = x361_;\
2 7u83 912 
    }
913 
 
6 7u83 914 
#define DECONS_id_type_alias(name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 915 
    {\
6 7u83 916 
	c_class *x362_ = CHECK_TAG((c_class_id), 12);\
917 
	(name_) = DEREF_hashid(x362_ + 1);\
918 
	(storage_) = DEREF_dspec(x362_ + 2);\
919 
	(parent_) = DEREF_nspace(x362_ + 3);\
920 
	(loc_).line = DEREF_ulong(x362_ + 4);\
921 
	(loc_).column = DEREF_ulong(x362_ + 5);\
922 
	(loc_).posn = DEREF_ptr(x362_ + 6);\
923 
	(alias_) = DEREF_id(x362_ + 7);\
924 
	(no_) = DEREF_ulong(x362_ + 8);\
925 
	(dump_) = DEREF_ulong(x362_ + 9);\
926 
	(defn_) = DEREF_type(x362_ + 10);\
927 
	(rep_) = DEREF_btype(x362_ + 11);\
2 7u83 928 
    }
929 
 
6 7u83 930 
#define DESTROY_id_type_alias(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, rep_, c_class_id)\
2 7u83 931 
    {\
6 7u83 932 
	c_class *x363_ = CHECK_TAG((c_class_id), 12);\
933 
	(name_) = DEREF_hashid(x363_ + 1);\
934 
	(storage_) = DEREF_dspec(x363_ + 2);\
935 
	(parent_) = DEREF_nspace(x363_ + 3);\
936 
	(loc_).line = DEREF_ulong(x363_ + 4);\
937 
	(loc_).column = DEREF_ulong(x363_ + 5);\
938 
	(loc_).posn = DEREF_ptr(x363_ + 6);\
939 
	(alias_) = DEREF_id(x363_ + 7);\
940 
	(no_) = DEREF_ulong(x363_ + 8);\
941 
	(dump_) = DEREF_ulong(x363_ + 9);\
942 
	(defn_) = DEREF_type(x363_ + 10);\
943 
	(rep_) = DEREF_btype(x363_ + 11);\
944 
	(destroyer_)(x363_, (unsigned)12);\
2 7u83 945 
    }
946 
 
947 
 
948 
/* Operations for field set nspace_name_etc of union IDENTIFIER */
949 
 
6 7u83 950 
#define id_nspace_name_etc_tag		((unsigned)15)
951 
#define IS_id_nspace_name_etc(P)	((unsigned)(CHECK_NULL(P)->ag_tag - 13) < (unsigned)2)
2 7u83 952 
 
6 7u83 953 
#define id_nspace_name_etc_defn(P)	(CHECK_TAG_ETC((P), 13, 15) + 10)
2 7u83 954 
 
6 7u83 955 
#define MAKE_id_nspace_name_etc(tag, name_, storage_, parent_, loc_, defn_, c_class_id)\
2 7u83 956 
    {\
6 7u83 957 
	c_class *x364_ = GEN_c_class(11, TYPEID_id);\
958 
	x364_->ag_tag = (tag);\
959 
	COPY_hashid(x364_ + 1, (name_));\
960 
	COPY_dspec(x364_ + 2, (storage_));\
961 
	COPY_nspace(x364_ + 3, (parent_));\
962 
	COPY_ulong(x364_ + 4, (loc_).line);\
963 
	COPY_ulong(x364_ + 5, (loc_).column);\
964 
	COPY_ptr(x364_ + 6, (loc_).posn);\
965 
	COPY_id(x364_ + 7, x364_);\
966 
	COPY_ulong(x364_ + 8, LINK_NONE);\
967 
	COPY_ulong(x364_ + 9, LINK_NONE);\
968 
	COPY_nspace(x364_ + 10, (defn_));\
969 
	(c_class_id) = CHECK_TAG_ETC(x364_, 13, 15);\
2 7u83 970 
    }
971 
 
6 7u83 972 
#define MODIFY_id_nspace_name_etc(tag, c_class_id)\
2 7u83 973 
    {\
6 7u83 974 
	c_class *x365_ = CHECK_TAG_ETC ((c_class_id), 13, 15);\
975 
	x365_->ag_tag = (tag);\
976 
	(void) CHECK_TAG_ETC (x365_, 13, 15);\
2 7u83 977 
    }
978 
 
6 7u83 979 
#define DECONS_id_nspace_name_etc(name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, c_class_id)\
2 7u83 980 
    {\
6 7u83 981 
	c_class *x366_ = CHECK_TAG_ETC((c_class_id), 13, 15);\
982 
	(name_) = DEREF_hashid(x366_ + 1);\
983 
	(storage_) = DEREF_dspec(x366_ + 2);\
984 
	(parent_) = DEREF_nspace(x366_ + 3);\
985 
	(loc_).line = DEREF_ulong(x366_ + 4);\
986 
	(loc_).column = DEREF_ulong(x366_ + 5);\
987 
	(loc_).posn = DEREF_ptr(x366_ + 6);\
988 
	(alias_) = DEREF_id(x366_ + 7);\
989 
	(no_) = DEREF_ulong(x366_ + 8);\
990 
	(dump_) = DEREF_ulong(x366_ + 9);\
991 
	(defn_) = DEREF_nspace(x366_ + 10);\
2 7u83 992 
    }
993 
 
6 7u83 994 
#define DESTROY_id_nspace_name_etc(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, c_class_id)\
2 7u83 995 
    {\
6 7u83 996 
	c_class *x367_ = CHECK_TAG_ETC((c_class_id), 13, 15);\
997 
	(name_) = DEREF_hashid(x367_ + 1);\
998 
	(storage_) = DEREF_dspec(x367_ + 2);\
999 
	(parent_) = DEREF_nspace(x367_ + 3);\
1000 
	(loc_).line = DEREF_ulong(x367_ + 4);\
1001 
	(loc_).column = DEREF_ulong(x367_ + 5);\
1002 
	(loc_).posn = DEREF_ptr(x367_ + 6);\
1003 
	(alias_) = DEREF_id(x367_ + 7);\
1004 
	(no_) = DEREF_ulong(x367_ + 8);\
1005 
	(dump_) = DEREF_ulong(x367_ + 9);\
1006 
	(defn_) = DEREF_nspace(x367_ + 10);\
1007 
	(destroyer_)(x367_, (unsigned)11);\
2 7u83 1008 
    }
1009 
 
1010 
 
1011 
/* Operations for field nspace_name of union IDENTIFIER */
1012 
 
6 7u83 1013 
#define id_nspace_name_tag		((unsigned)13)
1014 
#define IS_id_nspace_name(P)		(CHECK_NULL(P)->ag_tag == 13)
2 7u83 1015 
 
6 7u83 1016 
#define id_nspace_name_defn(P)		(CHECK_TAG((P), 13) + 10)
2 7u83 1017 
 
6 7u83 1018 
#define MAKE_id_nspace_name(name_, storage_, parent_, loc_, defn_, c_class_id)\
2 7u83 1019 
    {\
6 7u83 1020 
	c_class *x368_ = GEN_c_class(11, TYPEID_id);\
1021 
	x368_->ag_tag = 13;\
1022 
	COPY_hashid(x368_ + 1, (name_));\
1023 
	COPY_dspec(x368_ + 2, (storage_));\
1024 
	COPY_nspace(x368_ + 3, (parent_));\
1025 
	COPY_ulong(x368_ + 4, (loc_).line);\
1026 
	COPY_ulong(x368_ + 5, (loc_).column);\
1027 
	COPY_ptr(x368_ + 6, (loc_).posn);\
1028 
	COPY_id(x368_ + 7, x368_);\
1029 
	COPY_ulong(x368_ + 8, LINK_NONE);\
1030 
	COPY_ulong(x368_ + 9, LINK_NONE);\
1031 
	COPY_nspace(x368_ + 10, (defn_));\
1032 
	(c_class_id) = x368_;\
2 7u83 1033 
    }
1034 
 
6 7u83 1035 
#define DECONS_id_nspace_name(name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, c_class_id)\
2 7u83 1036 
    {\
6 7u83 1037 
	c_class *x369_ = CHECK_TAG((c_class_id), 13);\
1038 
	(name_) = DEREF_hashid(x369_ + 1);\
1039 
	(storage_) = DEREF_dspec(x369_ + 2);\
1040 
	(parent_) = DEREF_nspace(x369_ + 3);\
1041 
	(loc_).line = DEREF_ulong(x369_ + 4);\
1042 
	(loc_).column = DEREF_ulong(x369_ + 5);\
1043 
	(loc_).posn = DEREF_ptr(x369_ + 6);\
1044 
	(alias_) = DEREF_id(x369_ + 7);\
1045 
	(no_) = DEREF_ulong(x369_ + 8);\
1046 
	(dump_) = DEREF_ulong(x369_ + 9);\
1047 
	(defn_) = DEREF_nspace(x369_ + 10);\
2 7u83 1048 
    }
1049 
 
6 7u83 1050 
#define DESTROY_id_nspace_name(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, c_class_id)\
2 7u83 1051 
    {\
6 7u83 1052 
	c_class *x370_ = CHECK_TAG((c_class_id), 13);\
1053 
	(name_) = DEREF_hashid(x370_ + 1);\
1054 
	(storage_) = DEREF_dspec(x370_ + 2);\
1055 
	(parent_) = DEREF_nspace(x370_ + 3);\
1056 
	(loc_).line = DEREF_ulong(x370_ + 4);\
1057 
	(loc_).column = DEREF_ulong(x370_ + 5);\
1058 
	(loc_).posn = DEREF_ptr(x370_ + 6);\
1059 
	(alias_) = DEREF_id(x370_ + 7);\
1060 
	(no_) = DEREF_ulong(x370_ + 8);\
1061 
	(dump_) = DEREF_ulong(x370_ + 9);\
1062 
	(defn_) = DEREF_nspace(x370_ + 10);\
1063 
	(destroyer_)(x370_, (unsigned)11);\
2 7u83 1064 
    }
1065 
 
1066 
 
1067 
/* Operations for field nspace_alias of union IDENTIFIER */
1068 
 
6 7u83 1069 
#define id_nspace_alias_tag		((unsigned)14)
1070 
#define IS_id_nspace_alias(P)		(CHECK_NULL(P)->ag_tag == 14)
2 7u83 1071 
 
6 7u83 1072 
#define id_nspace_alias_defn(P)		(CHECK_TAG((P), 14) + 10)
2 7u83 1073 
 
6 7u83 1074 
#define MAKE_id_nspace_alias(name_, storage_, parent_, loc_, defn_, c_class_id)\
2 7u83 1075 
    {\
6 7u83 1076 
	c_class *x371_ = GEN_c_class(11, TYPEID_id);\
1077 
	x371_->ag_tag = 14;\
1078 
	COPY_hashid(x371_ + 1, (name_));\
1079 
	COPY_dspec(x371_ + 2, (storage_));\
1080 
	COPY_nspace(x371_ + 3, (parent_));\
1081 
	COPY_ulong(x371_ + 4, (loc_).line);\
1082 
	COPY_ulong(x371_ + 5, (loc_).column);\
1083 
	COPY_ptr(x371_ + 6, (loc_).posn);\
1084 
	COPY_id(x371_ + 7, x371_);\
1085 
	COPY_ulong(x371_ + 8, LINK_NONE);\
1086 
	COPY_ulong(x371_ + 9, LINK_NONE);\
1087 
	COPY_nspace(x371_ + 10, (defn_));\
1088 
	(c_class_id) = x371_;\
2 7u83 1089 
    }
1090 
 
6 7u83 1091 
#define DECONS_id_nspace_alias(name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, c_class_id)\
2 7u83 1092 
    {\
6 7u83 1093 
	c_class *x372_ = CHECK_TAG((c_class_id), 14);\
1094 
	(name_) = DEREF_hashid(x372_ + 1);\
1095 
	(storage_) = DEREF_dspec(x372_ + 2);\
1096 
	(parent_) = DEREF_nspace(x372_ + 3);\
1097 
	(loc_).line = DEREF_ulong(x372_ + 4);\
1098 
	(loc_).column = DEREF_ulong(x372_ + 5);\
1099 
	(loc_).posn = DEREF_ptr(x372_ + 6);\
1100 
	(alias_) = DEREF_id(x372_ + 7);\
1101 
	(no_) = DEREF_ulong(x372_ + 8);\
1102 
	(dump_) = DEREF_ulong(x372_ + 9);\
1103 
	(defn_) = DEREF_nspace(x372_ + 10);\
2 7u83 1104 
    }
1105 
 
6 7u83 1106 
#define DESTROY_id_nspace_alias(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, defn_, c_class_id)\
2 7u83 1107 
    {\
6 7u83 1108 
	c_class *x373_ = CHECK_TAG((c_class_id), 14);\
1109 
	(name_) = DEREF_hashid(x373_ + 1);\
1110 
	(storage_) = DEREF_dspec(x373_ + 2);\
1111 
	(parent_) = DEREF_nspace(x373_ + 3);\
1112 
	(loc_).line = DEREF_ulong(x373_ + 4);\
1113 
	(loc_).column = DEREF_ulong(x373_ + 5);\
1114 
	(loc_).posn = DEREF_ptr(x373_ + 6);\
1115 
	(alias_) = DEREF_id(x373_ + 7);\
1116 
	(no_) = DEREF_ulong(x373_ + 8);\
1117 
	(dump_) = DEREF_ulong(x373_ + 9);\
1118 
	(defn_) = DEREF_nspace(x373_ + 10);\
1119 
	(destroyer_)(x373_, (unsigned)11);\
2 7u83 1120 
    }
1121 
 
1122 
 
1123 
/* Operations for field set variable_etc of union IDENTIFIER */
1124 
 
6 7u83 1125 
#define id_variable_etc_tag		((unsigned)18)
1126 
#define IS_id_variable_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 15) < (unsigned)3)
2 7u83 1127 
 
6 7u83 1128 
#define id_variable_etc_type(P)		(CHECK_TAG_ETC((P), 15, 18) + 10)
1129 
#define id_variable_etc_init(P)		(CHECK_TAG_ETC((P), 15, 18) + 11)
1130 
#define id_variable_etc_term(P)		(CHECK_TAG_ETC((P), 15, 18) + 12)
2 7u83 1131 
 
6 7u83 1132 
#define MAKE_id_variable_etc(tag, name_, storage_, parent_, loc_, type_, c_class_id)\
2 7u83 1133 
    {\
6 7u83 1134 
	c_class *x374_ = GEN_c_class(13, TYPEID_id);\
1135 
	x374_->ag_tag = (tag);\
1136 
	COPY_hashid(x374_ + 1, (name_));\
1137 
	COPY_dspec(x374_ + 2, (storage_));\
1138 
	COPY_nspace(x374_ + 3, (parent_));\
1139 
	COPY_ulong(x374_ + 4, (loc_).line);\
1140 
	COPY_ulong(x374_ + 5, (loc_).column);\
1141 
	COPY_ptr(x374_ + 6, (loc_).posn);\
1142 
	COPY_id(x374_ + 7, x374_);\
1143 
	COPY_ulong(x374_ + 8, LINK_NONE);\
1144 
	COPY_ulong(x374_ + 9, LINK_NONE);\
1145 
	COPY_type(x374_ + 10, (type_));\
1146 
	COPY_exp(x374_ + 11, NULL_exp);\
1147 
	COPY_exp(x374_ + 12, NULL_exp);\
1148 
	(c_class_id) = CHECK_TAG_ETC(x374_, 15, 18);\
2 7u83 1149 
    }
1150 
 
6 7u83 1151 
#define MODIFY_id_variable_etc(tag, c_class_id)\
2 7u83 1152 
    {\
6 7u83 1153 
	c_class *x375_ = CHECK_TAG_ETC ((c_class_id), 15, 18);\
1154 
	x375_->ag_tag = (tag);\
1155 
	(void) CHECK_TAG_ETC (x375_, 15, 18);\
2 7u83 1156 
    }
1157 
 
6 7u83 1158 
#define DECONS_id_variable_etc(name_, storage_, parent_, loc_, alias_, no_, dump_, type_, init_, term_, c_class_id)\
2 7u83 1159 
    {\
6 7u83 1160 
	c_class *x376_ = CHECK_TAG_ETC((c_class_id), 15, 18);\
1161 
	(name_) = DEREF_hashid(x376_ + 1);\
1162 
	(storage_) = DEREF_dspec(x376_ + 2);\
1163 
	(parent_) = DEREF_nspace(x376_ + 3);\
1164 
	(loc_).line = DEREF_ulong(x376_ + 4);\
1165 
	(loc_).column = DEREF_ulong(x376_ + 5);\
1166 
	(loc_).posn = DEREF_ptr(x376_ + 6);\
1167 
	(alias_) = DEREF_id(x376_ + 7);\
1168 
	(no_) = DEREF_ulong(x376_ + 8);\
1169 
	(dump_) = DEREF_ulong(x376_ + 9);\
1170 
	(type_) = DEREF_type(x376_ + 10);\
1171 
	(init_) = DEREF_exp(x376_ + 11);\
1172 
	(term_) = DEREF_exp(x376_ + 12);\
2 7u83 1173 
    }
1174 
 
6 7u83 1175 
#define DESTROY_id_variable_etc(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, type_, init_, term_, c_class_id)\
2 7u83 1176 
    {\
6 7u83 1177 
	c_class *x377_ = CHECK_TAG_ETC((c_class_id), 15, 18);\
1178 
	(name_) = DEREF_hashid(x377_ + 1);\
1179 
	(storage_) = DEREF_dspec(x377_ + 2);\
1180 
	(parent_) = DEREF_nspace(x377_ + 3);\
1181 
	(loc_).line = DEREF_ulong(x377_ + 4);\
1182 
	(loc_).column = DEREF_ulong(x377_ + 5);\
1183 
	(loc_).posn = DEREF_ptr(x377_ + 6);\
1184 
	(alias_) = DEREF_id(x377_ + 7);\
1185 
	(no_) = DEREF_ulong(x377_ + 8);\
1186 
	(dump_) = DEREF_ulong(x377_ + 9);\
1187 
	(type_) = DEREF_type(x377_ + 10);\
1188 
	(init_) = DEREF_exp(x377_ + 11);\
1189 
	(term_) = DEREF_exp(x377_ + 12);\
1190 
	(destroyer_)(x377_, (unsigned)13);\
2 7u83 1191 
    }
1192 
 
1193 
 
1194 
/* Operations for field variable of union IDENTIFIER */
1195 
 
6 7u83 1196 
#define id_variable_tag			((unsigned)15)
1197 
#define IS_id_variable(P)		(CHECK_NULL(P)->ag_tag == 15)
2 7u83 1198 
 
6 7u83 1199 
#define id_variable_type(P)		(CHECK_TAG((P), 15) + 10)
1200 
#define id_variable_init(P)		(CHECK_TAG((P), 15) + 11)
1201 
#define id_variable_term(P)		(CHECK_TAG((P), 15) + 12)
2 7u83 1202 
 
6 7u83 1203 
#define MAKE_id_variable(name_, storage_, parent_, loc_, type_, c_class_id)\
2 7u83 1204 
    {\
6 7u83 1205 
	c_class *x378_ = GEN_c_class(13, TYPEID_id);\
1206 
	x378_->ag_tag = 15;\
1207 
	COPY_hashid(x378_ + 1, (name_));\
1208 
	COPY_dspec(x378_ + 2, (storage_));\
1209 
	COPY_nspace(x378_ + 3, (parent_));\
1210 
	COPY_ulong(x378_ + 4, (loc_).line);\
1211 
	COPY_ulong(x378_ + 5, (loc_).column);\
1212 
	COPY_ptr(x378_ + 6, (loc_).posn);\
1213 
	COPY_id(x378_ + 7, x378_);\
1214 
	COPY_ulong(x378_ + 8, LINK_NONE);\
1215 
	COPY_ulong(x378_ + 9, LINK_NONE);\
1216 
	COPY_type(x378_ + 10, (type_));\
1217 
	COPY_exp(x378_ + 11, NULL_exp);\
1218 
	COPY_exp(x378_ + 12, NULL_exp);\
1219 
	(c_class_id) = x378_;\
2 7u83 1220 
    }
1221 
 
6 7u83 1222 
#define DECONS_id_variable(name_, storage_, parent_, loc_, alias_, no_, dump_, type_, init_, term_, c_class_id)\
2 7u83 1223 
    {\
6 7u83 1224 
	c_class *x379_ = CHECK_TAG((c_class_id), 15);\
1225 
	(name_) = DEREF_hashid(x379_ + 1);\
1226 
	(storage_) = DEREF_dspec(x379_ + 2);\
1227 
	(parent_) = DEREF_nspace(x379_ + 3);\
1228 
	(loc_).line = DEREF_ulong(x379_ + 4);\
1229 
	(loc_).column = DEREF_ulong(x379_ + 5);\
1230 
	(loc_).posn = DEREF_ptr(x379_ + 6);\
1231 
	(alias_) = DEREF_id(x379_ + 7);\
1232 
	(no_) = DEREF_ulong(x379_ + 8);\
1233 
	(dump_) = DEREF_ulong(x379_ + 9);\
1234 
	(type_) = DEREF_type(x379_ + 10);\
1235 
	(init_) = DEREF_exp(x379_ + 11);\
1236 
	(term_) = DEREF_exp(x379_ + 12);\
2 7u83 1237 
    }
1238 
 
6 7u83 1239 
#define DESTROY_id_variable(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, type_, init_, term_, c_class_id)\
2 7u83 1240 
    {\
6 7u83 1241 
	c_class *x380_ = CHECK_TAG((c_class_id), 15);\
1242 
	(name_) = DEREF_hashid(x380_ + 1);\
1243 
	(storage_) = DEREF_dspec(x380_ + 2);\
1244 
	(parent_) = DEREF_nspace(x380_ + 3);\
1245 
	(loc_).line = DEREF_ulong(x380_ + 4);\
1246 
	(loc_).column = DEREF_ulong(x380_ + 5);\
1247 
	(loc_).posn = DEREF_ptr(x380_ + 6);\
1248 
	(alias_) = DEREF_id(x380_ + 7);\
1249 
	(no_) = DEREF_ulong(x380_ + 8);\
1250 
	(dump_) = DEREF_ulong(x380_ + 9);\
1251 
	(type_) = DEREF_type(x380_ + 10);\
1252 
	(init_) = DEREF_exp(x380_ + 11);\
1253 
	(term_) = DEREF_exp(x380_ + 12);\
1254 
	(destroyer_)(x380_, (unsigned)13);\
2 7u83 1255 
    }
1256 
 
1257 
 
1258 
/* Operations for field parameter of union IDENTIFIER */
1259 
 
6 7u83 1260 
#define id_parameter_tag		((unsigned)16)
1261 
#define IS_id_parameter(P)		(CHECK_NULL(P)->ag_tag == 16)
2 7u83 1262 
 
6 7u83 1263 
#define id_parameter_type(P)		(CHECK_TAG((P), 16) + 10)
1264 
#define id_parameter_init(P)		(CHECK_TAG((P), 16) + 11)
1265 
#define id_parameter_term(P)		(CHECK_TAG((P), 16) + 12)
2 7u83 1266 
 
6 7u83 1267 
#define MAKE_id_parameter(name_, storage_, parent_, loc_, type_, c_class_id)\
2 7u83 1268 
    {\
6 7u83 1269 
	c_class *x381_ = GEN_c_class(13, TYPEID_id);\
1270 
	x381_->ag_tag = 16;\
1271 
	COPY_hashid(x381_ + 1, (name_));\
1272 
	COPY_dspec(x381_ + 2, (storage_));\
1273 
	COPY_nspace(x381_ + 3, (parent_));\
1274 
	COPY_ulong(x381_ + 4, (loc_).line);\
1275 
	COPY_ulong(x381_ + 5, (loc_).column);\
1276 
	COPY_ptr(x381_ + 6, (loc_).posn);\
1277 
	COPY_id(x381_ + 7, x381_);\
1278 
	COPY_ulong(x381_ + 8, LINK_NONE);\
1279 
	COPY_ulong(x381_ + 9, LINK_NONE);\
1280 
	COPY_type(x381_ + 10, (type_));\
1281 
	COPY_exp(x381_ + 11, NULL_exp);\
1282 
	COPY_exp(x381_ + 12, NULL_exp);\
1283 
	(c_class_id) = x381_;\
2 7u83 1284 
    }
1285 
 
6 7u83 1286 
#define DECONS_id_parameter(name_, storage_, parent_, loc_, alias_, no_, dump_, type_, init_, term_, c_class_id)\
2 7u83 1287 
    {\
6 7u83 1288 
	c_class *x382_ = CHECK_TAG((c_class_id), 16);\
1289 
	(name_) = DEREF_hashid(x382_ + 1);\
1290 
	(storage_) = DEREF_dspec(x382_ + 2);\
1291 
	(parent_) = DEREF_nspace(x382_ + 3);\
1292 
	(loc_).line = DEREF_ulong(x382_ + 4);\
1293 
	(loc_).column = DEREF_ulong(x382_ + 5);\
1294 
	(loc_).posn = DEREF_ptr(x382_ + 6);\
1295 
	(alias_) = DEREF_id(x382_ + 7);\
1296 
	(no_) = DEREF_ulong(x382_ + 8);\
1297 
	(dump_) = DEREF_ulong(x382_ + 9);\
1298 
	(type_) = DEREF_type(x382_ + 10);\
1299 
	(init_) = DEREF_exp(x382_ + 11);\
1300 
	(term_) = DEREF_exp(x382_ + 12);\
2 7u83 1301 
    }
1302 
 
6 7u83 1303 
#define DESTROY_id_parameter(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, type_, init_, term_, c_class_id)\
2 7u83 1304 
    {\
6 7u83 1305 
	c_class *x383_ = CHECK_TAG((c_class_id), 16);\
1306 
	(name_) = DEREF_hashid(x383_ + 1);\
1307 
	(storage_) = DEREF_dspec(x383_ + 2);\
1308 
	(parent_) = DEREF_nspace(x383_ + 3);\
1309 
	(loc_).line = DEREF_ulong(x383_ + 4);\
1310 
	(loc_).column = DEREF_ulong(x383_ + 5);\
1311 
	(loc_).posn = DEREF_ptr(x383_ + 6);\
1312 
	(alias_) = DEREF_id(x383_ + 7);\
1313 
	(no_) = DEREF_ulong(x383_ + 8);\
1314 
	(dump_) = DEREF_ulong(x383_ + 9);\
1315 
	(type_) = DEREF_type(x383_ + 10);\
1316 
	(init_) = DEREF_exp(x383_ + 11);\
1317 
	(term_) = DEREF_exp(x383_ + 12);\
1318 
	(destroyer_)(x383_, (unsigned)13);\
2 7u83 1319 
    }
1320 
 
1321 
 
1322 
/* Operations for field stat_member of union IDENTIFIER */
1323 
 
6 7u83 1324 
#define id_stat_member_tag		((unsigned)17)
1325 
#define IS_id_stat_member(P)		(CHECK_NULL(P)->ag_tag == 17)
2 7u83 1326 
 
6 7u83 1327 
#define id_stat_member_type(P)		(CHECK_TAG((P), 17) + 10)
1328 
#define id_stat_member_init(P)		(CHECK_TAG((P), 17) + 11)
1329 
#define id_stat_member_term(P)		(CHECK_TAG((P), 17) + 12)
2 7u83 1330 
 
6 7u83 1331 
#define MAKE_id_stat_member(name_, storage_, parent_, loc_, type_, c_class_id)\
2 7u83 1332 
    {\
6 7u83 1333 
	c_class *x384_ = GEN_c_class(13, TYPEID_id);\
1334 
	x384_->ag_tag = 17;\
1335 
	COPY_hashid(x384_ + 1, (name_));\
1336 
	COPY_dspec(x384_ + 2, (storage_));\
1337 
	COPY_nspace(x384_ + 3, (parent_));\
1338 
	COPY_ulong(x384_ + 4, (loc_).line);\
1339 
	COPY_ulong(x384_ + 5, (loc_).column);\
1340 
	COPY_ptr(x384_ + 6, (loc_).posn);\
1341 
	COPY_id(x384_ + 7, x384_);\
1342 
	COPY_ulong(x384_ + 8, LINK_NONE);\
1343 
	COPY_ulong(x384_ + 9, LINK_NONE);\
1344 
	COPY_type(x384_ + 10, (type_));\
1345 
	COPY_exp(x384_ + 11, NULL_exp);\
1346 
	COPY_exp(x384_ + 12, NULL_exp);\
1347 
	(c_class_id) = x384_;\
2 7u83 1348 
    }
1349 
 
6 7u83 1350 
#define DECONS_id_stat_member(name_, storage_, parent_, loc_, alias_, no_, dump_, type_, init_, term_, c_class_id)\
2 7u83 1351 
    {\
6 7u83 1352 
	c_class *x385_ = CHECK_TAG((c_class_id), 17);\
1353 
	(name_) = DEREF_hashid(x385_ + 1);\
1354 
	(storage_) = DEREF_dspec(x385_ + 2);\
1355 
	(parent_) = DEREF_nspace(x385_ + 3);\
1356 
	(loc_).line = DEREF_ulong(x385_ + 4);\
1357 
	(loc_).column = DEREF_ulong(x385_ + 5);\
1358 
	(loc_).posn = DEREF_ptr(x385_ + 6);\
1359 
	(alias_) = DEREF_id(x385_ + 7);\
1360 
	(no_) = DEREF_ulong(x385_ + 8);\
1361 
	(dump_) = DEREF_ulong(x385_ + 9);\
1362 
	(type_) = DEREF_type(x385_ + 10);\
1363 
	(init_) = DEREF_exp(x385_ + 11);\
1364 
	(term_) = DEREF_exp(x385_ + 12);\
2 7u83 1365 
    }
1366 
 
6 7u83 1367 
#define DESTROY_id_stat_member(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, type_, init_, term_, c_class_id)\
2 7u83 1368 
    {\
6 7u83 1369 
	c_class *x386_ = CHECK_TAG((c_class_id), 17);\
1370 
	(name_) = DEREF_hashid(x386_ + 1);\
1371 
	(storage_) = DEREF_dspec(x386_ + 2);\
1372 
	(parent_) = DEREF_nspace(x386_ + 3);\
1373 
	(loc_).line = DEREF_ulong(x386_ + 4);\
1374 
	(loc_).column = DEREF_ulong(x386_ + 5);\
1375 
	(loc_).posn = DEREF_ptr(x386_ + 6);\
1376 
	(alias_) = DEREF_id(x386_ + 7);\
1377 
	(no_) = DEREF_ulong(x386_ + 8);\
1378 
	(dump_) = DEREF_ulong(x386_ + 9);\
1379 
	(type_) = DEREF_type(x386_ + 10);\
1380 
	(init_) = DEREF_exp(x386_ + 11);\
1381 
	(term_) = DEREF_exp(x386_ + 12);\
1382 
	(destroyer_)(x386_, (unsigned)13);\
2 7u83 1383 
    }
1384 
 
1385 
 
1386 
/* Operations for field weak_param of union IDENTIFIER */
1387 
 
6 7u83 1388 
#define id_weak_param_tag		((unsigned)18)
1389 
#define IS_id_weak_param(P)		(CHECK_NULL(P)->ag_tag == 18)
2 7u83 1390 
 
1391 
 
6 7u83 1392 
#define MAKE_id_weak_param(name_, storage_, parent_, loc_, c_class_id)\
2 7u83 1393 
    {\
6 7u83 1394 
	c_class *x387_ = GEN_c_class(10, TYPEID_id);\
1395 
	x387_->ag_tag = 18;\
1396 
	COPY_hashid(x387_ + 1, (name_));\
1397 
	COPY_dspec(x387_ + 2, (storage_));\
1398 
	COPY_nspace(x387_ + 3, (parent_));\
1399 
	COPY_ulong(x387_ + 4, (loc_).line);\
1400 
	COPY_ulong(x387_ + 5, (loc_).column);\
1401 
	COPY_ptr(x387_ + 6, (loc_).posn);\
1402 
	COPY_id(x387_ + 7, x387_);\
1403 
	COPY_ulong(x387_ + 8, LINK_NONE);\
1404 
	COPY_ulong(x387_ + 9, LINK_NONE);\
1405 
	(c_class_id) = x387_;\
2 7u83 1406 
    }
1407 
 
6 7u83 1408 
#define DECONS_id_weak_param(name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 1409 
    {\
6 7u83 1410 
	c_class *x388_ = CHECK_TAG((c_class_id), 18);\
1411 
	(name_) = DEREF_hashid(x388_ + 1);\
1412 
	(storage_) = DEREF_dspec(x388_ + 2);\
1413 
	(parent_) = DEREF_nspace(x388_ + 3);\
1414 
	(loc_).line = DEREF_ulong(x388_ + 4);\
1415 
	(loc_).column = DEREF_ulong(x388_ + 5);\
1416 
	(loc_).posn = DEREF_ptr(x388_ + 6);\
1417 
	(alias_) = DEREF_id(x388_ + 7);\
1418 
	(no_) = DEREF_ulong(x388_ + 8);\
1419 
	(dump_) = DEREF_ulong(x388_ + 9);\
2 7u83 1420 
    }
1421 
 
6 7u83 1422 
#define DESTROY_id_weak_param(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, c_class_id)\
2 7u83 1423 
    {\
6 7u83 1424 
	c_class *x389_ = CHECK_TAG((c_class_id), 18);\
1425 
	(name_) = DEREF_hashid(x389_ + 1);\
1426 
	(storage_) = DEREF_dspec(x389_ + 2);\
1427 
	(parent_) = DEREF_nspace(x389_ + 3);\
1428 
	(loc_).line = DEREF_ulong(x389_ + 4);\
1429 
	(loc_).column = DEREF_ulong(x389_ + 5);\
1430 
	(loc_).posn = DEREF_ptr(x389_ + 6);\
1431 
	(alias_) = DEREF_id(x389_ + 7);\
1432 
	(no_) = DEREF_ulong(x389_ + 8);\
1433 
	(dump_) = DEREF_ulong(x389_ + 9);\
1434 
	(destroyer_)(x389_, (unsigned)10);\
2 7u83 1435 
    }
1436 
 
1437 
 
1438 
/* Operations for field set function_etc of union IDENTIFIER */
1439 
 
6 7u83 1440 
#define id_function_etc_tag		((unsigned)22)
1441 
#define IS_id_function_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 19) < (unsigned)3)
2 7u83 1442 
 
6 7u83 1443 
#define id_function_etc_type(P)		(CHECK_TAG_ETC((P), 19, 22) + 10)
1444 
#define id_function_etc_over(P)		(CHECK_TAG_ETC((P), 19, 22) + 11)
1445 
#define id_function_etc_form(P)		(CHECK_TAG_ETC((P), 19, 22) + 12)
1446 
#define id_function_etc_chums(P)	(CHECK_TAG_ETC((P), 19, 22) + 13)
1447 
#define id_function_etc_defn(P)		(CHECK_TAG_ETC((P), 19, 22) + 14)
2 7u83 1448 
 
6 7u83 1449 
#define MAKE_id_function_etc(tag, name_, storage_, parent_, loc_, type_, over_, c_class_id)\
2 7u83 1450 
    {\
6 7u83 1451 
	c_class *x390_ = GEN_c_class(15, TYPEID_id);\
1452 
	x390_->ag_tag = (tag);\
1453 
	COPY_hashid(x390_ + 1, (name_));\
1454 
	COPY_dspec(x390_ + 2, (storage_));\
1455 
	COPY_nspace(x390_ + 3, (parent_));\
1456 
	COPY_ulong(x390_ + 4, (loc_).line);\
1457 
	COPY_ulong(x390_ + 5, (loc_).column);\
1458 
	COPY_ptr(x390_ + 6, (loc_).posn);\
1459 
	COPY_id(x390_ + 7, x390_);\
1460 
	COPY_ulong(x390_ + 8, LINK_NONE);\
1461 
	COPY_ulong(x390_ + 9, LINK_NONE);\
1462 
	COPY_type(x390_ + 10, (type_));\
1463 
	COPY_id(x390_ + 11, (over_));\
1464 
	COPY_type(x390_ + 12, NULL_type);\
1465 
	COPY_list(x390_ + 13, NULL_list ( CLASS_TYPE ));\
1466 
	COPY_exp(x390_ + 14, NULL_exp);\
1467 
	(c_class_id) = CHECK_TAG_ETC(x390_, 19, 22);\
2 7u83 1468 
    }
1469 
 
6 7u83 1470 
#define MODIFY_id_function_etc(tag, c_class_id)\
2 7u83 1471 
    {\
6 7u83 1472 
	c_class *x391_ = CHECK_TAG_ETC ((c_class_id), 19, 22);\
1473 
	x391_->ag_tag = (tag);\
1474 
	(void) CHECK_TAG_ETC (x391_, 19, 22);\
2 7u83 1475 
    }
1476 
 
6 7u83 1477 
#define DECONS_id_function_etc(name_, storage_, parent_, loc_, alias_, no_, dump_, type_, over_, form_, chums_, defn_, c_class_id)\
2 7u83 1478 
    {\
6 7u83 1479 
	c_class *x392_ = CHECK_TAG_ETC((c_class_id), 19, 22);\
1480 
	(name_) = DEREF_hashid(x392_ + 1);\
1481 
	(storage_) = DEREF_dspec(x392_ + 2);\
1482 
	(parent_) = DEREF_nspace(x392_ + 3);\
1483 
	(loc_).line = DEREF_ulong(x392_ + 4);\
1484 
	(loc_).column = DEREF_ulong(x392_ + 5);\
1485 
	(loc_).posn = DEREF_ptr(x392_ + 6);\
1486 
	(alias_) = DEREF_id(x392_ + 7);\
1487 
	(no_) = DEREF_ulong(x392_ + 8);\
1488 
	(dump_) = DEREF_ulong(x392_ + 9);\
1489 
	(type_) = DEREF_type(x392_ + 10);\
1490 
	(over_) = DEREF_id(x392_ + 11);\
1491 
	(form_) = DEREF_type(x392_ + 12);\
1492 
	(chums_) = DEREF_list(x392_ + 13);\
1493 
	(defn_) = DEREF_exp(x392_ + 14);\
2 7u83 1494 
    }
1495 
 
6 7u83 1496 
#define DESTROY_id_function_etc(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, type_, over_, form_, chums_, defn_, c_class_id)\
2 7u83 1497 
    {\
6 7u83 1498 
	c_class *x393_ = CHECK_TAG_ETC((c_class_id), 19, 22);\
1499 
	(name_) = DEREF_hashid(x393_ + 1);\
1500 
	(storage_) = DEREF_dspec(x393_ + 2);\
1501 
	(parent_) = DEREF_nspace(x393_ + 3);\
1502 
	(loc_).line = DEREF_ulong(x393_ + 4);\
1503 
	(loc_).column = DEREF_ulong(x393_ + 5);\
1504 
	(loc_).posn = DEREF_ptr(x393_ + 6);\
1505 
	(alias_) = DEREF_id(x393_ + 7);\
1506 
	(no_) = DEREF_ulong(x393_ + 8);\
1507 
	(dump_) = DEREF_ulong(x393_ + 9);\
1508 
	(type_) = DEREF_type(x393_ + 10);\
1509 
	(over_) = DEREF_id(x393_ + 11);\
1510 
	(form_) = DEREF_type(x393_ + 12);\
1511 
	(chums_) = DEREF_list(x393_ + 13);\
1512 
	(defn_) = DEREF_exp(x393_ + 14);\
1513 
	(destroyer_)(x393_, (unsigned)15);\
2 7u83 1514 
    }
1515 
 
1516 
 
1517 
/* Operations for field function of union IDENTIFIER */
1518 
 
6 7u83 1519 
#define id_function_tag			((unsigned)19)
1520 
#define IS_id_function(P)		(CHECK_NULL(P)->ag_tag == 19)
2 7u83 1521 
 
6 7u83 1522 
#define id_function_type(P)		(CHECK_TAG((P), 19) + 10)
1523 
#define id_function_over(P)		(CHECK_TAG((P), 19) + 11)
1524 
#define id_function_form(P)		(CHECK_TAG((P), 19) + 12)
1525 
#define id_function_chums(P)		(CHECK_TAG((P), 19) + 13)
1526 
#define id_function_defn(P)		(CHECK_TAG((P), 19) + 14)
2 7u83 1527 
 
6 7u83 1528 
#define MAKE_id_function(name_, storage_, parent_, loc_, type_, over_, c_class_id)\
2 7u83 1529 
    {\
6 7u83 1530 
	c_class *x394_ = GEN_c_class(15, TYPEID_id);\
1531 
	x394_->ag_tag = 19;\
1532 
	COPY_hashid(x394_ + 1, (name_));\
1533 
	COPY_dspec(x394_ + 2, (storage_));\
1534 
	COPY_nspace(x394_ + 3, (parent_));\
1535 
	COPY_ulong(x394_ + 4, (loc_).line);\
1536 
	COPY_ulong(x394_ + 5, (loc_).column);\
1537 
	COPY_ptr(x394_ + 6, (loc_).posn);\
1538 
	COPY_id(x394_ + 7, x394_);\
1539 
	COPY_ulong(x394_ + 8, LINK_NONE);\
1540 
	COPY_ulong(x394_ + 9, LINK_NONE);\
1541 
	COPY_type(x394_ + 10, (type_));\
1542 
	COPY_id(x394_ + 11, (over_));\
1543 
	COPY_type(x394_ + 12, NULL_type);\
1544 
	COPY_list(x394_ + 13, NULL_list ( CLASS_TYPE ));\
1545 
	COPY_exp(x394_ + 14, NULL_exp);\
1546 
	(c_class_id) = x394_;\
2 7u83 1547 
    }
1548 
 
6 7u83 1549 
#define DECONS_id_function(name_, storage_, parent_, loc_, alias_, no_, dump_, type_, over_, form_, chums_, defn_, c_class_id)\
2 7u83 1550 
    {\
6 7u83 1551 
	c_class *x395_ = CHECK_TAG((c_class_id), 19);\
1552 
	(name_) = DEREF_hashid(x395_ + 1);\
1553 
	(storage_) = DEREF_dspec(x395_ + 2);\
1554 
	(parent_) = DEREF_nspace(x395_ + 3);\
1555 
	(loc_).line = DEREF_ulong(x395_ + 4);\
1556 
	(loc_).column = DEREF_ulong(x395_ + 5);\
1557 
	(loc_).posn = DEREF_ptr(x395_ + 6);\
1558 
	(alias_) = DEREF_id(x395_ + 7);\
1559 
	(no_) = DEREF_ulong(x395_ + 8);\
1560 
	(dump_) = DEREF_ulong(x395_ + 9);\
1561 
	(type_) = DEREF_type(x395_ + 10);\
1562 
	(over_) = DEREF_id(x395_ + 11);\
1563 
	(form_) = DEREF_type(x395_ + 12);\
1564 
	(chums_) = DEREF_list(x395_ + 13);\
1565 
	(defn_) = DEREF_exp(x395_ + 14);\
2 7u83 1566 
    }
1567 
 
6 7u83 1568 
#define DESTROY_id_function(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, type_, over_, form_, chums_, defn_, c_class_id)\
2 7u83 1569 
    {\
6 7u83 1570 
	c_class *x396_ = CHECK_TAG((c_class_id), 19);\
1571 
	(name_) = DEREF_hashid(x396_ + 1);\
1572 
	(storage_) = DEREF_dspec(x396_ + 2);\
1573 
	(parent_) = DEREF_nspace(x396_ + 3);\
1574 
	(loc_).line = DEREF_ulong(x396_ + 4);\
1575 
	(loc_).column = DEREF_ulong(x396_ + 5);\
1576 
	(loc_).posn = DEREF_ptr(x396_ + 6);\
1577 
	(alias_) = DEREF_id(x396_ + 7);\
1578 
	(no_) = DEREF_ulong(x396_ + 8);\
1579 
	(dump_) = DEREF_ulong(x396_ + 9);\
1580 
	(type_) = DEREF_type(x396_ + 10);\
1581 
	(over_) = DEREF_id(x396_ + 11);\
1582 
	(form_) = DEREF_type(x396_ + 12);\
1583 
	(chums_) = DEREF_list(x396_ + 13);\
1584 
	(defn_) = DEREF_exp(x396_ + 14);\
1585 
	(destroyer_)(x396_, (unsigned)15);\
2 7u83 1586 
    }
1587 
 
1588 
 
1589 
/* Operations for field mem_func of union IDENTIFIER */
1590 
 
6 7u83 1591 
#define id_mem_func_tag			((unsigned)20)
1592 
#define IS_id_mem_func(P)		(CHECK_NULL(P)->ag_tag == 20)
2 7u83 1593 
 
6 7u83 1594 
#define id_mem_func_type(P)		(CHECK_TAG((P), 20) + 10)
1595 
#define id_mem_func_over(P)		(CHECK_TAG((P), 20) + 11)
1596 
#define id_mem_func_form(P)		(CHECK_TAG((P), 20) + 12)
1597 
#define id_mem_func_chums(P)		(CHECK_TAG((P), 20) + 13)
1598 
#define id_mem_func_defn(P)		(CHECK_TAG((P), 20) + 14)
2 7u83 1599 
 
6 7u83 1600 
#define MAKE_id_mem_func(name_, storage_, parent_, loc_, type_, over_, c_class_id)\
2 7u83 1601 
    {\
6 7u83 1602 
	c_class *x397_ = GEN_c_class(15, TYPEID_id);\
1603 
	x397_->ag_tag = 20;\
1604 
	COPY_hashid(x397_ + 1, (name_));\
1605 
	COPY_dspec(x397_ + 2, (storage_));\
1606 
	COPY_nspace(x397_ + 3, (parent_));\
1607 
	COPY_ulong(x397_ + 4, (loc_).line);\
1608 
	COPY_ulong(x397_ + 5, (loc_).column);\
1609 
	COPY_ptr(x397_ + 6, (loc_).posn);\
1610 
	COPY_id(x397_ + 7, x397_);\
1611 
	COPY_ulong(x397_ + 8, LINK_NONE);\
1612 
	COPY_ulong(x397_ + 9, LINK_NONE);\
1613 
	COPY_type(x397_ + 10, (type_));\
1614 
	COPY_id(x397_ + 11, (over_));\
1615 
	COPY_type(x397_ + 12, NULL_type);\
1616 
	COPY_list(x397_ + 13, NULL_list ( CLASS_TYPE ));\
1617 
	COPY_exp(x397_ + 14, NULL_exp);\
1618 
	(c_class_id) = x397_;\
2 7u83 1619 
    }
1620 
 
6 7u83 1621 
#define DECONS_id_mem_func(name_, storage_, parent_, loc_, alias_, no_, dump_, type_, over_, form_, chums_, defn_, c_class_id)\
2 7u83 1622 
    {\
6 7u83 1623 
	c_class *x398_ = CHECK_TAG((c_class_id), 20);\
1624 
	(name_) = DEREF_hashid(x398_ + 1);\
1625 
	(storage_) = DEREF_dspec(x398_ + 2);\
1626 
	(parent_) = DEREF_nspace(x398_ + 3);\
1627 
	(loc_).line = DEREF_ulong(x398_ + 4);\
1628 
	(loc_).column = DEREF_ulong(x398_ + 5);\
1629 
	(loc_).posn = DEREF_ptr(x398_ + 6);\
1630 
	(alias_) = DEREF_id(x398_ + 7);\
1631 
	(no_) = DEREF_ulong(x398_ + 8);\
1632 
	(dump_) = DEREF_ulong(x398_ + 9);\
1633 
	(type_) = DEREF_type(x398_ + 10);\
1634 
	(over_) = DEREF_id(x398_ + 11);\
1635 
	(form_) = DEREF_type(x398_ + 12);\
1636 
	(chums_) = DEREF_list(x398_ + 13);\
1637 
	(defn_) = DEREF_exp(x398_ + 14);\
2 7u83 1638 
    }
1639 
 
6 7u83 1640 
#define DESTROY_id_mem_func(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, type_, over_, form_, chums_, defn_, c_class_id)\
2 7u83 1641 
    {\
6 7u83 1642 
	c_class *x399_ = CHECK_TAG((c_class_id), 20);\
1643 
	(name_) = DEREF_hashid(x399_ + 1);\
1644 
	(storage_) = DEREF_dspec(x399_ + 2);\
1645 
	(parent_) = DEREF_nspace(x399_ + 3);\
1646 
	(loc_).line = DEREF_ulong(x399_ + 4);\
1647 
	(loc_).column = DEREF_ulong(x399_ + 5);\
1648 
	(loc_).posn = DEREF_ptr(x399_ + 6);\
1649 
	(alias_) = DEREF_id(x399_ + 7);\
1650 
	(no_) = DEREF_ulong(x399_ + 8);\
1651 
	(dump_) = DEREF_ulong(x399_ + 9);\
1652 
	(type_) = DEREF_type(x399_ + 10);\
1653 
	(over_) = DEREF_id(x399_ + 11);\
1654 
	(form_) = DEREF_type(x399_ + 12);\
1655 
	(chums_) = DEREF_list(x399_ + 13);\
1656 
	(defn_) = DEREF_exp(x399_ + 14);\
1657 
	(destroyer_)(x399_, (unsigned)15);\
2 7u83 1658 
    }
1659 
 
1660 
 
1661 
/* Operations for field stat_mem_func of union IDENTIFIER */
1662 
 
6 7u83 1663 
#define id_stat_mem_func_tag		((unsigned)21)
1664 
#define IS_id_stat_mem_func(P)		(CHECK_NULL(P)->ag_tag == 21)
2 7u83 1665 
 
6 7u83 1666 
#define id_stat_mem_func_type(P)	(CHECK_TAG((P), 21) + 10)
1667 
#define id_stat_mem_func_over(P)	(CHECK_TAG((P), 21) + 11)
1668 
#define id_stat_mem_func_form(P)	(CHECK_TAG((P), 21) + 12)
1669 
#define id_stat_mem_func_chums(P)	(CHECK_TAG((P), 21) + 13)
1670 
#define id_stat_mem_func_defn(P)	(CHECK_TAG((P), 21) + 14)
2 7u83 1671 
 
6 7u83 1672 
#define MAKE_id_stat_mem_func(name_, storage_, parent_, loc_, type_, over_, c_class_id)\
2 7u83 1673 
    {\
6 7u83 1674 
	c_class *x400_ = GEN_c_class(15, TYPEID_id);\
1675 
	x400_->ag_tag = 21;\
1676 
	COPY_hashid(x400_ + 1, (name_));\
1677 
	COPY_dspec(x400_ + 2, (storage_));\
1678 
	COPY_nspace(x400_ + 3, (parent_));\
1679 
	COPY_ulong(x400_ + 4, (loc_).line);\
1680 
	COPY_ulong(x400_ + 5, (loc_).column);\
1681 
	COPY_ptr(x400_ + 6, (loc_).posn);\
1682 
	COPY_id(x400_ + 7, x400_);\
1683 
	COPY_ulong(x400_ + 8, LINK_NONE);\
1684 
	COPY_ulong(x400_ + 9, LINK_NONE);\
1685 
	COPY_type(x400_ + 10, (type_));\
1686 
	COPY_id(x400_ + 11, (over_));\
1687 
	COPY_type(x400_ + 12, NULL_type);\
1688 
	COPY_list(x400_ + 13, NULL_list ( CLASS_TYPE ));\
1689 
	COPY_exp(x400_ + 14, NULL_exp);\
1690 
	(c_class_id) = x400_;\
2 7u83 1691 
    }
1692 
 
6 7u83 1693 
#define DECONS_id_stat_mem_func(name_, storage_, parent_, loc_, alias_, no_, dump_, type_, over_, form_, chums_, defn_, c_class_id)\
2 7u83 1694 
    {\
6 7u83 1695 
	c_class *x401_ = CHECK_TAG((c_class_id), 21);\
1696 
	(name_) = DEREF_hashid(x401_ + 1);\
1697 
	(storage_) = DEREF_dspec(x401_ + 2);\
1698 
	(parent_) = DEREF_nspace(x401_ + 3);\
1699 
	(loc_).line = DEREF_ulong(x401_ + 4);\
1700 
	(loc_).column = DEREF_ulong(x401_ + 5);\
1701 
	(loc_).posn = DEREF_ptr(x401_ + 6);\
1702 
	(alias_) = DEREF_id(x401_ + 7);\
1703 
	(no_) = DEREF_ulong(x401_ + 8);\
1704 
	(dump_) = DEREF_ulong(x401_ + 9);\
1705 
	(type_) = DEREF_type(x401_ + 10);\
1706 
	(over_) = DEREF_id(x401_ + 11);\
1707 
	(form_) = DEREF_type(x401_ + 12);\
1708 
	(chums_) = DEREF_list(x401_ + 13);\
1709 
	(defn_) = DEREF_exp(x401_ + 14);\
2 7u83 1710 
    }
1711 
 
6 7u83 1712 
#define DESTROY_id_stat_mem_func(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, type_, over_, form_, chums_, defn_, c_class_id)\
2 7u83 1713 
    {\
6 7u83 1714 
	c_class *x402_ = CHECK_TAG((c_class_id), 21);\
1715 
	(name_) = DEREF_hashid(x402_ + 1);\
1716 
	(storage_) = DEREF_dspec(x402_ + 2);\
1717 
	(parent_) = DEREF_nspace(x402_ + 3);\
1718 
	(loc_).line = DEREF_ulong(x402_ + 4);\
1719 
	(loc_).column = DEREF_ulong(x402_ + 5);\
1720 
	(loc_).posn = DEREF_ptr(x402_ + 6);\
1721 
	(alias_) = DEREF_id(x402_ + 7);\
1722 
	(no_) = DEREF_ulong(x402_ + 8);\
1723 
	(dump_) = DEREF_ulong(x402_ + 9);\
1724 
	(type_) = DEREF_type(x402_ + 10);\
1725 
	(over_) = DEREF_id(x402_ + 11);\
1726 
	(form_) = DEREF_type(x402_ + 12);\
1727 
	(chums_) = DEREF_list(x402_ + 13);\
1728 
	(defn_) = DEREF_exp(x402_ + 14);\
1729 
	(destroyer_)(x402_, (unsigned)15);\
2 7u83 1730 
    }
1731 
 
1732 
 
1733 
/* Operations for field member of union IDENTIFIER */
1734 
 
6 7u83 1735 
#define id_member_tag			((unsigned)22)
1736 
#define IS_id_member(P)			(CHECK_NULL(P)->ag_tag == 22)
2 7u83 1737 
 
6 7u83 1738 
#define id_member_type(P)		(CHECK_TAG((P), 22) + 10)
1739 
#define id_member_off(P)		(CHECK_TAG((P), 22) + 11)
1740 
#define id_member_base(P)		(CHECK_TAG((P), 22) + 12)
2 7u83 1741 
 
6 7u83 1742 
#define MAKE_id_member(name_, storage_, parent_, loc_, type_, c_class_id)\
2 7u83 1743 
    {\
6 7u83 1744 
	c_class *x403_ = GEN_c_class(13, TYPEID_id);\
1745 
	x403_->ag_tag = 22;\
1746 
	COPY_hashid(x403_ + 1, (name_));\
1747 
	COPY_dspec(x403_ + 2, (storage_));\
1748 
	COPY_nspace(x403_ + 3, (parent_));\
1749 
	COPY_ulong(x403_ + 4, (loc_).line);\
1750 
	COPY_ulong(x403_ + 5, (loc_).column);\
1751 
	COPY_ptr(x403_ + 6, (loc_).posn);\
1752 
	COPY_id(x403_ + 7, x403_);\
1753 
	COPY_ulong(x403_ + 8, LINK_NONE);\
1754 
	COPY_ulong(x403_ + 9, LINK_NONE);\
1755 
	COPY_type(x403_ + 10, (type_));\
1756 
	COPY_off(x403_ + 11, NULL_off);\
1757 
	COPY_graph(x403_ + 12, NULL_graph);\
1758 
	(c_class_id) = x403_;\
2 7u83 1759 
    }
1760 
 
6 7u83 1761 
#define DECONS_id_member(name_, storage_, parent_, loc_, alias_, no_, dump_, type_, off_, base_, c_class_id)\
2 7u83 1762 
    {\
6 7u83 1763 
	c_class *x404_ = CHECK_TAG((c_class_id), 22);\
1764 
	(name_) = DEREF_hashid(x404_ + 1);\
1765 
	(storage_) = DEREF_dspec(x404_ + 2);\
1766 
	(parent_) = DEREF_nspace(x404_ + 3);\
1767 
	(loc_).line = DEREF_ulong(x404_ + 4);\
1768 
	(loc_).column = DEREF_ulong(x404_ + 5);\
1769 
	(loc_).posn = DEREF_ptr(x404_ + 6);\
1770 
	(alias_) = DEREF_id(x404_ + 7);\
1771 
	(no_) = DEREF_ulong(x404_ + 8);\
1772 
	(dump_) = DEREF_ulong(x404_ + 9);\
1773 
	(type_) = DEREF_type(x404_ + 10);\
1774 
	(off_) = DEREF_off(x404_ + 11);\
1775 
	(base_) = DEREF_graph(x404_ + 12);\
2 7u83 1776 
    }
1777 
 
6 7u83 1778 
#define DESTROY_id_member(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, type_, off_, base_, c_class_id)\
2 7u83 1779 
    {\
6 7u83 1780 
	c_class *x405_ = CHECK_TAG((c_class_id), 22);\
1781 
	(name_) = DEREF_hashid(x405_ + 1);\
1782 
	(storage_) = DEREF_dspec(x405_ + 2);\
1783 
	(parent_) = DEREF_nspace(x405_ + 3);\
1784 
	(loc_).line = DEREF_ulong(x405_ + 4);\
1785 
	(loc_).column = DEREF_ulong(x405_ + 5);\
1786 
	(loc_).posn = DEREF_ptr(x405_ + 6);\
1787 
	(alias_) = DEREF_id(x405_ + 7);\
1788 
	(no_) = DEREF_ulong(x405_ + 8);\
1789 
	(dump_) = DEREF_ulong(x405_ + 9);\
1790 
	(type_) = DEREF_type(x405_ + 10);\
1791 
	(off_) = DEREF_off(x405_ + 11);\
1792 
	(base_) = DEREF_graph(x405_ + 12);\
1793 
	(destroyer_)(x405_, (unsigned)13);\
2 7u83 1794 
    }
1795 
 
1796 
 
1797 
/* Operations for field enumerator of union IDENTIFIER */
1798 
 
6 7u83 1799 
#define id_enumerator_tag		((unsigned)23)
1800 
#define IS_id_enumerator(P)		(CHECK_NULL(P)->ag_tag == 23)
2 7u83 1801 
 
6 7u83 1802 
#define id_enumerator_etype(P)		(CHECK_TAG((P), 23) + 10)
1803 
#define id_enumerator_value(P)		(CHECK_TAG((P), 23) + 11)
2 7u83 1804 
 
6 7u83 1805 
#define MAKE_id_enumerator(name_, storage_, parent_, loc_, etype_, value_, c_class_id)\
2 7u83 1806 
    {\
6 7u83 1807 
	c_class *x406_ = GEN_c_class(12, TYPEID_id);\
1808 
	x406_->ag_tag = 23;\
1809 
	COPY_hashid(x406_ + 1, (name_));\
1810 
	COPY_dspec(x406_ + 2, (storage_));\
1811 
	COPY_nspace(x406_ + 3, (parent_));\
1812 
	COPY_ulong(x406_ + 4, (loc_).line);\
1813 
	COPY_ulong(x406_ + 5, (loc_).column);\
1814 
	COPY_ptr(x406_ + 6, (loc_).posn);\
1815 
	COPY_id(x406_ + 7, x406_);\
1816 
	COPY_ulong(x406_ + 8, LINK_NONE);\
1817 
	COPY_ulong(x406_ + 9, LINK_NONE);\
1818 
	COPY_type(x406_ + 10, (etype_));\
1819 
	COPY_exp(x406_ + 11, (value_));\
1820 
	(c_class_id) = x406_;\
2 7u83 1821 
    }
1822 
 
6 7u83 1823 
#define DECONS_id_enumerator(name_, storage_, parent_, loc_, alias_, no_, dump_, etype_, value_, c_class_id)\
2 7u83 1824 
    {\
6 7u83 1825 
	c_class *x407_ = CHECK_TAG((c_class_id), 23);\
1826 
	(name_) = DEREF_hashid(x407_ + 1);\
1827 
	(storage_) = DEREF_dspec(x407_ + 2);\
1828 
	(parent_) = DEREF_nspace(x407_ + 3);\
1829 
	(loc_).line = DEREF_ulong(x407_ + 4);\
1830 
	(loc_).column = DEREF_ulong(x407_ + 5);\
1831 
	(loc_).posn = DEREF_ptr(x407_ + 6);\
1832 
	(alias_) = DEREF_id(x407_ + 7);\
1833 
	(no_) = DEREF_ulong(x407_ + 8);\
1834 
	(dump_) = DEREF_ulong(x407_ + 9);\
1835 
	(etype_) = DEREF_type(x407_ + 10);\
1836 
	(value_) = DEREF_exp(x407_ + 11);\
2 7u83 1837 
    }
1838 
 
6 7u83 1839 
#define DESTROY_id_enumerator(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, etype_, value_, c_class_id)\
2 7u83 1840 
    {\
6 7u83 1841 
	c_class *x408_ = CHECK_TAG((c_class_id), 23);\
1842 
	(name_) = DEREF_hashid(x408_ + 1);\
1843 
	(storage_) = DEREF_dspec(x408_ + 2);\
1844 
	(parent_) = DEREF_nspace(x408_ + 3);\
1845 
	(loc_).line = DEREF_ulong(x408_ + 4);\
1846 
	(loc_).column = DEREF_ulong(x408_ + 5);\
1847 
	(loc_).posn = DEREF_ptr(x408_ + 6);\
1848 
	(alias_) = DEREF_id(x408_ + 7);\
1849 
	(no_) = DEREF_ulong(x408_ + 8);\
1850 
	(dump_) = DEREF_ulong(x408_ + 9);\
1851 
	(etype_) = DEREF_type(x408_ + 10);\
1852 
	(value_) = DEREF_exp(x408_ + 11);\
1853 
	(destroyer_)(x408_, (unsigned)12);\
2 7u83 1854 
    }
1855 
 
1856 
 
1857 
/* Operations for field label of union IDENTIFIER */
1858 
 
6 7u83 1859 
#define id_label_tag			((unsigned)24)
1860 
#define IS_id_label(P)			(CHECK_NULL(P)->ag_tag == 24)
2 7u83 1861 
 
6 7u83 1862 
#define id_label_op(P)			(CHECK_TAG((P), 24) + 10)
1863 
#define id_label_stmt(P)		(CHECK_TAG((P), 24) + 11)
1864 
#define id_label_gotos(P)		(CHECK_TAG((P), 24) + 12)
1865 
#define id_label_vars(P)		(CHECK_TAG((P), 24) + 13)
2 7u83 1866 
 
6 7u83 1867 
#define MAKE_id_label(name_, storage_, parent_, loc_, op_, c_class_id)\
2 7u83 1868 
    {\
6 7u83 1869 
	c_class *x409_ = GEN_c_class(14, TYPEID_id);\
1870 
	x409_->ag_tag = 24;\
1871 
	COPY_hashid(x409_ + 1, (name_));\
1872 
	COPY_dspec(x409_ + 2, (storage_));\
1873 
	COPY_nspace(x409_ + 3, (parent_));\
1874 
	COPY_ulong(x409_ + 4, (loc_).line);\
1875 
	COPY_ulong(x409_ + 5, (loc_).column);\
1876 
	COPY_ptr(x409_ + 6, (loc_).posn);\
1877 
	COPY_id(x409_ + 7, x409_);\
1878 
	COPY_ulong(x409_ + 8, LINK_NONE);\
1879 
	COPY_ulong(x409_ + 9, LINK_NONE);\
1880 
	COPY_int(x409_ + 10, (op_));\
1881 
	COPY_exp(x409_ + 11, NULL_exp);\
1882 
	COPY_exp(x409_ + 12, NULL_exp);\
1883 
	COPY_list(x409_ + 13, NULL_list ( VARIABLE ));\
1884 
	(c_class_id) = x409_;\
2 7u83 1885 
    }
1886 
 
6 7u83 1887 
#define DECONS_id_label(name_, storage_, parent_, loc_, alias_, no_, dump_, op_, stmt_, gotos_, vars_, c_class_id)\
2 7u83 1888 
    {\
6 7u83 1889 
	c_class *x410_ = CHECK_TAG((c_class_id), 24);\
1890 
	(name_) = DEREF_hashid(x410_ + 1);\
1891 
	(storage_) = DEREF_dspec(x410_ + 2);\
1892 
	(parent_) = DEREF_nspace(x410_ + 3);\
1893 
	(loc_).line = DEREF_ulong(x410_ + 4);\
1894 
	(loc_).column = DEREF_ulong(x410_ + 5);\
1895 
	(loc_).posn = DEREF_ptr(x410_ + 6);\
1896 
	(alias_) = DEREF_id(x410_ + 7);\
1897 
	(no_) = DEREF_ulong(x410_ + 8);\
1898 
	(dump_) = DEREF_ulong(x410_ + 9);\
1899 
	(op_) = DEREF_int(x410_ + 10);\
1900 
	(stmt_) = DEREF_exp(x410_ + 11);\
1901 
	(gotos_) = DEREF_exp(x410_ + 12);\
1902 
	(vars_) = DEREF_list(x410_ + 13);\
2 7u83 1903 
    }
1904 
 
6 7u83 1905 
#define DESTROY_id_label(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, op_, stmt_, gotos_, vars_, c_class_id)\
2 7u83 1906 
    {\
6 7u83 1907 
	c_class *x411_ = CHECK_TAG((c_class_id), 24);\
1908 
	(name_) = DEREF_hashid(x411_ + 1);\
1909 
	(storage_) = DEREF_dspec(x411_ + 2);\
1910 
	(parent_) = DEREF_nspace(x411_ + 3);\
1911 
	(loc_).line = DEREF_ulong(x411_ + 4);\
1912 
	(loc_).column = DEREF_ulong(x411_ + 5);\
1913 
	(loc_).posn = DEREF_ptr(x411_ + 6);\
1914 
	(alias_) = DEREF_id(x411_ + 7);\
1915 
	(no_) = DEREF_ulong(x411_ + 8);\
1916 
	(dump_) = DEREF_ulong(x411_ + 9);\
1917 
	(op_) = DEREF_int(x411_ + 10);\
1918 
	(stmt_) = DEREF_exp(x411_ + 11);\
1919 
	(gotos_) = DEREF_exp(x411_ + 12);\
1920 
	(vars_) = DEREF_list(x411_ + 13);\
1921 
	(destroyer_)(x411_, (unsigned)14);\
2 7u83 1922 
    }
1923 
 
1924 
 
1925 
/* Operations for field token of union IDENTIFIER */
1926 
 
6 7u83 1927 
#define id_token_tag			((unsigned)25)
1928 
#define IS_id_token(P)			(CHECK_NULL(P)->ag_tag == 25)
2 7u83 1929 
 
6 7u83 1930 
#define id_token_sort(P)		(CHECK_TAG((P), 25) + 10)
1931 
#define id_token_alt(P)			(CHECK_TAG((P), 25) + 11)
2 7u83 1932 
 
6 7u83 1933 
#define MAKE_id_token(name_, storage_, parent_, loc_, sort_, alt_, c_class_id)\
2 7u83 1934 
    {\
6 7u83 1935 
	c_class *x412_ = GEN_c_class(12, TYPEID_id);\
1936 
	x412_->ag_tag = 25;\
1937 
	COPY_hashid(x412_ + 1, (name_));\
1938 
	COPY_dspec(x412_ + 2, (storage_));\
1939 
	COPY_nspace(x412_ + 3, (parent_));\
1940 
	COPY_ulong(x412_ + 4, (loc_).line);\
1941 
	COPY_ulong(x412_ + 5, (loc_).column);\
1942 
	COPY_ptr(x412_ + 6, (loc_).posn);\
1943 
	COPY_id(x412_ + 7, x412_);\
1944 
	COPY_ulong(x412_ + 8, LINK_NONE);\
1945 
	COPY_ulong(x412_ + 9, LINK_NONE);\
1946 
	COPY_tok(x412_ + 10, (sort_));\
1947 
	COPY_id(x412_ + 11, (alt_));\
1948 
	(c_class_id) = x412_;\
2 7u83 1949 
    }
1950 
 
6 7u83 1951 
#define DECONS_id_token(name_, storage_, parent_, loc_, alias_, no_, dump_, sort_, alt_, c_class_id)\
2 7u83 1952 
    {\
6 7u83 1953 
	c_class *x413_ = CHECK_TAG((c_class_id), 25);\
1954 
	(name_) = DEREF_hashid(x413_ + 1);\
1955 
	(storage_) = DEREF_dspec(x413_ + 2);\
1956 
	(parent_) = DEREF_nspace(x413_ + 3);\
1957 
	(loc_).line = DEREF_ulong(x413_ + 4);\
1958 
	(loc_).column = DEREF_ulong(x413_ + 5);\
1959 
	(loc_).posn = DEREF_ptr(x413_ + 6);\
1960 
	(alias_) = DEREF_id(x413_ + 7);\
1961 
	(no_) = DEREF_ulong(x413_ + 8);\
1962 
	(dump_) = DEREF_ulong(x413_ + 9);\
1963 
	(sort_) = DEREF_tok(x413_ + 10);\
1964 
	(alt_) = DEREF_id(x413_ + 11);\
2 7u83 1965 
    }
1966 
 
6 7u83 1967 
#define DESTROY_id_token(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, sort_, alt_, c_class_id)\
2 7u83 1968 
    {\
6 7u83 1969 
	c_class *x414_ = CHECK_TAG((c_class_id), 25);\
1970 
	(name_) = DEREF_hashid(x414_ + 1);\
1971 
	(storage_) = DEREF_dspec(x414_ + 2);\
1972 
	(parent_) = DEREF_nspace(x414_ + 3);\
1973 
	(loc_).line = DEREF_ulong(x414_ + 4);\
1974 
	(loc_).column = DEREF_ulong(x414_ + 5);\
1975 
	(loc_).posn = DEREF_ptr(x414_ + 6);\
1976 
	(alias_) = DEREF_id(x414_ + 7);\
1977 
	(no_) = DEREF_ulong(x414_ + 8);\
1978 
	(dump_) = DEREF_ulong(x414_ + 9);\
1979 
	(sort_) = DEREF_tok(x414_ + 10);\
1980 
	(alt_) = DEREF_id(x414_ + 11);\
1981 
	(destroyer_)(x414_, (unsigned)12);\
2 7u83 1982 
    }
1983 
 
1984 
 
1985 
/* Operations for field ambig of union IDENTIFIER */
1986 
 
6 7u83 1987 
#define id_ambig_tag			((unsigned)26)
1988 
#define IS_id_ambig(P)			(CHECK_NULL(P)->ag_tag == 26)
2 7u83 1989 
 
6 7u83 1990 
#define id_ambig_ids(P)			(CHECK_TAG((P), 26) + 10)
1991 
#define id_ambig_over(P)		(CHECK_TAG((P), 26) + 11)
2 7u83 1992 
 
6 7u83 1993 
#define MAKE_id_ambig(name_, storage_, parent_, loc_, ids_, over_, c_class_id)\
2 7u83 1994 
    {\
6 7u83 1995 
	c_class *x415_ = GEN_c_class(12, TYPEID_id);\
1996 
	x415_->ag_tag = 26;\
1997 
	COPY_hashid(x415_ + 1, (name_));\
1998 
	COPY_dspec(x415_ + 2, (storage_));\
1999 
	COPY_nspace(x415_ + 3, (parent_));\
2000 
	COPY_ulong(x415_ + 4, (loc_).line);\
2001 
	COPY_ulong(x415_ + 5, (loc_).column);\
2002 
	COPY_ptr(x415_ + 6, (loc_).posn);\
2003 
	COPY_id(x415_ + 7, x415_);\
2004 
	COPY_ulong(x415_ + 8, LINK_NONE);\
2005 
	COPY_ulong(x415_ + 9, LINK_NONE);\
2006 
	COPY_list(x415_ + 10, (ids_));\
2007 
	COPY_int(x415_ + 11, (over_));\
2008 
	(c_class_id) = x415_;\
2 7u83 2009 
    }
2010 
 
6 7u83 2011 
#define DECONS_id_ambig(name_, storage_, parent_, loc_, alias_, no_, dump_, ids_, over_, c_class_id)\
2 7u83 2012 
    {\
6 7u83 2013 
	c_class *x416_ = CHECK_TAG((c_class_id), 26);\
2014 
	(name_) = DEREF_hashid(x416_ + 1);\
2015 
	(storage_) = DEREF_dspec(x416_ + 2);\
2016 
	(parent_) = DEREF_nspace(x416_ + 3);\
2017 
	(loc_).line = DEREF_ulong(x416_ + 4);\
2018 
	(loc_).column = DEREF_ulong(x416_ + 5);\
2019 
	(loc_).posn = DEREF_ptr(x416_ + 6);\
2020 
	(alias_) = DEREF_id(x416_ + 7);\
2021 
	(no_) = DEREF_ulong(x416_ + 8);\
2022 
	(dump_) = DEREF_ulong(x416_ + 9);\
2023 
	(ids_) = DEREF_list(x416_ + 10);\
2024 
	(over_) = DEREF_int(x416_ + 11);\
2 7u83 2025 
    }
2026 
 
6 7u83 2027 
#define DESTROY_id_ambig(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, ids_, over_, c_class_id)\
2 7u83 2028 
    {\
6 7u83 2029 
	c_class *x417_ = CHECK_TAG((c_class_id), 26);\
2030 
	(name_) = DEREF_hashid(x417_ + 1);\
2031 
	(storage_) = DEREF_dspec(x417_ + 2);\
2032 
	(parent_) = DEREF_nspace(x417_ + 3);\
2033 
	(loc_).line = DEREF_ulong(x417_ + 4);\
2034 
	(loc_).column = DEREF_ulong(x417_ + 5);\
2035 
	(loc_).posn = DEREF_ptr(x417_ + 6);\
2036 
	(alias_) = DEREF_id(x417_ + 7);\
2037 
	(no_) = DEREF_ulong(x417_ + 8);\
2038 
	(dump_) = DEREF_ulong(x417_ + 9);\
2039 
	(ids_) = DEREF_list(x417_ + 10);\
2040 
	(over_) = DEREF_int(x417_ + 11);\
2041 
	(destroyer_)(x417_, (unsigned)12);\
2 7u83 2042 
    }
2043 
 
2044 
 
2045 
/* Operations for field undef of union IDENTIFIER */
2046 
 
6 7u83 2047 
#define id_undef_tag			((unsigned)27)
2048 
#define IS_id_undef(P)			(CHECK_NULL(P)->ag_tag == 27)
2 7u83 2049 
 
6 7u83 2050 
#define id_undef_form(P)		(CHECK_TAG((P), 27) + 10)
2 7u83 2051 
 
6 7u83 2052 
#define MAKE_id_undef(name_, storage_, parent_, loc_, c_class_id)\
2 7u83 2053 
    {\
6 7u83 2054 
	c_class *x418_ = GEN_c_class(11, TYPEID_id);\
2055 
	x418_->ag_tag = 27;\
2056 
	COPY_hashid(x418_ + 1, (name_));\
2057 
	COPY_dspec(x418_ + 2, (storage_));\
2058 
	COPY_nspace(x418_ + 3, (parent_));\
2059 
	COPY_ulong(x418_ + 4, (loc_).line);\
2060 
	COPY_ulong(x418_ + 5, (loc_).column);\
2061 
	COPY_ptr(x418_ + 6, (loc_).posn);\
2062 
	COPY_id(x418_ + 7, x418_);\
2063 
	COPY_ulong(x418_ + 8, LINK_NONE);\
2064 
	COPY_ulong(x418_ + 9, LINK_NONE);\
2065 
	COPY_type(x418_ + 10, NULL_type);\
2066 
	(c_class_id) = x418_;\
2 7u83 2067 
    }
2068 
 
6 7u83 2069 
#define DECONS_id_undef(name_, storage_, parent_, loc_, alias_, no_, dump_, form_, c_class_id)\
2 7u83 2070 
    {\
6 7u83 2071 
	c_class *x419_ = CHECK_TAG((c_class_id), 27);\
2072 
	(name_) = DEREF_hashid(x419_ + 1);\
2073 
	(storage_) = DEREF_dspec(x419_ + 2);\
2074 
	(parent_) = DEREF_nspace(x419_ + 3);\
2075 
	(loc_).line = DEREF_ulong(x419_ + 4);\
2076 
	(loc_).column = DEREF_ulong(x419_ + 5);\
2077 
	(loc_).posn = DEREF_ptr(x419_ + 6);\
2078 
	(alias_) = DEREF_id(x419_ + 7);\
2079 
	(no_) = DEREF_ulong(x419_ + 8);\
2080 
	(dump_) = DEREF_ulong(x419_ + 9);\
2081 
	(form_) = DEREF_type(x419_ + 10);\
2 7u83 2082 
    }
2083 
 
6 7u83 2084 
#define DESTROY_id_undef(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, form_, c_class_id)\
2 7u83 2085 
    {\
6 7u83 2086 
	c_class *x420_ = CHECK_TAG((c_class_id), 27);\
2087 
	(name_) = DEREF_hashid(x420_ + 1);\
2088 
	(storage_) = DEREF_dspec(x420_ + 2);\
2089 
	(parent_) = DEREF_nspace(x420_ + 3);\
2090 
	(loc_).line = DEREF_ulong(x420_ + 4);\
2091 
	(loc_).column = DEREF_ulong(x420_ + 5);\
2092 
	(loc_).posn = DEREF_ptr(x420_ + 6);\
2093 
	(alias_) = DEREF_id(x420_ + 7);\
2094 
	(no_) = DEREF_ulong(x420_ + 8);\
2095 
	(dump_) = DEREF_ulong(x420_ + 9);\
2096 
	(form_) = DEREF_type(x420_ + 10);\
2097 
	(destroyer_)(x420_, (unsigned)11);\
2 7u83 2098 
    }
2099 
 
2100 
 
2101 
/* Operations for field pending of union IDENTIFIER */
2102 
 
6 7u83 2103 
#define id_pending_tag			((unsigned)28)
2104 
#define IS_id_pending(P)		(CHECK_NULL(P)->ag_tag == 28)
2 7u83 2105 
 
6 7u83 2106 
#define id_pending_itag(P)		(CHECK_TAG((P), 28) + 10)
2107 
#define id_pending_type(P)		(CHECK_TAG((P), 28) + 11)
2 7u83 2108 
 
6 7u83 2109 
#define MAKE_id_pending(name_, storage_, parent_, loc_, itag_, type_, c_class_id)\
2 7u83 2110 
    {\
6 7u83 2111 
	c_class *x421_ = GEN_c_class(12, TYPEID_id);\
2112 
	x421_->ag_tag = 28;\
2113 
	COPY_hashid(x421_ + 1, (name_));\
2114 
	COPY_dspec(x421_ + 2, (storage_));\
2115 
	COPY_nspace(x421_ + 3, (parent_));\
2116 
	COPY_ulong(x421_ + 4, (loc_).line);\
2117 
	COPY_ulong(x421_ + 5, (loc_).column);\
2118 
	COPY_ptr(x421_ + 6, (loc_).posn);\
2119 
	COPY_id(x421_ + 7, x421_);\
2120 
	COPY_ulong(x421_ + 8, LINK_NONE);\
2121 
	COPY_ulong(x421_ + 9, LINK_NONE);\
2122 
	COPY_unsigned(x421_ + 10, (itag_));\
2123 
	COPY_type(x421_ + 11, (type_));\
2124 
	(c_class_id) = x421_;\
2 7u83 2125 
    }
2126 
 
6 7u83 2127 
#define DECONS_id_pending(name_, storage_, parent_, loc_, alias_, no_, dump_, itag_, type_, c_class_id)\
2 7u83 2128 
    {\
6 7u83 2129 
	c_class *x422_ = CHECK_TAG((c_class_id), 28);\
2130 
	(name_) = DEREF_hashid(x422_ + 1);\
2131 
	(storage_) = DEREF_dspec(x422_ + 2);\
2132 
	(parent_) = DEREF_nspace(x422_ + 3);\
2133 
	(loc_).line = DEREF_ulong(x422_ + 4);\
2134 
	(loc_).column = DEREF_ulong(x422_ + 5);\
2135 
	(loc_).posn = DEREF_ptr(x422_ + 6);\
2136 
	(alias_) = DEREF_id(x422_ + 7);\
2137 
	(no_) = DEREF_ulong(x422_ + 8);\
2138 
	(dump_) = DEREF_ulong(x422_ + 9);\
2139 
	(itag_) = DEREF_unsigned(x422_ + 10);\
2140 
	(type_) = DEREF_type(x422_ + 11);\
2 7u83 2141 
    }
2142 
 
6 7u83 2143 
#define DESTROY_id_pending(destroyer_, name_, storage_, parent_, loc_, alias_, no_, dump_, itag_, type_, c_class_id)\
2 7u83 2144 
    {\
6 7u83 2145 
	c_class *x423_ = CHECK_TAG((c_class_id), 28);\
2146 
	(name_) = DEREF_hashid(x423_ + 1);\
2147 
	(storage_) = DEREF_dspec(x423_ + 2);\
2148 
	(parent_) = DEREF_nspace(x423_ + 3);\
2149 
	(loc_).line = DEREF_ulong(x423_ + 4);\
2150 
	(loc_).column = DEREF_ulong(x423_ + 5);\
2151 
	(loc_).posn = DEREF_ptr(x423_ + 6);\
2152 
	(alias_) = DEREF_id(x423_ + 7);\
2153 
	(no_) = DEREF_ulong(x423_ + 8);\
2154 
	(dump_) = DEREF_ulong(x423_ + 9);\
2155 
	(itag_) = DEREF_unsigned(x423_ + 10);\
2156 
	(type_) = DEREF_type(x423_ + 11);\
2157 
	(destroyer_)(x423_, (unsigned)12);\
2 7u83 2158 
    }
2159 
 
2160 
 
2161 
#endif