Subversion Repositories tendra.SVN

Rev

Rev 5 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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