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 NSPACE_OPS_H_INCLUDED
 35 
#ifndef NSPACE_OPS_H_INCLUDED
36 
#define NSPACE_OPS_H_INCLUDED
 36 
#define NSPACE_OPS_H_INCLUDED
37 
 
 37 
 
38 
/* Operations for union NAMESPACE */
 38 
/* Operations for union NAMESPACE */
39 
 
 39 
 
40 
#define TAG_nspace( P )			( CHECK_NULL ( P )->ag_tag )
 40 
#define TAG_nspace(P)			(CHECK_NULL(P)->ag_tag)
41 
 
 41 
 
42 
 
 42 
 
43 
/* Operations for component name of union NAMESPACE */
 43 
/* Operations for component name of union NAMESPACE */
44 
 
 44 
 
45 
#define nspace_name( P )		( CHECK_NULL ( P ) + 1 )
 45 
#define nspace_name(P)			(CHECK_NULL(P) + 1)
46 
 
 46 
 
47 
 
 47 
 
48 
/* Operations for component last of union NAMESPACE */
 48 
/* Operations for component last of union NAMESPACE */
49 
 
 49 
 
50 
#define nspace_last( P )		( CHECK_NULL ( P ) + 2 )
 50 
#define nspace_last(P)			(CHECK_NULL(P) + 2)
51 
 
 51 
 
52 
 
 52 
 
53 
/* Operations for component prev of union NAMESPACE */
 53 
/* Operations for component prev of union NAMESPACE */
54 
 
 54 
 
55 
#define nspace_prev( P )		( CHECK_NULL ( P ) + 3 )
 55 
#define nspace_prev(P)			(CHECK_NULL(P) + 3)
56 
 
 56 
 
57 
 
 57 
 
58 
/* Operations for component parent of union NAMESPACE */
 58 
/* Operations for component parent of union NAMESPACE */
59 
 
 59 
 
60 
#define nspace_parent( P )		( CHECK_NULL ( P ) + 4 )
 60 
#define nspace_parent(P)		(CHECK_NULL(P) + 4)
61 
 
 61 
 
62 
 
 62 
 
63 
/* Operations for component use of union NAMESPACE */
 63 
/* Operations for component use of union NAMESPACE */
64 
 
 64 
 
65 
#define nspace_use( P )			( CHECK_NULL ( P ) + 5 )
 65 
#define nspace_use(P)			(CHECK_NULL(P) + 5)
66 
 
 66 
 
67 
 
 67 
 
68 
/* Operations for component join of union NAMESPACE */
 68 
/* Operations for component join of union NAMESPACE */
69 
 
 69 
 
70 
#define nspace_join( P )		( CHECK_NULL ( P ) + 6 )
 70 
#define nspace_join(P)			(CHECK_NULL(P) + 6)
71 
 
 71 
 
72 
 
 72 
 
73 
/* Operations for component set of union NAMESPACE */
 73 
/* Operations for component set of union NAMESPACE */
74 
 
 74 
 
75 
#define nspace_set( P )			( CHECK_NULL ( P ) + 7 )
 75 
#define nspace_set(P)			(CHECK_NULL(P) + 7)
76 
 
 76 
 
77 
 
 77 
 
78 
/* Operations for component dump of union NAMESPACE */
 78 
/* Operations for component dump of union NAMESPACE */
79 
 
 79 
 
80 
#define nspace_dump( P )		( CHECK_NULL ( P ) + 8 )
 80 
#define nspace_dump(P)			(CHECK_NULL(P) + 8)
81 
 
 81 
 
82 
 
 82 
 
83 
/* Operations for field set block_etc of union NAMESPACE */
 83 
/* Operations for field set block_etc of union NAMESPACE */
84 
 
 84 
 
85 
#define nspace_block_etc_tag		( ( unsigned ) 5 )
 85 
#define nspace_block_etc_tag		((unsigned)5)
86 
#define IS_nspace_block_etc( P )	( ( unsigned ) ( CHECK_NULL ( P )->ag_tag - 0 ) < ( unsigned ) 5 )
 86 
#define IS_nspace_block_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 0) < (unsigned)5)
87 
 
 87 
 
88 
 
 88 
 
89 
#define MAKE_nspace_block_etc( tag, name_, parent_, c_class_nspace )\
 89 
#define MAKE_nspace_block_etc(tag, name_, parent_, c_class_nspace)\
90 
    {\
 90 
    {\
91 
	c_class *x430_ = GEN_c_class ( 9, TYPEID_nspace ) ;\
 91 
	c_class *x430_ = GEN_c_class(9, TYPEID_nspace);\
92 
	x430_->ag_tag = ( tag ) ;\
 92 
	x430_->ag_tag = (tag);\
93 
	COPY_id ( x430_ + 1, ( name_ ) ) ;\
 93 
	COPY_id(x430_ + 1, (name_));\
94 
	COPY_member ( x430_ + 2, NULL_member ) ;\
 94 
	COPY_member(x430_ + 2, NULL_member);\
95 
	COPY_member ( x430_ + 3, NULL_member ) ;\
 95 
	COPY_member(x430_ + 3, NULL_member);\
96 
	COPY_nspace ( x430_ + 4, ( parent_ ) ) ;\
 96 
	COPY_nspace(x430_ + 4, (parent_));\
97 
	COPY_list ( x430_ + 5, NULL_list ( NAMESPACE ) ) ;\
 97 
	COPY_list(x430_ + 5, NULL_list ( NAMESPACE ));\
98 
	COPY_list ( x430_ + 6, NULL_list ( NAMESPACE ) ) ;\
 98 
	COPY_list(x430_ + 6, NULL_list ( NAMESPACE ));\
99 
	COPY_stack ( x430_ + 7, NULL_stack ( IDENTIFIER ) ) ;\
 99 
	COPY_stack(x430_ + 7, NULL_stack ( IDENTIFIER ));\
100 
	COPY_ulong ( x430_ + 8, LINK_NONE ) ;\
 100 
	COPY_ulong(x430_ + 8, LINK_NONE);\
101 
	( c_class_nspace ) = CHECK_TAG_ETC ( x430_, 0, 5 ) ;\
 101 
	(c_class_nspace) = CHECK_TAG_ETC(x430_, 0, 5);\
102 
    }
 102 
    }
103 
 
 103 
 
104 
#define MODIFY_nspace_block_etc( tag, c_class_nspace )\
 104 
#define MODIFY_nspace_block_etc(tag, c_class_nspace)\
105 
    {\
 105 
    {\
106 
	c_class *x431_ = CHECK_TAG_ETC ( ( c_class_nspace ), 0, 5 ) ;\
 106 
	c_class *x431_ = CHECK_TAG_ETC ((c_class_nspace), 0, 5);\
107 
	x431_->ag_tag = ( tag ) ;\
 107 
	x431_->ag_tag = (tag);\
108 
	( void ) CHECK_TAG_ETC ( x431_, 0, 5 ) ;\
 108 
	(void) CHECK_TAG_ETC (x431_, 0, 5);\
109 
    }
 109 
    }
110 
 
 110 
 
111 
#define DECONS_nspace_block_etc( name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 111 
#define DECONS_nspace_block_etc(name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
112 
    {\
 112 
    {\
113 
	c_class *x432_ = CHECK_TAG_ETC ( ( c_class_nspace ), 0, 5 ) ;\
 113 
	c_class *x432_ = CHECK_TAG_ETC((c_class_nspace), 0, 5);\
114 
	( name_ ) = DEREF_id ( x432_ + 1 ) ;\
 114 
	(name_) = DEREF_id(x432_ + 1);\
115 
	( last_ ) = DEREF_member ( x432_ + 2 ) ;\
 115 
	(last_) = DEREF_member(x432_ + 2);\
116 
	( prev_ ) = DEREF_member ( x432_ + 3 ) ;\
 116 
	(prev_) = DEREF_member(x432_ + 3);\
117 
	( parent_ ) = DEREF_nspace ( x432_ + 4 ) ;\
 117 
	(parent_) = DEREF_nspace(x432_ + 4);\
118 
	( use_ ) = DEREF_list ( x432_ + 5 ) ;\
 118 
	(use_) = DEREF_list(x432_ + 5);\
119 
	( join_ ) = DEREF_list ( x432_ + 6 ) ;\
 119 
	(join_) = DEREF_list(x432_ + 6);\
120 
	( set_ ) = DEREF_stack ( x432_ + 7 ) ;\
 120 
	(set_) = DEREF_stack(x432_ + 7);\
121 
	( dump_ ) = DEREF_ulong ( x432_ + 8 ) ;\
 121 
	(dump_) = DEREF_ulong(x432_ + 8);\
122 
    }
 122 
    }
123 
 
 123 
 
124 
#define DESTROY_nspace_block_etc( destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 124 
#define DESTROY_nspace_block_etc(destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
125 
    {\
 125 
    {\
126 
	c_class *x433_ = CHECK_TAG_ETC ( ( c_class_nspace ), 0, 5 ) ;\
 126 
	c_class *x433_ = CHECK_TAG_ETC((c_class_nspace), 0, 5);\
127 
	( name_ ) = DEREF_id ( x433_ + 1 ) ;\
 127 
	(name_) = DEREF_id(x433_ + 1);\
128 
	( last_ ) = DEREF_member ( x433_ + 2 ) ;\
 128 
	(last_) = DEREF_member(x433_ + 2);\
129 
	( prev_ ) = DEREF_member ( x433_ + 3 ) ;\
 129 
	(prev_) = DEREF_member(x433_ + 3);\
130 
	( parent_ ) = DEREF_nspace ( x433_ + 4 ) ;\
 130 
	(parent_) = DEREF_nspace(x433_ + 4);\
131 
	( use_ ) = DEREF_list ( x433_ + 5 ) ;\
 131 
	(use_) = DEREF_list(x433_ + 5);\
132 
	( join_ ) = DEREF_list ( x433_ + 6 ) ;\
 132 
	(join_) = DEREF_list(x433_ + 6);\
133 
	( set_ ) = DEREF_stack ( x433_ + 7 ) ;\
 133 
	(set_) = DEREF_stack(x433_ + 7);\
134 
	( dump_ ) = DEREF_ulong ( x433_ + 8 ) ;\
 134 
	(dump_) = DEREF_ulong(x433_ + 8);\
135 
	( destroyer_ ) ( x433_, ( unsigned ) 9 ) ;\
 135 
	(destroyer_)(x433_, (unsigned)9);\
136 
    }
 136 
    }
137 
 
 137 
 
138 
 
 138 
 
139 
/* Operations for field block of union NAMESPACE */
 139 
/* Operations for field block of union NAMESPACE */
140 
 
 140 
 
141 
#define nspace_block_tag		( ( unsigned ) 0 )
 141 
#define nspace_block_tag		((unsigned)0)
142 
#define IS_nspace_block( P )		( CHECK_NULL ( P )->ag_tag == 0 )
 142 
#define IS_nspace_block(P)		(CHECK_NULL(P)->ag_tag == 0)
143 
 
 143 
 
144 
 
 144 
 
145 
#define MAKE_nspace_block( name_, parent_, c_class_nspace )\
 145 
#define MAKE_nspace_block(name_, parent_, c_class_nspace)\
146 
    {\
 146 
    {\
147 
	c_class *x434_ = GEN_c_class ( 9, TYPEID_nspace ) ;\
 147 
	c_class *x434_ = GEN_c_class(9, TYPEID_nspace);\
148 
	x434_->ag_tag = 0 ;\
 148 
	x434_->ag_tag = 0;\
149 
	COPY_id ( x434_ + 1, ( name_ ) ) ;\
 149 
	COPY_id(x434_ + 1, (name_));\
150 
	COPY_member ( x434_ + 2, NULL_member ) ;\
 150 
	COPY_member(x434_ + 2, NULL_member);\
151 
	COPY_member ( x434_ + 3, NULL_member ) ;\
 151 
	COPY_member(x434_ + 3, NULL_member);\
152 
	COPY_nspace ( x434_ + 4, ( parent_ ) ) ;\
 152 
	COPY_nspace(x434_ + 4, (parent_));\
153 
	COPY_list ( x434_ + 5, NULL_list ( NAMESPACE ) ) ;\
 153 
	COPY_list(x434_ + 5, NULL_list ( NAMESPACE ));\
154 
	COPY_list ( x434_ + 6, NULL_list ( NAMESPACE ) ) ;\
 154 
	COPY_list(x434_ + 6, NULL_list ( NAMESPACE ));\
155 
	COPY_stack ( x434_ + 7, NULL_stack ( IDENTIFIER ) ) ;\
 155 
	COPY_stack(x434_ + 7, NULL_stack ( IDENTIFIER ));\
156 
	COPY_ulong ( x434_ + 8, LINK_NONE ) ;\
 156 
	COPY_ulong(x434_ + 8, LINK_NONE);\
157 
	( c_class_nspace ) = x434_ ;\
 157 
	(c_class_nspace) = x434_;\
158 
    }
 158 
    }
159 
 
 159 
 
160 
#define DECONS_nspace_block( name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 160 
#define DECONS_nspace_block(name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
161 
    {\
 161 
    {\
162 
	c_class *x435_ = CHECK_TAG ( ( c_class_nspace ), 0 ) ;\
 162 
	c_class *x435_ = CHECK_TAG((c_class_nspace), 0);\
163 
	( name_ ) = DEREF_id ( x435_ + 1 ) ;\
 163 
	(name_) = DEREF_id(x435_ + 1);\
164 
	( last_ ) = DEREF_member ( x435_ + 2 ) ;\
 164 
	(last_) = DEREF_member(x435_ + 2);\
165 
	( prev_ ) = DEREF_member ( x435_ + 3 ) ;\
 165 
	(prev_) = DEREF_member(x435_ + 3);\
166 
	( parent_ ) = DEREF_nspace ( x435_ + 4 ) ;\
 166 
	(parent_) = DEREF_nspace(x435_ + 4);\
167 
	( use_ ) = DEREF_list ( x435_ + 5 ) ;\
 167 
	(use_) = DEREF_list(x435_ + 5);\
168 
	( join_ ) = DEREF_list ( x435_ + 6 ) ;\
 168 
	(join_) = DEREF_list(x435_ + 6);\
169 
	( set_ ) = DEREF_stack ( x435_ + 7 ) ;\
 169 
	(set_) = DEREF_stack(x435_ + 7);\
170 
	( dump_ ) = DEREF_ulong ( x435_ + 8 ) ;\
 170 
	(dump_) = DEREF_ulong(x435_ + 8);\
171 
    }
 171 
    }
172 
 
 172 
 
173 
#define DESTROY_nspace_block( destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 173 
#define DESTROY_nspace_block(destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
174 
    {\
 174 
    {\
175 
	c_class *x436_ = CHECK_TAG ( ( c_class_nspace ), 0 ) ;\
 175 
	c_class *x436_ = CHECK_TAG((c_class_nspace), 0);\
176 
	( name_ ) = DEREF_id ( x436_ + 1 ) ;\
 176 
	(name_) = DEREF_id(x436_ + 1);\
177 
	( last_ ) = DEREF_member ( x436_ + 2 ) ;\
 177 
	(last_) = DEREF_member(x436_ + 2);\
178 
	( prev_ ) = DEREF_member ( x436_ + 3 ) ;\
 178 
	(prev_) = DEREF_member(x436_ + 3);\
179 
	( parent_ ) = DEREF_nspace ( x436_ + 4 ) ;\
 179 
	(parent_) = DEREF_nspace(x436_ + 4);\
180 
	( use_ ) = DEREF_list ( x436_ + 5 ) ;\
 180 
	(use_) = DEREF_list(x436_ + 5);\
181 
	( join_ ) = DEREF_list ( x436_ + 6 ) ;\
 181 
	(join_) = DEREF_list(x436_ + 6);\
182 
	( set_ ) = DEREF_stack ( x436_ + 7 ) ;\
 182 
	(set_) = DEREF_stack(x436_ + 7);\
183 
	( dump_ ) = DEREF_ulong ( x436_ + 8 ) ;\
 183 
	(dump_) = DEREF_ulong(x436_ + 8);\
184 
	( destroyer_ ) ( x436_, ( unsigned ) 9 ) ;\
 184 
	(destroyer_)(x436_, (unsigned)9);\
185 
    }
 185 
    }
186 
 
 186 
 
187 
 
 187 
 
188 
/* Operations for field param of union NAMESPACE */
 188 
/* Operations for field param of union NAMESPACE */
189 
 
 189 
 
190 
#define nspace_param_tag		( ( unsigned ) 1 )
 190 
#define nspace_param_tag		((unsigned)1)
191 
#define IS_nspace_param( P )		( CHECK_NULL ( P )->ag_tag == 1 )
 191 
#define IS_nspace_param(P)		(CHECK_NULL(P)->ag_tag == 1)
192 
 
 192 
 
193 
 
 193 
 
194 
#define MAKE_nspace_param( name_, parent_, c_class_nspace )\
 194 
#define MAKE_nspace_param(name_, parent_, c_class_nspace)\
195 
    {\
 195 
    {\
196 
	c_class *x437_ = GEN_c_class ( 9, TYPEID_nspace ) ;\
 196 
	c_class *x437_ = GEN_c_class(9, TYPEID_nspace);\
197 
	x437_->ag_tag = 1 ;\
 197 
	x437_->ag_tag = 1;\
198 
	COPY_id ( x437_ + 1, ( name_ ) ) ;\
 198 
	COPY_id(x437_ + 1, (name_));\
199 
	COPY_member ( x437_ + 2, NULL_member ) ;\
 199 
	COPY_member(x437_ + 2, NULL_member);\
200 
	COPY_member ( x437_ + 3, NULL_member ) ;\
 200 
	COPY_member(x437_ + 3, NULL_member);\
201 
	COPY_nspace ( x437_ + 4, ( parent_ ) ) ;\
 201 
	COPY_nspace(x437_ + 4, (parent_));\
202 
	COPY_list ( x437_ + 5, NULL_list ( NAMESPACE ) ) ;\
 202 
	COPY_list(x437_ + 5, NULL_list ( NAMESPACE ));\
203 
	COPY_list ( x437_ + 6, NULL_list ( NAMESPACE ) ) ;\
 203 
	COPY_list(x437_ + 6, NULL_list ( NAMESPACE ));\
204 
	COPY_stack ( x437_ + 7, NULL_stack ( IDENTIFIER ) ) ;\
 204 
	COPY_stack(x437_ + 7, NULL_stack ( IDENTIFIER ));\
205 
	COPY_ulong ( x437_ + 8, LINK_NONE ) ;\
 205 
	COPY_ulong(x437_ + 8, LINK_NONE);\
206 
	( c_class_nspace ) = x437_ ;\
 206 
	(c_class_nspace) = x437_;\
207 
    }
 207 
    }
208 
 
 208 
 
209 
#define DECONS_nspace_param( name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 209 
#define DECONS_nspace_param(name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
210 
    {\
 210 
    {\
211 
	c_class *x438_ = CHECK_TAG ( ( c_class_nspace ), 1 ) ;\
 211 
	c_class *x438_ = CHECK_TAG((c_class_nspace), 1);\
212 
	( name_ ) = DEREF_id ( x438_ + 1 ) ;\
 212 
	(name_) = DEREF_id(x438_ + 1);\
213 
	( last_ ) = DEREF_member ( x438_ + 2 ) ;\
 213 
	(last_) = DEREF_member(x438_ + 2);\
214 
	( prev_ ) = DEREF_member ( x438_ + 3 ) ;\
 214 
	(prev_) = DEREF_member(x438_ + 3);\
215 
	( parent_ ) = DEREF_nspace ( x438_ + 4 ) ;\
 215 
	(parent_) = DEREF_nspace(x438_ + 4);\
216 
	( use_ ) = DEREF_list ( x438_ + 5 ) ;\
 216 
	(use_) = DEREF_list(x438_ + 5);\
217 
	( join_ ) = DEREF_list ( x438_ + 6 ) ;\
 217 
	(join_) = DEREF_list(x438_ + 6);\
218 
	( set_ ) = DEREF_stack ( x438_ + 7 ) ;\
 218 
	(set_) = DEREF_stack(x438_ + 7);\
219 
	( dump_ ) = DEREF_ulong ( x438_ + 8 ) ;\
 219 
	(dump_) = DEREF_ulong(x438_ + 8);\
220 
    }
 220 
    }
221 
 
 221 
 
222 
#define DESTROY_nspace_param( destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 222 
#define DESTROY_nspace_param(destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
223 
    {\
 223 
    {\
224 
	c_class *x439_ = CHECK_TAG ( ( c_class_nspace ), 1 ) ;\
 224 
	c_class *x439_ = CHECK_TAG((c_class_nspace), 1);\
225 
	( name_ ) = DEREF_id ( x439_ + 1 ) ;\
 225 
	(name_) = DEREF_id(x439_ + 1);\
226 
	( last_ ) = DEREF_member ( x439_ + 2 ) ;\
 226 
	(last_) = DEREF_member(x439_ + 2);\
227 
	( prev_ ) = DEREF_member ( x439_ + 3 ) ;\
 227 
	(prev_) = DEREF_member(x439_ + 3);\
228 
	( parent_ ) = DEREF_nspace ( x439_ + 4 ) ;\
 228 
	(parent_) = DEREF_nspace(x439_ + 4);\
229 
	( use_ ) = DEREF_list ( x439_ + 5 ) ;\
 229 
	(use_) = DEREF_list(x439_ + 5);\
230 
	( join_ ) = DEREF_list ( x439_ + 6 ) ;\
 230 
	(join_) = DEREF_list(x439_ + 6);\
231 
	( set_ ) = DEREF_stack ( x439_ + 7 ) ;\
 231 
	(set_) = DEREF_stack(x439_ + 7);\
232 
	( dump_ ) = DEREF_ulong ( x439_ + 8 ) ;\
 232 
	(dump_) = DEREF_ulong(x439_ + 8);\
233 
	( destroyer_ ) ( x439_, ( unsigned ) 9 ) ;\
 233 
	(destroyer_)(x439_, (unsigned)9);\
234 
    }
 234 
    }
235 
 
 235 
 
236 
 
 236 
 
237 
/* Operations for field dummy of union NAMESPACE */
 237 
/* Operations for field dummy of union NAMESPACE */
238 
 
 238 
 
239 
#define nspace_dummy_tag		( ( unsigned ) 2 )
 239 
#define nspace_dummy_tag		((unsigned)2)
240 
#define IS_nspace_dummy( P )		( CHECK_NULL ( P )->ag_tag == 2 )
 240 
#define IS_nspace_dummy(P)		(CHECK_NULL(P)->ag_tag == 2)
241 
 
 241 
 
242 
 
 242 
 
243 
#define MAKE_nspace_dummy( name_, parent_, c_class_nspace )\
 243 
#define MAKE_nspace_dummy(name_, parent_, c_class_nspace)\
244 
    {\
 244 
    {\
245 
	c_class *x440_ = GEN_c_class ( 9, TYPEID_nspace ) ;\
 245 
	c_class *x440_ = GEN_c_class(9, TYPEID_nspace);\
246 
	x440_->ag_tag = 2 ;\
 246 
	x440_->ag_tag = 2;\
247 
	COPY_id ( x440_ + 1, ( name_ ) ) ;\
 247 
	COPY_id(x440_ + 1, (name_));\
248 
	COPY_member ( x440_ + 2, NULL_member ) ;\
 248 
	COPY_member(x440_ + 2, NULL_member);\
249 
	COPY_member ( x440_ + 3, NULL_member ) ;\
 249 
	COPY_member(x440_ + 3, NULL_member);\
250 
	COPY_nspace ( x440_ + 4, ( parent_ ) ) ;\
 250 
	COPY_nspace(x440_ + 4, (parent_));\
251 
	COPY_list ( x440_ + 5, NULL_list ( NAMESPACE ) ) ;\
 251 
	COPY_list(x440_ + 5, NULL_list ( NAMESPACE ));\
252 
	COPY_list ( x440_ + 6, NULL_list ( NAMESPACE ) ) ;\
 252 
	COPY_list(x440_ + 6, NULL_list ( NAMESPACE ));\
253 
	COPY_stack ( x440_ + 7, NULL_stack ( IDENTIFIER ) ) ;\
 253 
	COPY_stack(x440_ + 7, NULL_stack ( IDENTIFIER ));\
254 
	COPY_ulong ( x440_ + 8, LINK_NONE ) ;\
 254 
	COPY_ulong(x440_ + 8, LINK_NONE);\
255 
	( c_class_nspace ) = x440_ ;\
 255 
	(c_class_nspace) = x440_;\
256 
    }
 256 
    }
257 
 
 257 
 
258 
#define DECONS_nspace_dummy( name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 258 
#define DECONS_nspace_dummy(name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
259 
    {\
 259 
    {\
260 
	c_class *x441_ = CHECK_TAG ( ( c_class_nspace ), 2 ) ;\
 260 
	c_class *x441_ = CHECK_TAG((c_class_nspace), 2);\
261 
	( name_ ) = DEREF_id ( x441_ + 1 ) ;\
 261 
	(name_) = DEREF_id(x441_ + 1);\
262 
	( last_ ) = DEREF_member ( x441_ + 2 ) ;\
 262 
	(last_) = DEREF_member(x441_ + 2);\
263 
	( prev_ ) = DEREF_member ( x441_ + 3 ) ;\
 263 
	(prev_) = DEREF_member(x441_ + 3);\
264 
	( parent_ ) = DEREF_nspace ( x441_ + 4 ) ;\
 264 
	(parent_) = DEREF_nspace(x441_ + 4);\
265 
	( use_ ) = DEREF_list ( x441_ + 5 ) ;\
 265 
	(use_) = DEREF_list(x441_ + 5);\
266 
	( join_ ) = DEREF_list ( x441_ + 6 ) ;\
 266 
	(join_) = DEREF_list(x441_ + 6);\
267 
	( set_ ) = DEREF_stack ( x441_ + 7 ) ;\
 267 
	(set_) = DEREF_stack(x441_ + 7);\
268 
	( dump_ ) = DEREF_ulong ( x441_ + 8 ) ;\
 268 
	(dump_) = DEREF_ulong(x441_ + 8);\
269 
    }
 269 
    }
270 
 
 270 
 
271 
#define DESTROY_nspace_dummy( destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 271 
#define DESTROY_nspace_dummy(destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
272 
    {\
 272 
    {\
273 
	c_class *x442_ = CHECK_TAG ( ( c_class_nspace ), 2 ) ;\
 273 
	c_class *x442_ = CHECK_TAG((c_class_nspace), 2);\
274 
	( name_ ) = DEREF_id ( x442_ + 1 ) ;\
 274 
	(name_) = DEREF_id(x442_ + 1);\
275 
	( last_ ) = DEREF_member ( x442_ + 2 ) ;\
 275 
	(last_) = DEREF_member(x442_ + 2);\
276 
	( prev_ ) = DEREF_member ( x442_ + 3 ) ;\
 276 
	(prev_) = DEREF_member(x442_ + 3);\
277 
	( parent_ ) = DEREF_nspace ( x442_ + 4 ) ;\
 277 
	(parent_) = DEREF_nspace(x442_ + 4);\
278 
	( use_ ) = DEREF_list ( x442_ + 5 ) ;\
 278 
	(use_) = DEREF_list(x442_ + 5);\
279 
	( join_ ) = DEREF_list ( x442_ + 6 ) ;\
 279 
	(join_) = DEREF_list(x442_ + 6);\
280 
	( set_ ) = DEREF_stack ( x442_ + 7 ) ;\
 280 
	(set_) = DEREF_stack(x442_ + 7);\
281 
	( dump_ ) = DEREF_ulong ( x442_ + 8 ) ;\
 281 
	(dump_) = DEREF_ulong(x442_ + 8);\
282 
	( destroyer_ ) ( x442_, ( unsigned ) 9 ) ;\
 282 
	(destroyer_)(x442_, (unsigned)9);\
283 
    }
 283 
    }
284 
 
 284 
 
285 
 
 285 
 
286 
/* Operations for field label of union NAMESPACE */
 286 
/* Operations for field label of union NAMESPACE */
287 
 
 287 
 
288 
#define nspace_label_tag		( ( unsigned ) 3 )
 288 
#define nspace_label_tag		((unsigned)3)
289 
#define IS_nspace_label( P )		( CHECK_NULL ( P )->ag_tag == 3 )
 289 
#define IS_nspace_label(P)		(CHECK_NULL(P)->ag_tag == 3)
290 
 
 290 
 
291 
 
 291 
 
292 
#define MAKE_nspace_label( name_, parent_, c_class_nspace )\
 292 
#define MAKE_nspace_label(name_, parent_, c_class_nspace)\
293 
    {\
 293 
    {\
294 
	c_class *x443_ = GEN_c_class ( 9, TYPEID_nspace ) ;\
 294 
	c_class *x443_ = GEN_c_class(9, TYPEID_nspace);\
295 
	x443_->ag_tag = 3 ;\
 295 
	x443_->ag_tag = 3;\
296 
	COPY_id ( x443_ + 1, ( name_ ) ) ;\
 296 
	COPY_id(x443_ + 1, (name_));\
297 
	COPY_member ( x443_ + 2, NULL_member ) ;\
 297 
	COPY_member(x443_ + 2, NULL_member);\
298 
	COPY_member ( x443_ + 3, NULL_member ) ;\
 298 
	COPY_member(x443_ + 3, NULL_member);\
299 
	COPY_nspace ( x443_ + 4, ( parent_ ) ) ;\
 299 
	COPY_nspace(x443_ + 4, (parent_));\
300 
	COPY_list ( x443_ + 5, NULL_list ( NAMESPACE ) ) ;\
 300 
	COPY_list(x443_ + 5, NULL_list ( NAMESPACE ));\
301 
	COPY_list ( x443_ + 6, NULL_list ( NAMESPACE ) ) ;\
 301 
	COPY_list(x443_ + 6, NULL_list ( NAMESPACE ));\
302 
	COPY_stack ( x443_ + 7, NULL_stack ( IDENTIFIER ) ) ;\
 302 
	COPY_stack(x443_ + 7, NULL_stack ( IDENTIFIER ));\
303 
	COPY_ulong ( x443_ + 8, LINK_NONE ) ;\
 303 
	COPY_ulong(x443_ + 8, LINK_NONE);\
304 
	( c_class_nspace ) = x443_ ;\
 304 
	(c_class_nspace) = x443_;\
305 
    }
 305 
    }
306 
 
 306 
 
307 
#define DECONS_nspace_label( name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 307 
#define DECONS_nspace_label(name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
308 
    {\
 308 
    {\
309 
	c_class *x444_ = CHECK_TAG ( ( c_class_nspace ), 3 ) ;\
 309 
	c_class *x444_ = CHECK_TAG((c_class_nspace), 3);\
310 
	( name_ ) = DEREF_id ( x444_ + 1 ) ;\
 310 
	(name_) = DEREF_id(x444_ + 1);\
311 
	( last_ ) = DEREF_member ( x444_ + 2 ) ;\
 311 
	(last_) = DEREF_member(x444_ + 2);\
312 
	( prev_ ) = DEREF_member ( x444_ + 3 ) ;\
 312 
	(prev_) = DEREF_member(x444_ + 3);\
313 
	( parent_ ) = DEREF_nspace ( x444_ + 4 ) ;\
 313 
	(parent_) = DEREF_nspace(x444_ + 4);\
314 
	( use_ ) = DEREF_list ( x444_ + 5 ) ;\
 314 
	(use_) = DEREF_list(x444_ + 5);\
315 
	( join_ ) = DEREF_list ( x444_ + 6 ) ;\
 315 
	(join_) = DEREF_list(x444_ + 6);\
316 
	( set_ ) = DEREF_stack ( x444_ + 7 ) ;\
 316 
	(set_) = DEREF_stack(x444_ + 7);\
317 
	( dump_ ) = DEREF_ulong ( x444_ + 8 ) ;\
 317 
	(dump_) = DEREF_ulong(x444_ + 8);\
318 
    }
 318 
    }
319 
 
 319 
 
320 
#define DESTROY_nspace_label( destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 320 
#define DESTROY_nspace_label(destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
321 
    {\
 321 
    {\
322 
	c_class *x445_ = CHECK_TAG ( ( c_class_nspace ), 3 ) ;\
 322 
	c_class *x445_ = CHECK_TAG((c_class_nspace), 3);\
323 
	( name_ ) = DEREF_id ( x445_ + 1 ) ;\
 323 
	(name_) = DEREF_id(x445_ + 1);\
324 
	( last_ ) = DEREF_member ( x445_ + 2 ) ;\
 324 
	(last_) = DEREF_member(x445_ + 2);\
325 
	( prev_ ) = DEREF_member ( x445_ + 3 ) ;\
 325 
	(prev_) = DEREF_member(x445_ + 3);\
326 
	( parent_ ) = DEREF_nspace ( x445_ + 4 ) ;\
 326 
	(parent_) = DEREF_nspace(x445_ + 4);\
327 
	( use_ ) = DEREF_list ( x445_ + 5 ) ;\
 327 
	(use_) = DEREF_list(x445_ + 5);\
328 
	( join_ ) = DEREF_list ( x445_ + 6 ) ;\
 328 
	(join_) = DEREF_list(x445_ + 6);\
329 
	( set_ ) = DEREF_stack ( x445_ + 7 ) ;\
 329 
	(set_) = DEREF_stack(x445_ + 7);\
330 
	( dump_ ) = DEREF_ulong ( x445_ + 8 ) ;\
 330 
	(dump_) = DEREF_ulong(x445_ + 8);\
331 
	( destroyer_ ) ( x445_, ( unsigned ) 9 ) ;\
 331 
	(destroyer_)(x445_, (unsigned)9);\
332 
    }
 332 
    }
333 
 
 333 
 
334 
 
 334 
 
335 
/* Operations for field templ of union NAMESPACE */
 335 
/* Operations for field templ of union NAMESPACE */
336 
 
 336 
 
337 
#define nspace_templ_tag		( ( unsigned ) 4 )
 337 
#define nspace_templ_tag		((unsigned)4)
338 
#define IS_nspace_templ( P )		( CHECK_NULL ( P )->ag_tag == 4 )
 338 
#define IS_nspace_templ(P)		(CHECK_NULL(P)->ag_tag == 4)
339 
 
 339 
 
340 
 
 340 
 
341 
#define MAKE_nspace_templ( name_, parent_, c_class_nspace )\
 341 
#define MAKE_nspace_templ(name_, parent_, c_class_nspace)\
342 
    {\
 342 
    {\
343 
	c_class *x446_ = GEN_c_class ( 9, TYPEID_nspace ) ;\
 343 
	c_class *x446_ = GEN_c_class(9, TYPEID_nspace);\
344 
	x446_->ag_tag = 4 ;\
 344 
	x446_->ag_tag = 4;\
345 
	COPY_id ( x446_ + 1, ( name_ ) ) ;\
 345 
	COPY_id(x446_ + 1, (name_));\
346 
	COPY_member ( x446_ + 2, NULL_member ) ;\
 346 
	COPY_member(x446_ + 2, NULL_member);\
347 
	COPY_member ( x446_ + 3, NULL_member ) ;\
 347 
	COPY_member(x446_ + 3, NULL_member);\
348 
	COPY_nspace ( x446_ + 4, ( parent_ ) ) ;\
 348 
	COPY_nspace(x446_ + 4, (parent_));\
349 
	COPY_list ( x446_ + 5, NULL_list ( NAMESPACE ) ) ;\
 349 
	COPY_list(x446_ + 5, NULL_list ( NAMESPACE ));\
350 
	COPY_list ( x446_ + 6, NULL_list ( NAMESPACE ) ) ;\
 350 
	COPY_list(x446_ + 6, NULL_list ( NAMESPACE ));\
351 
	COPY_stack ( x446_ + 7, NULL_stack ( IDENTIFIER ) ) ;\
 351 
	COPY_stack(x446_ + 7, NULL_stack ( IDENTIFIER ));\
352 
	COPY_ulong ( x446_ + 8, LINK_NONE ) ;\
 352 
	COPY_ulong(x446_ + 8, LINK_NONE);\
353 
	( c_class_nspace ) = x446_ ;\
 353 
	(c_class_nspace) = x446_;\
354 
    }
 354 
    }
355 
 
 355 
 
356 
#define DECONS_nspace_templ( name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 356 
#define DECONS_nspace_templ(name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
357 
    {\
 357 
    {\
358 
	c_class *x447_ = CHECK_TAG ( ( c_class_nspace ), 4 ) ;\
 358 
	c_class *x447_ = CHECK_TAG((c_class_nspace), 4);\
359 
	( name_ ) = DEREF_id ( x447_ + 1 ) ;\
 359 
	(name_) = DEREF_id(x447_ + 1);\
360 
	( last_ ) = DEREF_member ( x447_ + 2 ) ;\
 360 
	(last_) = DEREF_member(x447_ + 2);\
361 
	( prev_ ) = DEREF_member ( x447_ + 3 ) ;\
 361 
	(prev_) = DEREF_member(x447_ + 3);\
362 
	( parent_ ) = DEREF_nspace ( x447_ + 4 ) ;\
 362 
	(parent_) = DEREF_nspace(x447_ + 4);\
363 
	( use_ ) = DEREF_list ( x447_ + 5 ) ;\
 363 
	(use_) = DEREF_list(x447_ + 5);\
364 
	( join_ ) = DEREF_list ( x447_ + 6 ) ;\
 364 
	(join_) = DEREF_list(x447_ + 6);\
365 
	( set_ ) = DEREF_stack ( x447_ + 7 ) ;\
 365 
	(set_) = DEREF_stack(x447_ + 7);\
366 
	( dump_ ) = DEREF_ulong ( x447_ + 8 ) ;\
 366 
	(dump_) = DEREF_ulong(x447_ + 8);\
367 
    }
 367 
    }
368 
 
 368 
 
369 
#define DESTROY_nspace_templ( destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace )\
 369 
#define DESTROY_nspace_templ(destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, c_class_nspace)\
370 
    {\
 370 
    {\
371 
	c_class *x448_ = CHECK_TAG ( ( c_class_nspace ), 4 ) ;\
 371 
	c_class *x448_ = CHECK_TAG((c_class_nspace), 4);\
372 
	( name_ ) = DEREF_id ( x448_ + 1 ) ;\
 372 
	(name_) = DEREF_id(x448_ + 1);\
373 
	( last_ ) = DEREF_member ( x448_ + 2 ) ;\
 373 
	(last_) = DEREF_member(x448_ + 2);\
374 
	( prev_ ) = DEREF_member ( x448_ + 3 ) ;\
 374 
	(prev_) = DEREF_member(x448_ + 3);\
375 
	( parent_ ) = DEREF_nspace ( x448_ + 4 ) ;\
 375 
	(parent_) = DEREF_nspace(x448_ + 4);\
376 
	( use_ ) = DEREF_list ( x448_ + 5 ) ;\
 376 
	(use_) = DEREF_list(x448_ + 5);\
377 
	( join_ ) = DEREF_list ( x448_ + 6 ) ;\
 377 
	(join_) = DEREF_list(x448_ + 6);\
378 
	( set_ ) = DEREF_stack ( x448_ + 7 ) ;\
 378 
	(set_) = DEREF_stack(x448_ + 7);\
379 
	( dump_ ) = DEREF_ulong ( x448_ + 8 ) ;\
 379 
	(dump_) = DEREF_ulong(x448_ + 8);\
380 
	( destroyer_ ) ( x448_, ( unsigned ) 9 ) ;\
 380 
	(destroyer_)(x448_, (unsigned)9);\
381 
    }
 381 
    }
382 
 
 382 
 
383 
 
 383 
 
384 
/* Operations for field set named_etc of union NAMESPACE */
 384 
/* Operations for field set named_etc of union NAMESPACE */
385 
 
 385 
 
386 
#define nspace_named_etc_tag		( ( unsigned ) 9 )
 386 
#define nspace_named_etc_tag		((unsigned)9)
387 
#define IS_nspace_named_etc( P )	( ( unsigned ) ( CHECK_NULL ( P )->ag_tag - 5 ) < ( unsigned ) 4 )
 387 
#define IS_nspace_named_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 5) < (unsigned)4)
388 
 
 388 
 
389 
#define nspace_named_etc_first( P )	( CHECK_TAG_ETC ( ( P ), 5, 9 ) + 9 )
 389 
#define nspace_named_etc_first(P)	(CHECK_TAG_ETC((P), 5, 9) + 9)
390 
#define nspace_named_etc_extra( P )	( CHECK_TAG_ETC ( ( P ), 5, 9 ) + 10 )
 390 
#define nspace_named_etc_extra(P)	(CHECK_TAG_ETC((P), 5, 9) + 10)
391 
#define nspace_named_etc_size( P )	( CHECK_TAG_ETC ( ( P ), 5, 9 ) + 11 )
 391 
#define nspace_named_etc_size(P)	(CHECK_TAG_ETC((P), 5, 9) + 11)
392 
#define nspace_named_etc_table( P )	( CHECK_TAG_ETC ( ( P ), 5, 9 ) + 12 )
 392 
#define nspace_named_etc_table(P)	(CHECK_TAG_ETC((P), 5, 9) + 12)
393 
 
 393 
 
394 
#define MAKE_nspace_named_etc( tag, name_, parent_, size_, table_, c_class_nspace )\
 394 
#define MAKE_nspace_named_etc(tag, name_, parent_, size_, table_, c_class_nspace)\
395 
    {\
 395 
    {\
396 
	c_class *x449_ = GEN_c_class ( 13, TYPEID_nspace ) ;\
 396 
	c_class *x449_ = GEN_c_class(13, TYPEID_nspace);\
397 
	x449_->ag_tag = ( tag ) ;\
 397 
	x449_->ag_tag = (tag);\
398 
	COPY_id ( x449_ + 1, ( name_ ) ) ;\
 398 
	COPY_id(x449_ + 1, (name_));\
399 
	COPY_member ( x449_ + 2, NULL_member ) ;\
 399 
	COPY_member(x449_ + 2, NULL_member);\
400 
	COPY_member ( x449_ + 3, NULL_member ) ;\
 400 
	COPY_member(x449_ + 3, NULL_member);\
401 
	COPY_nspace ( x449_ + 4, ( parent_ ) ) ;\
 401 
	COPY_nspace(x449_ + 4, (parent_));\
402 
	COPY_list ( x449_ + 5, NULL_list ( NAMESPACE ) ) ;\
 402 
	COPY_list(x449_ + 5, NULL_list ( NAMESPACE ));\
403 
	COPY_list ( x449_ + 6, NULL_list ( NAMESPACE ) ) ;\
 403 
	COPY_list(x449_ + 6, NULL_list ( NAMESPACE ));\
404 
	COPY_stack ( x449_ + 7, NULL_stack ( IDENTIFIER ) ) ;\
 404 
	COPY_stack(x449_ + 7, NULL_stack ( IDENTIFIER ));\
405 
	COPY_ulong ( x449_ + 8, LINK_NONE ) ;\
 405 
	COPY_ulong(x449_ + 8, LINK_NONE);\
406 
	COPY_member ( x449_ + 9, NULL_member ) ;\
 406 
	COPY_member(x449_ + 9, NULL_member);\
407 
	COPY_list ( x449_ + 10, NULL_list ( IDENTIFIER ) ) ;\
 407 
	COPY_list(x449_ + 10, NULL_list ( IDENTIFIER ));\
408 
	COPY_ulong ( x449_ + 11, ( size_ ) ) ;\
 408 
	COPY_ulong(x449_ + 11, (size_));\
409 
	COPY_ptr ( x449_ + 12, ( table_ ) ) ;\
 409 
	COPY_ptr(x449_ + 12, (table_));\
410 
	( c_class_nspace ) = CHECK_TAG_ETC ( x449_, 5, 9 ) ;\
 410 
	(c_class_nspace) = CHECK_TAG_ETC(x449_, 5, 9);\
411 
    }
 411 
    }
412 
 
 412 
 
413 
#define MODIFY_nspace_named_etc( tag, c_class_nspace )\
 413 
#define MODIFY_nspace_named_etc(tag, c_class_nspace)\
414 
    {\
 414 
    {\
415 
	c_class *x450_ = CHECK_TAG_ETC ( ( c_class_nspace ), 5, 9 ) ;\
 415 
	c_class *x450_ = CHECK_TAG_ETC ((c_class_nspace), 5, 9);\
416 
	x450_->ag_tag = ( tag ) ;\
 416 
	x450_->ag_tag = (tag);\
417 
	( void ) CHECK_TAG_ETC ( x450_, 5, 9 ) ;\
 417 
	(void) CHECK_TAG_ETC (x450_, 5, 9);\
418 
    }
 418 
    }
419 
 
 419 
 
420 
#define DECONS_nspace_named_etc( name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace )\
 420 
#define DECONS_nspace_named_etc(name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace)\
421 
    {\
 421 
    {\
422 
	c_class *x451_ = CHECK_TAG_ETC ( ( c_class_nspace ), 5, 9 ) ;\
 422 
	c_class *x451_ = CHECK_TAG_ETC((c_class_nspace), 5, 9);\
423 
	( name_ ) = DEREF_id ( x451_ + 1 ) ;\
 423 
	(name_) = DEREF_id(x451_ + 1);\
424 
	( last_ ) = DEREF_member ( x451_ + 2 ) ;\
 424 
	(last_) = DEREF_member(x451_ + 2);\
425 
	( prev_ ) = DEREF_member ( x451_ + 3 ) ;\
 425 
	(prev_) = DEREF_member(x451_ + 3);\
426 
	( parent_ ) = DEREF_nspace ( x451_ + 4 ) ;\
 426 
	(parent_) = DEREF_nspace(x451_ + 4);\
427 
	( use_ ) = DEREF_list ( x451_ + 5 ) ;\
 427 
	(use_) = DEREF_list(x451_ + 5);\
428 
	( join_ ) = DEREF_list ( x451_ + 6 ) ;\
 428 
	(join_) = DEREF_list(x451_ + 6);\
429 
	( set_ ) = DEREF_stack ( x451_ + 7 ) ;\
 429 
	(set_) = DEREF_stack(x451_ + 7);\
430 
	( dump_ ) = DEREF_ulong ( x451_ + 8 ) ;\
 430 
	(dump_) = DEREF_ulong(x451_ + 8);\
431 
	( first_ ) = DEREF_member ( x451_ + 9 ) ;\
 431 
	(first_) = DEREF_member(x451_ + 9);\
432 
	( extra_ ) = DEREF_list ( x451_ + 10 ) ;\
 432 
	(extra_) = DEREF_list(x451_ + 10);\
433 
	( size_ ) = DEREF_ulong ( x451_ + 11 ) ;\
 433 
	(size_) = DEREF_ulong(x451_ + 11);\
434 
	( table_ ) = DEREF_ptr ( x451_ + 12 ) ;\
 434 
	(table_) = DEREF_ptr(x451_ + 12);\
435 
    }
 435 
    }
436 
 
 436 
 
437 
#define DESTROY_nspace_named_etc( destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace )\
 437 
#define DESTROY_nspace_named_etc(destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace)\
438 
    {\
 438 
    {\
439 
	c_class *x452_ = CHECK_TAG_ETC ( ( c_class_nspace ), 5, 9 ) ;\
 439 
	c_class *x452_ = CHECK_TAG_ETC((c_class_nspace), 5, 9);\
440 
	( name_ ) = DEREF_id ( x452_ + 1 ) ;\
 440 
	(name_) = DEREF_id(x452_ + 1);\
441 
	( last_ ) = DEREF_member ( x452_ + 2 ) ;\
 441 
	(last_) = DEREF_member(x452_ + 2);\
442 
	( prev_ ) = DEREF_member ( x452_ + 3 ) ;\
 442 
	(prev_) = DEREF_member(x452_ + 3);\
443 
	( parent_ ) = DEREF_nspace ( x452_ + 4 ) ;\
 443 
	(parent_) = DEREF_nspace(x452_ + 4);\
444 
	( use_ ) = DEREF_list ( x452_ + 5 ) ;\
 444 
	(use_) = DEREF_list(x452_ + 5);\
445 
	( join_ ) = DEREF_list ( x452_ + 6 ) ;\
 445 
	(join_) = DEREF_list(x452_ + 6);\
446 
	( set_ ) = DEREF_stack ( x452_ + 7 ) ;\
 446 
	(set_) = DEREF_stack(x452_ + 7);\
447 
	( dump_ ) = DEREF_ulong ( x452_ + 8 ) ;\
 447 
	(dump_) = DEREF_ulong(x452_ + 8);\
448 
	( first_ ) = DEREF_member ( x452_ + 9 ) ;\
 448 
	(first_) = DEREF_member(x452_ + 9);\
449 
	( extra_ ) = DEREF_list ( x452_ + 10 ) ;\
 449 
	(extra_) = DEREF_list(x452_ + 10);\
450 
	( size_ ) = DEREF_ulong ( x452_ + 11 ) ;\
 450 
	(size_) = DEREF_ulong(x452_ + 11);\
451 
	( table_ ) = DEREF_ptr ( x452_ + 12 ) ;\
 451 
	(table_) = DEREF_ptr(x452_ + 12);\
452 
	( destroyer_ ) ( x452_, ( unsigned ) 13 ) ;\
 452 
	(destroyer_)(x452_, (unsigned)13);\
453 
    }
 453 
    }
454 
 
 454 
 
455 
 
 455 
 
456 
/* Operations for field named of union NAMESPACE */
 456 
/* Operations for field named of union NAMESPACE */
457 
 
 457 
 
458 
#define nspace_named_tag		( ( unsigned ) 5 )
 458 
#define nspace_named_tag		((unsigned)5)
459 
#define IS_nspace_named( P )		( CHECK_NULL ( P )->ag_tag == 5 )
 459 
#define IS_nspace_named(P)		(CHECK_NULL(P)->ag_tag == 5)
460 
 
 460 
 
461 
#define nspace_named_first( P )		( CHECK_TAG ( ( P ), 5 ) + 9 )
 461 
#define nspace_named_first(P)		(CHECK_TAG((P), 5) + 9)
462 
#define nspace_named_extra( P )		( CHECK_TAG ( ( P ), 5 ) + 10 )
 462 
#define nspace_named_extra(P)		(CHECK_TAG((P), 5) + 10)
463 
#define nspace_named_size( P )		( CHECK_TAG ( ( P ), 5 ) + 11 )
 463 
#define nspace_named_size(P)		(CHECK_TAG((P), 5) + 11)
464 
#define nspace_named_table( P )		( CHECK_TAG ( ( P ), 5 ) + 12 )
 464 
#define nspace_named_table(P)		(CHECK_TAG((P), 5) + 12)
465 
 
 465 
 
466 
#define MAKE_nspace_named( name_, parent_, size_, table_, c_class_nspace )\
 466 
#define MAKE_nspace_named(name_, parent_, size_, table_, c_class_nspace)\
467 
    {\
 467 
    {\
468 
	c_class *x453_ = GEN_c_class ( 13, TYPEID_nspace ) ;\
 468 
	c_class *x453_ = GEN_c_class(13, TYPEID_nspace);\
469 
	x453_->ag_tag = 5 ;\
 469 
	x453_->ag_tag = 5;\
470 
	COPY_id ( x453_ + 1, ( name_ ) ) ;\
 470 
	COPY_id(x453_ + 1, (name_));\
471 
	COPY_member ( x453_ + 2, NULL_member ) ;\
 471 
	COPY_member(x453_ + 2, NULL_member);\
472 
	COPY_member ( x453_ + 3, NULL_member ) ;\
 472 
	COPY_member(x453_ + 3, NULL_member);\
473 
	COPY_nspace ( x453_ + 4, ( parent_ ) ) ;\
 473 
	COPY_nspace(x453_ + 4, (parent_));\
474 
	COPY_list ( x453_ + 5, NULL_list ( NAMESPACE ) ) ;\
 474 
	COPY_list(x453_ + 5, NULL_list ( NAMESPACE ));\
475 
	COPY_list ( x453_ + 6, NULL_list ( NAMESPACE ) ) ;\
 475 
	COPY_list(x453_ + 6, NULL_list ( NAMESPACE ));\
476 
	COPY_stack ( x453_ + 7, NULL_stack ( IDENTIFIER ) ) ;\
 476 
	COPY_stack(x453_ + 7, NULL_stack ( IDENTIFIER ));\
477 
	COPY_ulong ( x453_ + 8, LINK_NONE ) ;\
 477 
	COPY_ulong(x453_ + 8, LINK_NONE);\
478 
	COPY_member ( x453_ + 9, NULL_member ) ;\
 478 
	COPY_member(x453_ + 9, NULL_member);\
479 
	COPY_list ( x453_ + 10, NULL_list ( IDENTIFIER ) ) ;\
 479 
	COPY_list(x453_ + 10, NULL_list ( IDENTIFIER ));\
480 
	COPY_ulong ( x453_ + 11, ( size_ ) ) ;\
 480 
	COPY_ulong(x453_ + 11, (size_));\
481 
	COPY_ptr ( x453_ + 12, ( table_ ) ) ;\
 481 
	COPY_ptr(x453_ + 12, (table_));\
482 
	( c_class_nspace ) = x453_ ;\
 482 
	(c_class_nspace) = x453_;\
483 
    }
 483 
    }
484 
 
 484 
 
485 
#define DECONS_nspace_named( name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace )\
 485 
#define DECONS_nspace_named(name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace)\
486 
    {\
 486 
    {\
487 
	c_class *x454_ = CHECK_TAG ( ( c_class_nspace ), 5 ) ;\
 487 
	c_class *x454_ = CHECK_TAG((c_class_nspace), 5);\
488 
	( name_ ) = DEREF_id ( x454_ + 1 ) ;\
 488 
	(name_) = DEREF_id(x454_ + 1);\
489 
	( last_ ) = DEREF_member ( x454_ + 2 ) ;\
 489 
	(last_) = DEREF_member(x454_ + 2);\
490 
	( prev_ ) = DEREF_member ( x454_ + 3 ) ;\
 490 
	(prev_) = DEREF_member(x454_ + 3);\
491 
	( parent_ ) = DEREF_nspace ( x454_ + 4 ) ;\
 491 
	(parent_) = DEREF_nspace(x454_ + 4);\
492 
	( use_ ) = DEREF_list ( x454_ + 5 ) ;\
 492 
	(use_) = DEREF_list(x454_ + 5);\
493 
	( join_ ) = DEREF_list ( x454_ + 6 ) ;\
 493 
	(join_) = DEREF_list(x454_ + 6);\
494 
	( set_ ) = DEREF_stack ( x454_ + 7 ) ;\
 494 
	(set_) = DEREF_stack(x454_ + 7);\
495 
	( dump_ ) = DEREF_ulong ( x454_ + 8 ) ;\
 495 
	(dump_) = DEREF_ulong(x454_ + 8);\
496 
	( first_ ) = DEREF_member ( x454_ + 9 ) ;\
 496 
	(first_) = DEREF_member(x454_ + 9);\
497 
	( extra_ ) = DEREF_list ( x454_ + 10 ) ;\
 497 
	(extra_) = DEREF_list(x454_ + 10);\
498 
	( size_ ) = DEREF_ulong ( x454_ + 11 ) ;\
 498 
	(size_) = DEREF_ulong(x454_ + 11);\
499 
	( table_ ) = DEREF_ptr ( x454_ + 12 ) ;\
 499 
	(table_) = DEREF_ptr(x454_ + 12);\
500 
    }
 500 
    }
501 
 
 501 
 
502 
#define DESTROY_nspace_named( destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace )\
 502 
#define DESTROY_nspace_named(destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace)\
503 
    {\
 503 
    {\
504 
	c_class *x455_ = CHECK_TAG ( ( c_class_nspace ), 5 ) ;\
 504 
	c_class *x455_ = CHECK_TAG((c_class_nspace), 5);\
505 
	( name_ ) = DEREF_id ( x455_ + 1 ) ;\
 505 
	(name_) = DEREF_id(x455_ + 1);\
506 
	( last_ ) = DEREF_member ( x455_ + 2 ) ;\
 506 
	(last_) = DEREF_member(x455_ + 2);\
507 
	( prev_ ) = DEREF_member ( x455_ + 3 ) ;\
 507 
	(prev_) = DEREF_member(x455_ + 3);\
508 
	( parent_ ) = DEREF_nspace ( x455_ + 4 ) ;\
 508 
	(parent_) = DEREF_nspace(x455_ + 4);\
509 
	( use_ ) = DEREF_list ( x455_ + 5 ) ;\
 509 
	(use_) = DEREF_list(x455_ + 5);\
510 
	( join_ ) = DEREF_list ( x455_ + 6 ) ;\
 510 
	(join_) = DEREF_list(x455_ + 6);\
511 
	( set_ ) = DEREF_stack ( x455_ + 7 ) ;\
 511 
	(set_) = DEREF_stack(x455_ + 7);\
512 
	( dump_ ) = DEREF_ulong ( x455_ + 8 ) ;\
 512 
	(dump_) = DEREF_ulong(x455_ + 8);\
513 
	( first_ ) = DEREF_member ( x455_ + 9 ) ;\
 513 
	(first_) = DEREF_member(x455_ + 9);\
514 
	( extra_ ) = DEREF_list ( x455_ + 10 ) ;\
 514 
	(extra_) = DEREF_list(x455_ + 10);\
515 
	( size_ ) = DEREF_ulong ( x455_ + 11 ) ;\
 515 
	(size_) = DEREF_ulong(x455_ + 11);\
516 
	( table_ ) = DEREF_ptr ( x455_ + 12 ) ;\
 516 
	(table_) = DEREF_ptr(x455_ + 12);\
517 
	( destroyer_ ) ( x455_, ( unsigned ) 13 ) ;\
 517 
	(destroyer_)(x455_, (unsigned)13);\
518 
    }
 518 
    }
519 
 
 519 
 
520 
 
 520 
 
521 
/* Operations for field unnamed of union NAMESPACE */
 521 
/* Operations for field unnamed of union NAMESPACE */
522 
 
 522 
 
523 
#define nspace_unnamed_tag		( ( unsigned ) 6 )
 523 
#define nspace_unnamed_tag		((unsigned)6)
524 
#define IS_nspace_unnamed( P )		( CHECK_NULL ( P )->ag_tag == 6 )
 524 
#define IS_nspace_unnamed(P)		(CHECK_NULL(P)->ag_tag == 6)
525 
 
 525 
 
526 
#define nspace_unnamed_first( P )	( CHECK_TAG ( ( P ), 6 ) + 9 )
 526 
#define nspace_unnamed_first(P)		(CHECK_TAG((P), 6) + 9)
527 
#define nspace_unnamed_extra( P )	( CHECK_TAG ( ( P ), 6 ) + 10 )
 527 
#define nspace_unnamed_extra(P)		(CHECK_TAG((P), 6) + 10)
528 
#define nspace_unnamed_size( P )	( CHECK_TAG ( ( P ), 6 ) + 11 )
 528 
#define nspace_unnamed_size(P)		(CHECK_TAG((P), 6) + 11)
529 
#define nspace_unnamed_table( P )	( CHECK_TAG ( ( P ), 6 ) + 12 )
 529 
#define nspace_unnamed_table(P)		(CHECK_TAG((P), 6) + 12)
530 
 
 530 
 
531 
#define MAKE_nspace_unnamed( name_, parent_, size_, table_, c_class_nspace )\
 531 
#define MAKE_nspace_unnamed(name_, parent_, size_, table_, c_class_nspace)\
532 
    {\
 532 
    {\
533 
	c_class *x456_ = GEN_c_class ( 13, TYPEID_nspace ) ;\
 533 
	c_class *x456_ = GEN_c_class(13, TYPEID_nspace);\
534 
	x456_->ag_tag = 6 ;\
 534 
	x456_->ag_tag = 6;\
535 
	COPY_id ( x456_ + 1, ( name_ ) ) ;\
 535 
	COPY_id(x456_ + 1, (name_));\
536 
	COPY_member ( x456_ + 2, NULL_member ) ;\
 536 
	COPY_member(x456_ + 2, NULL_member);\
537 
	COPY_member ( x456_ + 3, NULL_member ) ;\
 537 
	COPY_member(x456_ + 3, NULL_member);\
538 
	COPY_nspace ( x456_ + 4, ( parent_ ) ) ;\
 538 
	COPY_nspace(x456_ + 4, (parent_));\
539 
	COPY_list ( x456_ + 5, NULL_list ( NAMESPACE ) ) ;\
 539 
	COPY_list(x456_ + 5, NULL_list ( NAMESPACE ));\
540 
	COPY_list ( x456_ + 6, NULL_list ( NAMESPACE ) ) ;\
 540 
	COPY_list(x456_ + 6, NULL_list ( NAMESPACE ));\
541 
	COPY_stack ( x456_ + 7, NULL_stack ( IDENTIFIER ) ) ;\
 541 
	COPY_stack(x456_ + 7, NULL_stack ( IDENTIFIER ));\
542 
	COPY_ulong ( x456_ + 8, LINK_NONE ) ;\
 542 
	COPY_ulong(x456_ + 8, LINK_NONE);\
543 
	COPY_member ( x456_ + 9, NULL_member ) ;\
 543 
	COPY_member(x456_ + 9, NULL_member);\
544 
	COPY_list ( x456_ + 10, NULL_list ( IDENTIFIER ) ) ;\
 544 
	COPY_list(x456_ + 10, NULL_list ( IDENTIFIER ));\
545 
	COPY_ulong ( x456_ + 11, ( size_ ) ) ;\
 545 
	COPY_ulong(x456_ + 11, (size_));\
546 
	COPY_ptr ( x456_ + 12, ( table_ ) ) ;\
 546 
	COPY_ptr(x456_ + 12, (table_));\
547 
	( c_class_nspace ) = x456_ ;\
 547 
	(c_class_nspace) = x456_;\
548 
    }
 548 
    }
549 
 
 549 
 
550 
#define DECONS_nspace_unnamed( name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace )\
 550 
#define DECONS_nspace_unnamed(name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace)\
551 
    {\
 551 
    {\
552 
	c_class *x457_ = CHECK_TAG ( ( c_class_nspace ), 6 ) ;\
 552 
	c_class *x457_ = CHECK_TAG((c_class_nspace), 6);\
553 
	( name_ ) = DEREF_id ( x457_ + 1 ) ;\
 553 
	(name_) = DEREF_id(x457_ + 1);\
554 
	( last_ ) = DEREF_member ( x457_ + 2 ) ;\
 554 
	(last_) = DEREF_member(x457_ + 2);\
555 
	( prev_ ) = DEREF_member ( x457_ + 3 ) ;\
 555 
	(prev_) = DEREF_member(x457_ + 3);\
556 
	( parent_ ) = DEREF_nspace ( x457_ + 4 ) ;\
 556 
	(parent_) = DEREF_nspace(x457_ + 4);\
557 
	( use_ ) = DEREF_list ( x457_ + 5 ) ;\
 557 
	(use_) = DEREF_list(x457_ + 5);\
558 
	( join_ ) = DEREF_list ( x457_ + 6 ) ;\
 558 
	(join_) = DEREF_list(x457_ + 6);\
559 
	( set_ ) = DEREF_stack ( x457_ + 7 ) ;\
 559 
	(set_) = DEREF_stack(x457_ + 7);\
560 
	( dump_ ) = DEREF_ulong ( x457_ + 8 ) ;\
 560 
	(dump_) = DEREF_ulong(x457_ + 8);\
561 
	( first_ ) = DEREF_member ( x457_ + 9 ) ;\
 561 
	(first_) = DEREF_member(x457_ + 9);\
562 
	( extra_ ) = DEREF_list ( x457_ + 10 ) ;\
 562 
	(extra_) = DEREF_list(x457_ + 10);\
563 
	( size_ ) = DEREF_ulong ( x457_ + 11 ) ;\
 563 
	(size_) = DEREF_ulong(x457_ + 11);\
564 
	( table_ ) = DEREF_ptr ( x457_ + 12 ) ;\
 564 
	(table_) = DEREF_ptr(x457_ + 12);\
565 
    }
 565 
    }
566 
 
 566 
 
567 
#define DESTROY_nspace_unnamed( destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace )\
 567 
#define DESTROY_nspace_unnamed(destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace)\
568 
    {\
 568 
    {\
569 
	c_class *x458_ = CHECK_TAG ( ( c_class_nspace ), 6 ) ;\
 569 
	c_class *x458_ = CHECK_TAG((c_class_nspace), 6);\
570 
	( name_ ) = DEREF_id ( x458_ + 1 ) ;\
 570 
	(name_) = DEREF_id(x458_ + 1);\
571 
	( last_ ) = DEREF_member ( x458_ + 2 ) ;\
 571 
	(last_) = DEREF_member(x458_ + 2);\
572 
	( prev_ ) = DEREF_member ( x458_ + 3 ) ;\
 572 
	(prev_) = DEREF_member(x458_ + 3);\
573 
	( parent_ ) = DEREF_nspace ( x458_ + 4 ) ;\
 573 
	(parent_) = DEREF_nspace(x458_ + 4);\
574 
	( use_ ) = DEREF_list ( x458_ + 5 ) ;\
 574 
	(use_) = DEREF_list(x458_ + 5);\
575 
	( join_ ) = DEREF_list ( x458_ + 6 ) ;\
 575 
	(join_) = DEREF_list(x458_ + 6);\
576 
	( set_ ) = DEREF_stack ( x458_ + 7 ) ;\
 576 
	(set_) = DEREF_stack(x458_ + 7);\
577 
	( dump_ ) = DEREF_ulong ( x458_ + 8 ) ;\
 577 
	(dump_) = DEREF_ulong(x458_ + 8);\
578 
	( first_ ) = DEREF_member ( x458_ + 9 ) ;\
 578 
	(first_) = DEREF_member(x458_ + 9);\
579 
	( extra_ ) = DEREF_list ( x458_ + 10 ) ;\
 579 
	(extra_) = DEREF_list(x458_ + 10);\
580 
	( size_ ) = DEREF_ulong ( x458_ + 11 ) ;\
 580 
	(size_) = DEREF_ulong(x458_ + 11);\
581 
	( table_ ) = DEREF_ptr ( x458_ + 12 ) ;\
 581 
	(table_) = DEREF_ptr(x458_ + 12);\
582 
	( destroyer_ ) ( x458_, ( unsigned ) 13 ) ;\
 582 
	(destroyer_)(x458_, (unsigned)13);\
583 
    }
 583 
    }
584 
 
 584 
 
585 
 
 585 
 
586 
/* Operations for field global of union NAMESPACE */
 586 
/* Operations for field global of union NAMESPACE */
587 
 
 587 
 
588 
#define nspace_global_tag		( ( unsigned ) 7 )
 588 
#define nspace_global_tag		((unsigned)7)
589 
#define IS_nspace_global( P )		( CHECK_NULL ( P )->ag_tag == 7 )
 589 
#define IS_nspace_global(P)		(CHECK_NULL(P)->ag_tag == 7)
590 
 
 590 
 
591 
#define nspace_global_first( P )	( CHECK_TAG ( ( P ), 7 ) + 9 )
 591 
#define nspace_global_first(P)		(CHECK_TAG((P), 7) + 9)
592 
#define nspace_global_extra( P )	( CHECK_TAG ( ( P ), 7 ) + 10 )
 592 
#define nspace_global_extra(P)		(CHECK_TAG((P), 7) + 10)
593 
#define nspace_global_size( P )		( CHECK_TAG ( ( P ), 7 ) + 11 )
 593 
#define nspace_global_size(P)		(CHECK_TAG((P), 7) + 11)
594 
#define nspace_global_table( P )	( CHECK_TAG ( ( P ), 7 ) + 12 )
 594 
#define nspace_global_table(P)		(CHECK_TAG((P), 7) + 12)
595 
 
 595 
 
596 
#define MAKE_nspace_global( name_, parent_, size_, table_, c_class_nspace )\
 596 
#define MAKE_nspace_global(name_, parent_, size_, table_, c_class_nspace)\
597 
    {\
 597 
    {\
598 
	c_class *x459_ = GEN_c_class ( 13, TYPEID_nspace ) ;\
 598 
	c_class *x459_ = GEN_c_class(13, TYPEID_nspace);\
599 
	x459_->ag_tag = 7 ;\
 599 
	x459_->ag_tag = 7;\
600 
	COPY_id ( x459_ + 1, ( name_ ) ) ;\
 600 
	COPY_id(x459_ + 1, (name_));\
601 
	COPY_member ( x459_ + 2, NULL_member ) ;\
 601 
	COPY_member(x459_ + 2, NULL_member);\
602 
	COPY_member ( x459_ + 3, NULL_member ) ;\
 602 
	COPY_member(x459_ + 3, NULL_member);\
603 
	COPY_nspace ( x459_ + 4, ( parent_ ) ) ;\
 603 
	COPY_nspace(x459_ + 4, (parent_));\
604 
	COPY_list ( x459_ + 5, NULL_list ( NAMESPACE ) ) ;\
 604 
	COPY_list(x459_ + 5, NULL_list ( NAMESPACE ));\
605 
	COPY_list ( x459_ + 6, NULL_list ( NAMESPACE ) ) ;\
 605 
	COPY_list(x459_ + 6, NULL_list ( NAMESPACE ));\
606 
	COPY_stack ( x459_ + 7, NULL_stack ( IDENTIFIER ) ) ;\
 606 
	COPY_stack(x459_ + 7, NULL_stack ( IDENTIFIER ));\
607 
	COPY_ulong ( x459_ + 8, LINK_NONE ) ;\
 607 
	COPY_ulong(x459_ + 8, LINK_NONE);\
608 
	COPY_member ( x459_ + 9, NULL_member ) ;\
 608 
	COPY_member(x459_ + 9, NULL_member);\
609 
	COPY_list ( x459_ + 10, NULL_list ( IDENTIFIER ) ) ;\
 609 
	COPY_list(x459_ + 10, NULL_list ( IDENTIFIER ));\
610 
	COPY_ulong ( x459_ + 11, ( size_ ) ) ;\
 610 
	COPY_ulong(x459_ + 11, (size_));\
611 
	COPY_ptr ( x459_ + 12, ( table_ ) ) ;\
 611 
	COPY_ptr(x459_ + 12, (table_));\
612 
	( c_class_nspace ) = x459_ ;\
 612 
	(c_class_nspace) = x459_;\
613 
    }
 613 
    }
614 
 
 614 
 
615 
#define DECONS_nspace_global( name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace )\
 615 
#define DECONS_nspace_global(name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace)\
616 
    {\
 616 
    {\
617 
	c_class *x460_ = CHECK_TAG ( ( c_class_nspace ), 7 ) ;\
 617 
	c_class *x460_ = CHECK_TAG((c_class_nspace), 7);\
618 
	( name_ ) = DEREF_id ( x460_ + 1 ) ;\
 618 
	(name_) = DEREF_id(x460_ + 1);\
619 
	( last_ ) = DEREF_member ( x460_ + 2 ) ;\
 619 
	(last_) = DEREF_member(x460_ + 2);\
620 
	( prev_ ) = DEREF_member ( x460_ + 3 ) ;\
 620 
	(prev_) = DEREF_member(x460_ + 3);\
621 
	( parent_ ) = DEREF_nspace ( x460_ + 4 ) ;\
 621 
	(parent_) = DEREF_nspace(x460_ + 4);\
622 
	( use_ ) = DEREF_list ( x460_ + 5 ) ;\
 622 
	(use_) = DEREF_list(x460_ + 5);\
623 
	( join_ ) = DEREF_list ( x460_ + 6 ) ;\
 623 
	(join_) = DEREF_list(x460_ + 6);\
624 
	( set_ ) = DEREF_stack ( x460_ + 7 ) ;\
 624 
	(set_) = DEREF_stack(x460_ + 7);\
625 
	( dump_ ) = DEREF_ulong ( x460_ + 8 ) ;\
 625 
	(dump_) = DEREF_ulong(x460_ + 8);\
626 
	( first_ ) = DEREF_member ( x460_ + 9 ) ;\
 626 
	(first_) = DEREF_member(x460_ + 9);\
627 
	( extra_ ) = DEREF_list ( x460_ + 10 ) ;\
 627 
	(extra_) = DEREF_list(x460_ + 10);\
628 
	( size_ ) = DEREF_ulong ( x460_ + 11 ) ;\
 628 
	(size_) = DEREF_ulong(x460_ + 11);\
629 
	( table_ ) = DEREF_ptr ( x460_ + 12 ) ;\
 629 
	(table_) = DEREF_ptr(x460_ + 12);\
630 
    }
 630 
    }
631 
 
 631 
 
632 
#define DESTROY_nspace_global( destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace )\
 632 
#define DESTROY_nspace_global(destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace)\
633 
    {\
 633 
    {\
634 
	c_class *x461_ = CHECK_TAG ( ( c_class_nspace ), 7 ) ;\
 634 
	c_class *x461_ = CHECK_TAG((c_class_nspace), 7);\
635 
	( name_ ) = DEREF_id ( x461_ + 1 ) ;\
 635 
	(name_) = DEREF_id(x461_ + 1);\
636 
	( last_ ) = DEREF_member ( x461_ + 2 ) ;\
 636 
	(last_) = DEREF_member(x461_ + 2);\
637 
	( prev_ ) = DEREF_member ( x461_ + 3 ) ;\
 637 
	(prev_) = DEREF_member(x461_ + 3);\
638 
	( parent_ ) = DEREF_nspace ( x461_ + 4 ) ;\
 638 
	(parent_) = DEREF_nspace(x461_ + 4);\
639 
	( use_ ) = DEREF_list ( x461_ + 5 ) ;\
 639 
	(use_) = DEREF_list(x461_ + 5);\
640 
	( join_ ) = DEREF_list ( x461_ + 6 ) ;\
 640 
	(join_) = DEREF_list(x461_ + 6);\
641 
	( set_ ) = DEREF_stack ( x461_ + 7 ) ;\
 641 
	(set_) = DEREF_stack(x461_ + 7);\
642 
	( dump_ ) = DEREF_ulong ( x461_ + 8 ) ;\
 642 
	(dump_) = DEREF_ulong(x461_ + 8);\
643 
	( first_ ) = DEREF_member ( x461_ + 9 ) ;\
 643 
	(first_) = DEREF_member(x461_ + 9);\
644 
	( extra_ ) = DEREF_list ( x461_ + 10 ) ;\
 644 
	(extra_) = DEREF_list(x461_ + 10);\
645 
	( size_ ) = DEREF_ulong ( x461_ + 11 ) ;\
 645 
	(size_) = DEREF_ulong(x461_ + 11);\
646 
	( table_ ) = DEREF_ptr ( x461_ + 12 ) ;\
 646 
	(table_) = DEREF_ptr(x461_ + 12);\
647 
	( destroyer_ ) ( x461_, ( unsigned ) 13 ) ;\
 647 
	(destroyer_)(x461_, (unsigned)13);\
648 
    }
 648 
    }
649 
 
 649 
 
650 
 
 650 
 
651 
/* Operations for field ctype of union NAMESPACE */
 651 
/* Operations for field ctype of union NAMESPACE */
652 
 
 652 
 
653 
#define nspace_ctype_tag		( ( unsigned ) 8 )
 653 
#define nspace_ctype_tag		((unsigned)8)
654 
#define IS_nspace_ctype( P )		( CHECK_NULL ( P )->ag_tag == 8 )
 654 
#define IS_nspace_ctype(P)		(CHECK_NULL(P)->ag_tag == 8)
655 
 
 655 
 
656 
#define nspace_ctype_first( P )		( CHECK_TAG ( ( P ), 8 ) + 9 )
 656 
#define nspace_ctype_first(P)		(CHECK_TAG((P), 8) + 9)
657 
#define nspace_ctype_extra( P )		( CHECK_TAG ( ( P ), 8 ) + 10 )
 657 
#define nspace_ctype_extra(P)		(CHECK_TAG((P), 8) + 10)
658 
#define nspace_ctype_size( P )		( CHECK_TAG ( ( P ), 8 ) + 11 )
 658 
#define nspace_ctype_size(P)		(CHECK_TAG((P), 8) + 11)
659 
#define nspace_ctype_table( P )		( CHECK_TAG ( ( P ), 8 ) + 12 )
 659 
#define nspace_ctype_table(P)		(CHECK_TAG((P), 8) + 12)
660 
 
 660 
 
661 
#define MAKE_nspace_ctype( name_, parent_, size_, table_, c_class_nspace )\
 661 
#define MAKE_nspace_ctype(name_, parent_, size_, table_, c_class_nspace)\
662 
    {\
 662 
    {\
663 
	c_class *x462_ = GEN_c_class ( 13, TYPEID_nspace ) ;\
 663 
	c_class *x462_ = GEN_c_class(13, TYPEID_nspace);\
664 
	x462_->ag_tag = 8 ;\
 664 
	x462_->ag_tag = 8;\
665 
	COPY_id ( x462_ + 1, ( name_ ) ) ;\
 665 
	COPY_id(x462_ + 1, (name_));\
666 
	COPY_member ( x462_ + 2, NULL_member ) ;\
 666 
	COPY_member(x462_ + 2, NULL_member);\
667 
	COPY_member ( x462_ + 3, NULL_member ) ;\
 667 
	COPY_member(x462_ + 3, NULL_member);\
668 
	COPY_nspace ( x462_ + 4, ( parent_ ) ) ;\
 668 
	COPY_nspace(x462_ + 4, (parent_));\
669 
	COPY_list ( x462_ + 5, NULL_list ( NAMESPACE ) ) ;\
 669 
	COPY_list(x462_ + 5, NULL_list ( NAMESPACE ));\
670 
	COPY_list ( x462_ + 6, NULL_list ( NAMESPACE ) ) ;\
 670 
	COPY_list(x462_ + 6, NULL_list ( NAMESPACE ));\
671 
	COPY_stack ( x462_ + 7, NULL_stack ( IDENTIFIER ) ) ;\
 671 
	COPY_stack(x462_ + 7, NULL_stack ( IDENTIFIER ));\
672 
	COPY_ulong ( x462_ + 8, LINK_NONE ) ;\
 672 
	COPY_ulong(x462_ + 8, LINK_NONE);\
673 
	COPY_member ( x462_ + 9, NULL_member ) ;\
 673 
	COPY_member(x462_ + 9, NULL_member);\
674 
	COPY_list ( x462_ + 10, NULL_list ( IDENTIFIER ) ) ;\
 674 
	COPY_list(x462_ + 10, NULL_list ( IDENTIFIER ));\
675 
	COPY_ulong ( x462_ + 11, ( size_ ) ) ;\
 675 
	COPY_ulong(x462_ + 11, (size_));\
676 
	COPY_ptr ( x462_ + 12, ( table_ ) ) ;\
 676 
	COPY_ptr(x462_ + 12, (table_));\
677 
	( c_class_nspace ) = x462_ ;\
 677 
	(c_class_nspace) = x462_;\
678 
    }
 678 
    }
679 
 
 679 
 
680 
#define DECONS_nspace_ctype( name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace )\
 680 
#define DECONS_nspace_ctype(name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace)\
681 
    {\
 681 
    {\
682 
	c_class *x463_ = CHECK_TAG ( ( c_class_nspace ), 8 ) ;\
 682 
	c_class *x463_ = CHECK_TAG((c_class_nspace), 8);\
683 
	( name_ ) = DEREF_id ( x463_ + 1 ) ;\
 683 
	(name_) = DEREF_id(x463_ + 1);\
684 
	( last_ ) = DEREF_member ( x463_ + 2 ) ;\
 684 
	(last_) = DEREF_member(x463_ + 2);\
685 
	( prev_ ) = DEREF_member ( x463_ + 3 ) ;\
 685 
	(prev_) = DEREF_member(x463_ + 3);\
686 
	( parent_ ) = DEREF_nspace ( x463_ + 4 ) ;\
 686 
	(parent_) = DEREF_nspace(x463_ + 4);\
687 
	( use_ ) = DEREF_list ( x463_ + 5 ) ;\
 687 
	(use_) = DEREF_list(x463_ + 5);\
688 
	( join_ ) = DEREF_list ( x463_ + 6 ) ;\
 688 
	(join_) = DEREF_list(x463_ + 6);\
689 
	( set_ ) = DEREF_stack ( x463_ + 7 ) ;\
 689 
	(set_) = DEREF_stack(x463_ + 7);\
690 
	( dump_ ) = DEREF_ulong ( x463_ + 8 ) ;\
 690 
	(dump_) = DEREF_ulong(x463_ + 8);\
691 
	( first_ ) = DEREF_member ( x463_ + 9 ) ;\
 691 
	(first_) = DEREF_member(x463_ + 9);\
692 
	( extra_ ) = DEREF_list ( x463_ + 10 ) ;\
 692 
	(extra_) = DEREF_list(x463_ + 10);\
693 
	( size_ ) = DEREF_ulong ( x463_ + 11 ) ;\
 693 
	(size_) = DEREF_ulong(x463_ + 11);\
694 
	( table_ ) = DEREF_ptr ( x463_ + 12 ) ;\
 694 
	(table_) = DEREF_ptr(x463_ + 12);\
695 
    }
 695 
    }
696 
 
 696 
 
697 
#define DESTROY_nspace_ctype( destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace )\
 697 
#define DESTROY_nspace_ctype(destroyer_, name_, last_, prev_, parent_, use_, join_, set_, dump_, first_, extra_, size_, table_, c_class_nspace)\
698 
    {\
 698 
    {\
699 
	c_class *x464_ = CHECK_TAG ( ( c_class_nspace ), 8 ) ;\
 699 
	c_class *x464_ = CHECK_TAG((c_class_nspace), 8);\
700 
	( name_ ) = DEREF_id ( x464_ + 1 ) ;\
 700 
	(name_) = DEREF_id(x464_ + 1);\
701 
	( last_ ) = DEREF_member ( x464_ + 2 ) ;\
 701 
	(last_) = DEREF_member(x464_ + 2);\
702 
	( prev_ ) = DEREF_member ( x464_ + 3 ) ;\
 702 
	(prev_) = DEREF_member(x464_ + 3);\
703 
	( parent_ ) = DEREF_nspace ( x464_ + 4 ) ;\
 703 
	(parent_) = DEREF_nspace(x464_ + 4);\
704 
	( use_ ) = DEREF_list ( x464_ + 5 ) ;\
 704 
	(use_) = DEREF_list(x464_ + 5);\
705 
	( join_ ) = DEREF_list ( x464_ + 6 ) ;\
 705 
	(join_) = DEREF_list(x464_ + 6);\
706 
	( set_ ) = DEREF_stack ( x464_ + 7 ) ;\
 706 
	(set_) = DEREF_stack(x464_ + 7);\
707 
	( dump_ ) = DEREF_ulong ( x464_ + 8 ) ;\
 707 
	(dump_) = DEREF_ulong(x464_ + 8);\
708 
	( first_ ) = DEREF_member ( x464_ + 9 ) ;\
 708 
	(first_) = DEREF_member(x464_ + 9);\
709 
	( extra_ ) = DEREF_list ( x464_ + 10 ) ;\
 709 
	(extra_) = DEREF_list(x464_ + 10);\
710 
	( size_ ) = DEREF_ulong ( x464_ + 11 ) ;\
 710 
	(size_) = DEREF_ulong(x464_ + 11);\
711 
	( table_ ) = DEREF_ptr ( x464_ + 12 ) ;\
 711 
	(table_) = DEREF_ptr(x464_ + 12);\
712 
	( destroyer_ ) ( x464_, ( unsigned ) 13 ) ;\
 712 
	(destroyer_)(x464_, (unsigned)13);\
713 
    }
 713 
    }
714 
 
 714 
 
715 
 
 715 
 
716 
#endif
 716 
#endif