Subversion Repositories tendra.SVN

Rev

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

Rev 2 Rev 7
Line 35... Line 35...
35 
#ifndef HASHID_OPS_H_INCLUDED
 35 
#ifndef HASHID_OPS_H_INCLUDED
36 
#define HASHID_OPS_H_INCLUDED
 36 
#define HASHID_OPS_H_INCLUDED
37 
 
 37 
 
38 
/* Operations for union HASHID */
 38 
/* Operations for union HASHID */
39 
 
 39 
 
40 
#define TAG_hashid( P )			( CHECK_NULL ( P )->ag_tag )
 40 
#define TAG_hashid(P)			(CHECK_NULL(P)->ag_tag)
41 
 
 41 
 
42 
 
 42 
 
43 
/* Operations for component id of union HASHID */
 43 
/* Operations for component id of union HASHID */
44 
 
 44 
 
45 
#define hashid_id( P )			( CHECK_NULL ( P ) + 1 )
 45 
#define hashid_id(P)			(CHECK_NULL(P) + 1)
46 
 
 46 
 
47 
 
 47 
 
48 
/* Operations for component cache of union HASHID */
 48 
/* Operations for component cache of union HASHID */
49 
 
 49 
 
50 
#define hashid_cache( P )		( CHECK_NULL ( P ) + 2 )
 50 
#define hashid_cache(P)			(CHECK_NULL(P) + 2)
51 
 
 51 
 
52 
 
 52 
 
53 
/* Operations for component next of union HASHID */
 53 
/* Operations for component next of union HASHID */
54 
 
 54 
 
55 
#define hashid_next( P )		( CHECK_NULL ( P ) + 3 )
 55 
#define hashid_next(P)			(CHECK_NULL(P) + 3)
56 
 
 56 
 
57 
 
 57 
 
58 
/* Operations for component hash of union HASHID */
 58 
/* Operations for component hash of union HASHID */
59 
 
 59 
 
60 
#define hashid_hash( P )		( CHECK_NULL ( P ) + 4 )
 60 
#define hashid_hash(P)			(CHECK_NULL(P) + 4)
61 
 
 61 
 
62 
 
 62 
 
63 
/* Operations for field set name_etc of union HASHID */
 63 
/* Operations for field set name_etc of union HASHID */
64 
 
 64 
 
65 
#define hashid_name_etc_tag		( ( unsigned ) 2 )
 65 
#define hashid_name_etc_tag		((unsigned)2)
66 
#define IS_hashid_name_etc( P )		( ( unsigned ) ( CHECK_NULL ( P )->ag_tag - 0 ) < ( unsigned ) 2 )
 66 
#define IS_hashid_name_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 0) < (unsigned)2)
67 
 
 67 
 
68 
#define hashid_name_etc_text( P )	( CHECK_TAG_ETC ( ( P ), 0, 2 ) + 5 )
 68 
#define hashid_name_etc_text(P)		(CHECK_TAG_ETC((P), 0, 2) + 5)
69 
 
 69 
 
70 
#define MAKE_hashid_name_etc( tag, next_, hash_, text_, c_class_hashid )\
 70 
#define MAKE_hashid_name_etc(tag, next_, hash_, text_, c_class_hashid)\
71 
    {\
 71 
    {\
72 
	c_class *x288_ = GEN_c_class ( 6, TYPEID_hashid ) ;\
 72 
	c_class *x288_ = GEN_c_class(6, TYPEID_hashid);\
73 
	x288_->ag_tag = ( tag ) ;\
 73 
	x288_->ag_tag = (tag);\
74 
	COPY_id ( x288_ + 1, NULL_id ) ;\
 74 
	COPY_id(x288_ + 1, NULL_id);\
75 
	COPY_id ( x288_ + 2, NULL_id ) ;\
 75 
	COPY_id(x288_ + 2, NULL_id);\
76 
	COPY_hashid ( x288_ + 3, ( next_ ) ) ;\
 76 
	COPY_hashid(x288_ + 3, (next_));\
77 
	COPY_ulong ( x288_ + 4, ( hash_ ) ) ;\
 77 
	COPY_ulong(x288_ + 4, (hash_));\
78 
	COPY_string ( x288_ + 5, ( text_ ) ) ;\
 78 
	COPY_string(x288_ + 5, (text_));\
79 
	( c_class_hashid ) = CHECK_TAG_ETC ( x288_, 0, 2 ) ;\
 79 
	(c_class_hashid) = CHECK_TAG_ETC(x288_, 0, 2);\
80 
    }
 80 
    }
81 
 
 81 
 
82 
#define MODIFY_hashid_name_etc( tag, c_class_hashid )\
 82 
#define MODIFY_hashid_name_etc(tag, c_class_hashid)\
83 
    {\
 83 
    {\
84 
	c_class *x289_ = CHECK_TAG_ETC ( ( c_class_hashid ), 0, 2 ) ;\
 84 
	c_class *x289_ = CHECK_TAG_ETC ((c_class_hashid), 0, 2);\
85 
	x289_->ag_tag = ( tag ) ;\
 85 
	x289_->ag_tag = (tag);\
86 
	( void ) CHECK_TAG_ETC ( x289_, 0, 2 ) ;\
 86 
	(void) CHECK_TAG_ETC (x289_, 0, 2);\
87 
    }
 87 
    }
88 
 
 88 
 
89 
#define DECONS_hashid_name_etc( id_, cache_, next_, hash_, text_, c_class_hashid )\
 89 
#define DECONS_hashid_name_etc(id_, cache_, next_, hash_, text_, c_class_hashid)\
90 
    {\
 90 
    {\
91 
	c_class *x290_ = CHECK_TAG_ETC ( ( c_class_hashid ), 0, 2 ) ;\
 91 
	c_class *x290_ = CHECK_TAG_ETC((c_class_hashid), 0, 2);\
92 
	( id_ ) = DEREF_id ( x290_ + 1 ) ;\
 92 
	(id_) = DEREF_id(x290_ + 1);\
93 
	( cache_ ) = DEREF_id ( x290_ + 2 ) ;\
 93 
	(cache_) = DEREF_id(x290_ + 2);\
94 
	( next_ ) = DEREF_hashid ( x290_ + 3 ) ;\
 94 
	(next_) = DEREF_hashid(x290_ + 3);\
95 
	( hash_ ) = DEREF_ulong ( x290_ + 4 ) ;\
 95 
	(hash_) = DEREF_ulong(x290_ + 4);\
96 
	( text_ ) = DEREF_string ( x290_ + 5 ) ;\
 96 
	(text_) = DEREF_string(x290_ + 5);\
97 
    }
 97 
    }
98 
 
 98 
 
99 
#define DESTROY_hashid_name_etc( destroyer_, id_, cache_, next_, hash_, text_, c_class_hashid )\
 99 
#define DESTROY_hashid_name_etc(destroyer_, id_, cache_, next_, hash_, text_, c_class_hashid)\
100 
    {\
 100 
    {\
101 
	c_class *x291_ = CHECK_TAG_ETC ( ( c_class_hashid ), 0, 2 ) ;\
 101 
	c_class *x291_ = CHECK_TAG_ETC((c_class_hashid), 0, 2);\
102 
	( id_ ) = DEREF_id ( x291_ + 1 ) ;\
 102 
	(id_) = DEREF_id(x291_ + 1);\
103 
	( cache_ ) = DEREF_id ( x291_ + 2 ) ;\
 103 
	(cache_) = DEREF_id(x291_ + 2);\
104 
	( next_ ) = DEREF_hashid ( x291_ + 3 ) ;\
 104 
	(next_) = DEREF_hashid(x291_ + 3);\
105 
	( hash_ ) = DEREF_ulong ( x291_ + 4 ) ;\
 105 
	(hash_) = DEREF_ulong(x291_ + 4);\
106 
	( text_ ) = DEREF_string ( x291_ + 5 ) ;\
 106 
	(text_) = DEREF_string(x291_ + 5);\
107 
	( destroyer_ ) ( x291_, ( unsigned ) 6 ) ;\
 107 
	(destroyer_)(x291_, (unsigned)6);\
108 
    }
 108 
    }
109 
 
 109 
 
110 
 
 110 
 
111 
/* Operations for field name of union HASHID */
 111 
/* Operations for field name of union HASHID */
112 
 
 112 
 
113 
#define hashid_name_tag			( ( unsigned ) 0 )
 113 
#define hashid_name_tag			((unsigned)0)
114 
#define IS_hashid_name( P )		( CHECK_NULL ( P )->ag_tag == 0 )
 114 
#define IS_hashid_name(P)		(CHECK_NULL(P)->ag_tag == 0)
115 
 
 115 
 
116 
#define hashid_name_text( P )		( CHECK_TAG ( ( P ), 0 ) + 5 )
 116 
#define hashid_name_text(P)		(CHECK_TAG((P), 0) + 5)
117 
 
 117 
 
118 
#define MAKE_hashid_name( next_, hash_, text_, c_class_hashid )\
 118 
#define MAKE_hashid_name(next_, hash_, text_, c_class_hashid)\
119 
    {\
 119 
    {\
120 
	c_class *x292_ = GEN_c_class ( 6, TYPEID_hashid ) ;\
 120 
	c_class *x292_ = GEN_c_class(6, TYPEID_hashid);\
121 
	x292_->ag_tag = 0 ;\
 121 
	x292_->ag_tag = 0;\
122 
	COPY_id ( x292_ + 1, NULL_id ) ;\
 122 
	COPY_id(x292_ + 1, NULL_id);\
123 
	COPY_id ( x292_ + 2, NULL_id ) ;\
 123 
	COPY_id(x292_ + 2, NULL_id);\
124 
	COPY_hashid ( x292_ + 3, ( next_ ) ) ;\
 124 
	COPY_hashid(x292_ + 3, (next_));\
125 
	COPY_ulong ( x292_ + 4, ( hash_ ) ) ;\
 125 
	COPY_ulong(x292_ + 4, (hash_));\
126 
	COPY_string ( x292_ + 5, ( text_ ) ) ;\
 126 
	COPY_string(x292_ + 5, (text_));\
127 
	( c_class_hashid ) = x292_ ;\
 127 
	(c_class_hashid) = x292_;\
128 
    }
 128 
    }
129 
 
 129 
 
130 
#define DECONS_hashid_name( id_, cache_, next_, hash_, text_, c_class_hashid )\
 130 
#define DECONS_hashid_name(id_, cache_, next_, hash_, text_, c_class_hashid)\
131 
    {\
 131 
    {\
132 
	c_class *x293_ = CHECK_TAG ( ( c_class_hashid ), 0 ) ;\
 132 
	c_class *x293_ = CHECK_TAG((c_class_hashid), 0);\
133 
	( id_ ) = DEREF_id ( x293_ + 1 ) ;\
 133 
	(id_) = DEREF_id(x293_ + 1);\
134 
	( cache_ ) = DEREF_id ( x293_ + 2 ) ;\
 134 
	(cache_) = DEREF_id(x293_ + 2);\
135 
	( next_ ) = DEREF_hashid ( x293_ + 3 ) ;\
 135 
	(next_) = DEREF_hashid(x293_ + 3);\
136 
	( hash_ ) = DEREF_ulong ( x293_ + 4 ) ;\
 136 
	(hash_) = DEREF_ulong(x293_ + 4);\
137 
	( text_ ) = DEREF_string ( x293_ + 5 ) ;\
 137 
	(text_) = DEREF_string(x293_ + 5);\
138 
    }
 138 
    }
139 
 
 139 
 
140 
#define DESTROY_hashid_name( destroyer_, id_, cache_, next_, hash_, text_, c_class_hashid )\
 140 
#define DESTROY_hashid_name(destroyer_, id_, cache_, next_, hash_, text_, c_class_hashid)\
141 
    {\
 141 
    {\
142 
	c_class *x294_ = CHECK_TAG ( ( c_class_hashid ), 0 ) ;\
 142 
	c_class *x294_ = CHECK_TAG((c_class_hashid), 0);\
143 
	( id_ ) = DEREF_id ( x294_ + 1 ) ;\
 143 
	(id_) = DEREF_id(x294_ + 1);\
144 
	( cache_ ) = DEREF_id ( x294_ + 2 ) ;\
 144 
	(cache_) = DEREF_id(x294_ + 2);\
145 
	( next_ ) = DEREF_hashid ( x294_ + 3 ) ;\
 145 
	(next_) = DEREF_hashid(x294_ + 3);\
146 
	( hash_ ) = DEREF_ulong ( x294_ + 4 ) ;\
 146 
	(hash_) = DEREF_ulong(x294_ + 4);\
147 
	( text_ ) = DEREF_string ( x294_ + 5 ) ;\
 147 
	(text_) = DEREF_string(x294_ + 5);\
148 
	( destroyer_ ) ( x294_, ( unsigned ) 6 ) ;\
 148 
	(destroyer_)(x294_, (unsigned)6);\
149 
    }
 149 
    }
150 
 
 150 
 
151 
 
 151 
 
152 
/* Operations for field ename of union HASHID */
 152 
/* Operations for field ename of union HASHID */
153 
 
 153 
 
154 
#define hashid_ename_tag		( ( unsigned ) 1 )
 154 
#define hashid_ename_tag		((unsigned)1)
155 
#define IS_hashid_ename( P )		( CHECK_NULL ( P )->ag_tag == 1 )
 155 
#define IS_hashid_ename(P)		(CHECK_NULL(P)->ag_tag == 1)
156 
 
 156 
 
157 
#define hashid_ename_text( P )		( CHECK_TAG ( ( P ), 1 ) + 5 )
 157 
#define hashid_ename_text(P)		(CHECK_TAG((P), 1) + 5)
158 
 
 158 
 
159 
#define MAKE_hashid_ename( next_, hash_, text_, c_class_hashid )\
 159 
#define MAKE_hashid_ename(next_, hash_, text_, c_class_hashid)\
160 
    {\
 160 
    {\
161 
	c_class *x295_ = GEN_c_class ( 6, TYPEID_hashid ) ;\
 161 
	c_class *x295_ = GEN_c_class(6, TYPEID_hashid);\
162 
	x295_->ag_tag = 1 ;\
 162 
	x295_->ag_tag = 1;\
163 
	COPY_id ( x295_ + 1, NULL_id ) ;\
 163 
	COPY_id(x295_ + 1, NULL_id);\
164 
	COPY_id ( x295_ + 2, NULL_id ) ;\
 164 
	COPY_id(x295_ + 2, NULL_id);\
165 
	COPY_hashid ( x295_ + 3, ( next_ ) ) ;\
 165 
	COPY_hashid(x295_ + 3, (next_));\
166 
	COPY_ulong ( x295_ + 4, ( hash_ ) ) ;\
 166 
	COPY_ulong(x295_ + 4, (hash_));\
167 
	COPY_string ( x295_ + 5, ( text_ ) ) ;\
 167 
	COPY_string(x295_ + 5, (text_));\
168 
	( c_class_hashid ) = x295_ ;\
 168 
	(c_class_hashid) = x295_;\
169 
    }
 169 
    }
170 
 
 170 
 
171 
#define DECONS_hashid_ename( id_, cache_, next_, hash_, text_, c_class_hashid )\
 171 
#define DECONS_hashid_ename(id_, cache_, next_, hash_, text_, c_class_hashid)\
172 
    {\
 172 
    {\
173 
	c_class *x296_ = CHECK_TAG ( ( c_class_hashid ), 1 ) ;\
 173 
	c_class *x296_ = CHECK_TAG((c_class_hashid), 1);\
174 
	( id_ ) = DEREF_id ( x296_ + 1 ) ;\
 174 
	(id_) = DEREF_id(x296_ + 1);\
175 
	( cache_ ) = DEREF_id ( x296_ + 2 ) ;\
 175 
	(cache_) = DEREF_id(x296_ + 2);\
176 
	( next_ ) = DEREF_hashid ( x296_ + 3 ) ;\
 176 
	(next_) = DEREF_hashid(x296_ + 3);\
177 
	( hash_ ) = DEREF_ulong ( x296_ + 4 ) ;\
 177 
	(hash_) = DEREF_ulong(x296_ + 4);\
178 
	( text_ ) = DEREF_string ( x296_ + 5 ) ;\
 178 
	(text_) = DEREF_string(x296_ + 5);\
179 
    }
 179 
    }
180 
 
 180 
 
181 
#define DESTROY_hashid_ename( destroyer_, id_, cache_, next_, hash_, text_, c_class_hashid )\
 181 
#define DESTROY_hashid_ename(destroyer_, id_, cache_, next_, hash_, text_, c_class_hashid)\
182 
    {\
 182 
    {\
183 
	c_class *x297_ = CHECK_TAG ( ( c_class_hashid ), 1 ) ;\
 183 
	c_class *x297_ = CHECK_TAG((c_class_hashid), 1);\
184 
	( id_ ) = DEREF_id ( x297_ + 1 ) ;\
 184 
	(id_) = DEREF_id(x297_ + 1);\
185 
	( cache_ ) = DEREF_id ( x297_ + 2 ) ;\
 185 
	(cache_) = DEREF_id(x297_ + 2);\
186 
	( next_ ) = DEREF_hashid ( x297_ + 3 ) ;\
 186 
	(next_) = DEREF_hashid(x297_ + 3);\
187 
	( hash_ ) = DEREF_ulong ( x297_ + 4 ) ;\
 187 
	(hash_) = DEREF_ulong(x297_ + 4);\
188 
	( text_ ) = DEREF_string ( x297_ + 5 ) ;\
 188 
	(text_) = DEREF_string(x297_ + 5);\
189 
	( destroyer_ ) ( x297_, ( unsigned ) 6 ) ;\
 189 
	(destroyer_)(x297_, (unsigned)6);\
190 
    }
 190 
    }
191 
 
 191 
 
192 
 
 192 
 
193 
/* Operations for field set constr_etc of union HASHID */
 193 
/* Operations for field set constr_etc of union HASHID */
194 
 
 194 
 
195 
#define hashid_constr_etc_tag		( ( unsigned ) 5 )
 195 
#define hashid_constr_etc_tag		((unsigned)5)
196 
#define IS_hashid_constr_etc( P )	( ( unsigned ) ( CHECK_NULL ( P )->ag_tag - 2 ) < ( unsigned ) 3 )
 196 
#define IS_hashid_constr_etc(P)		((unsigned)(CHECK_NULL(P)->ag_tag - 2) < (unsigned)3)
197 
 
 197 
 
198 
#define hashid_constr_etc_type( P )	( CHECK_TAG_ETC ( ( P ), 2, 5 ) + 5 )
 198 
#define hashid_constr_etc_type(P)	(CHECK_TAG_ETC((P), 2, 5) + 5)
199 
#define hashid_constr_etc_tid( P )	( CHECK_TAG_ETC ( ( P ), 2, 5 ) + 6 )
 199 
#define hashid_constr_etc_tid(P)	(CHECK_TAG_ETC((P), 2, 5) + 6)
200 
 
 200 
 
201 
#define MAKE_hashid_constr_etc( tag, next_, hash_, type_, tid_, c_class_hashid )\
 201 
#define MAKE_hashid_constr_etc(tag, next_, hash_, type_, tid_, c_class_hashid)\
202 
    {\
 202 
    {\
203 
	c_class *x298_ = GEN_c_class ( 7, TYPEID_hashid ) ;\
 203 
	c_class *x298_ = GEN_c_class(7, TYPEID_hashid);\
204 
	x298_->ag_tag = ( tag ) ;\
 204 
	x298_->ag_tag = (tag);\
205 
	COPY_id ( x298_ + 1, NULL_id ) ;\
 205 
	COPY_id(x298_ + 1, NULL_id);\
206 
	COPY_id ( x298_ + 2, NULL_id ) ;\
 206 
	COPY_id(x298_ + 2, NULL_id);\
207 
	COPY_hashid ( x298_ + 3, ( next_ ) ) ;\
 207 
	COPY_hashid(x298_ + 3, (next_));\
208 
	COPY_ulong ( x298_ + 4, ( hash_ ) ) ;\
 208 
	COPY_ulong(x298_ + 4, (hash_));\
209 
	COPY_type ( x298_ + 5, ( type_ ) ) ;\
 209 
	COPY_type(x298_ + 5, (type_));\
210 
	COPY_id ( x298_ + 6, ( tid_ ) ) ;\
 210 
	COPY_id(x298_ + 6, (tid_));\
211 
	( c_class_hashid ) = CHECK_TAG_ETC ( x298_, 2, 5 ) ;\
 211 
	(c_class_hashid) = CHECK_TAG_ETC(x298_, 2, 5);\
212 
    }
 212 
    }
213 
 
 213 
 
214 
#define MODIFY_hashid_constr_etc( tag, c_class_hashid )\
 214 
#define MODIFY_hashid_constr_etc(tag, c_class_hashid)\
215 
    {\
 215 
    {\
216 
	c_class *x299_ = CHECK_TAG_ETC ( ( c_class_hashid ), 2, 5 ) ;\
 216 
	c_class *x299_ = CHECK_TAG_ETC ((c_class_hashid), 2, 5);\
217 
	x299_->ag_tag = ( tag ) ;\
 217 
	x299_->ag_tag = (tag);\
218 
	( void ) CHECK_TAG_ETC ( x299_, 2, 5 ) ;\
 218 
	(void) CHECK_TAG_ETC (x299_, 2, 5);\
219 
    }
 219 
    }
220 
 
 220 
 
221 
#define DECONS_hashid_constr_etc( id_, cache_, next_, hash_, type_, tid_, c_class_hashid )\
 221 
#define DECONS_hashid_constr_etc(id_, cache_, next_, hash_, type_, tid_, c_class_hashid)\
222 
    {\
 222 
    {\
223 
	c_class *x300_ = CHECK_TAG_ETC ( ( c_class_hashid ), 2, 5 ) ;\
 223 
	c_class *x300_ = CHECK_TAG_ETC((c_class_hashid), 2, 5);\
224 
	( id_ ) = DEREF_id ( x300_ + 1 ) ;\
 224 
	(id_) = DEREF_id(x300_ + 1);\
225 
	( cache_ ) = DEREF_id ( x300_ + 2 ) ;\
 225 
	(cache_) = DEREF_id(x300_ + 2);\
226 
	( next_ ) = DEREF_hashid ( x300_ + 3 ) ;\
 226 
	(next_) = DEREF_hashid(x300_ + 3);\
227 
	( hash_ ) = DEREF_ulong ( x300_ + 4 ) ;\
 227 
	(hash_) = DEREF_ulong(x300_ + 4);\
228 
	( type_ ) = DEREF_type ( x300_ + 5 ) ;\
 228 
	(type_) = DEREF_type(x300_ + 5);\
229 
	( tid_ ) = DEREF_id ( x300_ + 6 ) ;\
 229 
	(tid_) = DEREF_id(x300_ + 6);\
230 
    }
 230 
    }
231 
 
 231 
 
232 
#define DESTROY_hashid_constr_etc( destroyer_, id_, cache_, next_, hash_, type_, tid_, c_class_hashid )\
 232 
#define DESTROY_hashid_constr_etc(destroyer_, id_, cache_, next_, hash_, type_, tid_, c_class_hashid)\
233 
    {\
 233 
    {\
234 
	c_class *x301_ = CHECK_TAG_ETC ( ( c_class_hashid ), 2, 5 ) ;\
 234 
	c_class *x301_ = CHECK_TAG_ETC((c_class_hashid), 2, 5);\
235 
	( id_ ) = DEREF_id ( x301_ + 1 ) ;\
 235 
	(id_) = DEREF_id(x301_ + 1);\
236 
	( cache_ ) = DEREF_id ( x301_ + 2 ) ;\
 236 
	(cache_) = DEREF_id(x301_ + 2);\
237 
	( next_ ) = DEREF_hashid ( x301_ + 3 ) ;\
 237 
	(next_) = DEREF_hashid(x301_ + 3);\
238 
	( hash_ ) = DEREF_ulong ( x301_ + 4 ) ;\
 238 
	(hash_) = DEREF_ulong(x301_ + 4);\
239 
	( type_ ) = DEREF_type ( x301_ + 5 ) ;\
 239 
	(type_) = DEREF_type(x301_ + 5);\
240 
	( tid_ ) = DEREF_id ( x301_ + 6 ) ;\
 240 
	(tid_) = DEREF_id(x301_ + 6);\
241 
	( destroyer_ ) ( x301_, ( unsigned ) 7 ) ;\
 241 
	(destroyer_)(x301_, (unsigned)7);\
242 
    }
 242 
    }
243 
 
 243 
 
244 
 
 244 
 
245 
/* Operations for field constr of union HASHID */
 245 
/* Operations for field constr of union HASHID */
246 
 
 246 
 
247 
#define hashid_constr_tag		( ( unsigned ) 2 )
 247 
#define hashid_constr_tag		((unsigned)2)
248 
#define IS_hashid_constr( P )		( CHECK_NULL ( P )->ag_tag == 2 )
 248 
#define IS_hashid_constr(P)		(CHECK_NULL(P)->ag_tag == 2)
249 
 
 249 
 
250 
#define hashid_constr_type( P )		( CHECK_TAG ( ( P ), 2 ) + 5 )
 250 
#define hashid_constr_type(P)		(CHECK_TAG((P), 2) + 5)
251 
#define hashid_constr_tid( P )		( CHECK_TAG ( ( P ), 2 ) + 6 )
 251 
#define hashid_constr_tid(P)		(CHECK_TAG((P), 2) + 6)
252 
 
 252 
 
253 
#define MAKE_hashid_constr( next_, hash_, type_, tid_, c_class_hashid )\
 253 
#define MAKE_hashid_constr(next_, hash_, type_, tid_, c_class_hashid)\
254 
    {\
 254 
    {\
255 
	c_class *x302_ = GEN_c_class ( 7, TYPEID_hashid ) ;\
 255 
	c_class *x302_ = GEN_c_class(7, TYPEID_hashid);\
256 
	x302_->ag_tag = 2 ;\
 256 
	x302_->ag_tag = 2;\
257 
	COPY_id ( x302_ + 1, NULL_id ) ;\
 257 
	COPY_id(x302_ + 1, NULL_id);\
258 
	COPY_id ( x302_ + 2, NULL_id ) ;\
 258 
	COPY_id(x302_ + 2, NULL_id);\
259 
	COPY_hashid ( x302_ + 3, ( next_ ) ) ;\
 259 
	COPY_hashid(x302_ + 3, (next_));\
260 
	COPY_ulong ( x302_ + 4, ( hash_ ) ) ;\
 260 
	COPY_ulong(x302_ + 4, (hash_));\
261 
	COPY_type ( x302_ + 5, ( type_ ) ) ;\
 261 
	COPY_type(x302_ + 5, (type_));\
262 
	COPY_id ( x302_ + 6, ( tid_ ) ) ;\
 262 
	COPY_id(x302_ + 6, (tid_));\
263 
	( c_class_hashid ) = x302_ ;\
 263 
	(c_class_hashid) = x302_;\
264 
    }
 264 
    }
265 
 
 265 
 
266 
#define DECONS_hashid_constr( id_, cache_, next_, hash_, type_, tid_, c_class_hashid )\
 266 
#define DECONS_hashid_constr(id_, cache_, next_, hash_, type_, tid_, c_class_hashid)\
267 
    {\
 267 
    {\
268 
	c_class *x303_ = CHECK_TAG ( ( c_class_hashid ), 2 ) ;\
 268 
	c_class *x303_ = CHECK_TAG((c_class_hashid), 2);\
269 
	( id_ ) = DEREF_id ( x303_ + 1 ) ;\
 269 
	(id_) = DEREF_id(x303_ + 1);\
270 
	( cache_ ) = DEREF_id ( x303_ + 2 ) ;\
 270 
	(cache_) = DEREF_id(x303_ + 2);\
271 
	( next_ ) = DEREF_hashid ( x303_ + 3 ) ;\
 271 
	(next_) = DEREF_hashid(x303_ + 3);\
272 
	( hash_ ) = DEREF_ulong ( x303_ + 4 ) ;\
 272 
	(hash_) = DEREF_ulong(x303_ + 4);\
273 
	( type_ ) = DEREF_type ( x303_ + 5 ) ;\
 273 
	(type_) = DEREF_type(x303_ + 5);\
274 
	( tid_ ) = DEREF_id ( x303_ + 6 ) ;\
 274 
	(tid_) = DEREF_id(x303_ + 6);\
275 
    }
 275 
    }
276 
 
 276 
 
277 
#define DESTROY_hashid_constr( destroyer_, id_, cache_, next_, hash_, type_, tid_, c_class_hashid )\
 277 
#define DESTROY_hashid_constr(destroyer_, id_, cache_, next_, hash_, type_, tid_, c_class_hashid)\
278 
    {\
 278 
    {\
279 
	c_class *x304_ = CHECK_TAG ( ( c_class_hashid ), 2 ) ;\
 279 
	c_class *x304_ = CHECK_TAG((c_class_hashid), 2);\
280 
	( id_ ) = DEREF_id ( x304_ + 1 ) ;\
 280 
	(id_) = DEREF_id(x304_ + 1);\
281 
	( cache_ ) = DEREF_id ( x304_ + 2 ) ;\
 281 
	(cache_) = DEREF_id(x304_ + 2);\
282 
	( next_ ) = DEREF_hashid ( x304_ + 3 ) ;\
 282 
	(next_) = DEREF_hashid(x304_ + 3);\
283 
	( hash_ ) = DEREF_ulong ( x304_ + 4 ) ;\
 283 
	(hash_) = DEREF_ulong(x304_ + 4);\
284 
	( type_ ) = DEREF_type ( x304_ + 5 ) ;\
 284 
	(type_) = DEREF_type(x304_ + 5);\
285 
	( tid_ ) = DEREF_id ( x304_ + 6 ) ;\
 285 
	(tid_) = DEREF_id(x304_ + 6);\
286 
	( destroyer_ ) ( x304_, ( unsigned ) 7 ) ;\
 286 
	(destroyer_)(x304_, (unsigned)7);\
287 
    }
 287 
    }
288 
 
 288 
 
289 
 
 289 
 
290 
/* Operations for field destr of union HASHID */
 290 
/* Operations for field destr of union HASHID */
291 
 
 291 
 
292 
#define hashid_destr_tag		( ( unsigned ) 3 )
 292 
#define hashid_destr_tag		((unsigned)3)
293 
#define IS_hashid_destr( P )		( CHECK_NULL ( P )->ag_tag == 3 )
 293 
#define IS_hashid_destr(P)		(CHECK_NULL(P)->ag_tag == 3)
294 
 
 294 
 
295 
#define hashid_destr_type( P )		( CHECK_TAG ( ( P ), 3 ) + 5 )
 295 
#define hashid_destr_type(P)		(CHECK_TAG((P), 3) + 5)
296 
#define hashid_destr_tid( P )		( CHECK_TAG ( ( P ), 3 ) + 6 )
 296 
#define hashid_destr_tid(P)		(CHECK_TAG((P), 3) + 6)
297 
 
 297 
 
298 
#define MAKE_hashid_destr( next_, hash_, type_, tid_, c_class_hashid )\
 298 
#define MAKE_hashid_destr(next_, hash_, type_, tid_, c_class_hashid)\
299 
    {\
 299 
    {\
300 
	c_class *x305_ = GEN_c_class ( 7, TYPEID_hashid ) ;\
 300 
	c_class *x305_ = GEN_c_class(7, TYPEID_hashid);\
301 
	x305_->ag_tag = 3 ;\
 301 
	x305_->ag_tag = 3;\
302 
	COPY_id ( x305_ + 1, NULL_id ) ;\
 302 
	COPY_id(x305_ + 1, NULL_id);\
303 
	COPY_id ( x305_ + 2, NULL_id ) ;\
 303 
	COPY_id(x305_ + 2, NULL_id);\
304 
	COPY_hashid ( x305_ + 3, ( next_ ) ) ;\
 304 
	COPY_hashid(x305_ + 3, (next_));\
305 
	COPY_ulong ( x305_ + 4, ( hash_ ) ) ;\
 305 
	COPY_ulong(x305_ + 4, (hash_));\
306 
	COPY_type ( x305_ + 5, ( type_ ) ) ;\
 306 
	COPY_type(x305_ + 5, (type_));\
307 
	COPY_id ( x305_ + 6, ( tid_ ) ) ;\
 307 
	COPY_id(x305_ + 6, (tid_));\
308 
	( c_class_hashid ) = x305_ ;\
 308 
	(c_class_hashid) = x305_;\
309 
    }
 309 
    }
310 
 
 310 
 
311 
#define DECONS_hashid_destr( id_, cache_, next_, hash_, type_, tid_, c_class_hashid )\
 311 
#define DECONS_hashid_destr(id_, cache_, next_, hash_, type_, tid_, c_class_hashid)\
312 
    {\
 312 
    {\
313 
	c_class *x306_ = CHECK_TAG ( ( c_class_hashid ), 3 ) ;\
 313 
	c_class *x306_ = CHECK_TAG((c_class_hashid), 3);\
314 
	( id_ ) = DEREF_id ( x306_ + 1 ) ;\
 314 
	(id_) = DEREF_id(x306_ + 1);\
315 
	( cache_ ) = DEREF_id ( x306_ + 2 ) ;\
 315 
	(cache_) = DEREF_id(x306_ + 2);\
316 
	( next_ ) = DEREF_hashid ( x306_ + 3 ) ;\
 316 
	(next_) = DEREF_hashid(x306_ + 3);\
317 
	( hash_ ) = DEREF_ulong ( x306_ + 4 ) ;\
 317 
	(hash_) = DEREF_ulong(x306_ + 4);\
318 
	( type_ ) = DEREF_type ( x306_ + 5 ) ;\
 318 
	(type_) = DEREF_type(x306_ + 5);\
319 
	( tid_ ) = DEREF_id ( x306_ + 6 ) ;\
 319 
	(tid_) = DEREF_id(x306_ + 6);\
320 
    }
 320 
    }
321 
 
 321 
 
322 
#define DESTROY_hashid_destr( destroyer_, id_, cache_, next_, hash_, type_, tid_, c_class_hashid )\
 322 
#define DESTROY_hashid_destr(destroyer_, id_, cache_, next_, hash_, type_, tid_, c_class_hashid)\
323 
    {\
 323 
    {\
324 
	c_class *x307_ = CHECK_TAG ( ( c_class_hashid ), 3 ) ;\
 324 
	c_class *x307_ = CHECK_TAG((c_class_hashid), 3);\
325 
	( id_ ) = DEREF_id ( x307_ + 1 ) ;\
 325 
	(id_) = DEREF_id(x307_ + 1);\
326 
	( cache_ ) = DEREF_id ( x307_ + 2 ) ;\
 326 
	(cache_) = DEREF_id(x307_ + 2);\
327 
	( next_ ) = DEREF_hashid ( x307_ + 3 ) ;\
 327 
	(next_) = DEREF_hashid(x307_ + 3);\
328 
	( hash_ ) = DEREF_ulong ( x307_ + 4 ) ;\
 328 
	(hash_) = DEREF_ulong(x307_ + 4);\
329 
	( type_ ) = DEREF_type ( x307_ + 5 ) ;\
 329 
	(type_) = DEREF_type(x307_ + 5);\
330 
	( tid_ ) = DEREF_id ( x307_ + 6 ) ;\
 330 
	(tid_) = DEREF_id(x307_ + 6);\
331 
	( destroyer_ ) ( x307_, ( unsigned ) 7 ) ;\
 331 
	(destroyer_)(x307_, (unsigned)7);\
332 
    }
 332 
    }
333 
 
 333 
 
334 
 
 334 
 
335 
/* Operations for field conv of union HASHID */
 335 
/* Operations for field conv of union HASHID */
336 
 
 336 
 
337 
#define hashid_conv_tag			( ( unsigned ) 4 )
 337 
#define hashid_conv_tag			((unsigned)4)
338 
#define IS_hashid_conv( P )		( CHECK_NULL ( P )->ag_tag == 4 )
 338 
#define IS_hashid_conv(P)		(CHECK_NULL(P)->ag_tag == 4)
339 
 
 339 
 
340 
#define hashid_conv_type( P )		( CHECK_TAG ( ( P ), 4 ) + 5 )
 340 
#define hashid_conv_type(P)		(CHECK_TAG((P), 4) + 5)
341 
#define hashid_conv_tid( P )		( CHECK_TAG ( ( P ), 4 ) + 6 )
 341 
#define hashid_conv_tid(P)		(CHECK_TAG((P), 4) + 6)
342 
 
 342 
 
343 
#define MAKE_hashid_conv( next_, hash_, type_, tid_, c_class_hashid )\
 343 
#define MAKE_hashid_conv(next_, hash_, type_, tid_, c_class_hashid)\
344 
    {\
 344 
    {\
345 
	c_class *x308_ = GEN_c_class ( 7, TYPEID_hashid ) ;\
 345 
	c_class *x308_ = GEN_c_class(7, TYPEID_hashid);\
346 
	x308_->ag_tag = 4 ;\
 346 
	x308_->ag_tag = 4;\
347 
	COPY_id ( x308_ + 1, NULL_id ) ;\
 347 
	COPY_id(x308_ + 1, NULL_id);\
348 
	COPY_id ( x308_ + 2, NULL_id ) ;\
 348 
	COPY_id(x308_ + 2, NULL_id);\
349 
	COPY_hashid ( x308_ + 3, ( next_ ) ) ;\
 349 
	COPY_hashid(x308_ + 3, (next_));\
350 
	COPY_ulong ( x308_ + 4, ( hash_ ) ) ;\
 350 
	COPY_ulong(x308_ + 4, (hash_));\
351 
	COPY_type ( x308_ + 5, ( type_ ) ) ;\
 351 
	COPY_type(x308_ + 5, (type_));\
352 
	COPY_id ( x308_ + 6, ( tid_ ) ) ;\
 352 
	COPY_id(x308_ + 6, (tid_));\
353 
	( c_class_hashid ) = x308_ ;\
 353 
	(c_class_hashid) = x308_;\
354 
    }
 354 
    }
355 
 
 355 
 
356 
#define DECONS_hashid_conv( id_, cache_, next_, hash_, type_, tid_, c_class_hashid )\
 356 
#define DECONS_hashid_conv(id_, cache_, next_, hash_, type_, tid_, c_class_hashid)\
357 
    {\
 357 
    {\
358 
	c_class *x309_ = CHECK_TAG ( ( c_class_hashid ), 4 ) ;\
 358 
	c_class *x309_ = CHECK_TAG((c_class_hashid), 4);\
359 
	( id_ ) = DEREF_id ( x309_ + 1 ) ;\
 359 
	(id_) = DEREF_id(x309_ + 1);\
360 
	( cache_ ) = DEREF_id ( x309_ + 2 ) ;\
 360 
	(cache_) = DEREF_id(x309_ + 2);\
361 
	( next_ ) = DEREF_hashid ( x309_ + 3 ) ;\
 361 
	(next_) = DEREF_hashid(x309_ + 3);\
362 
	( hash_ ) = DEREF_ulong ( x309_ + 4 ) ;\
 362 
	(hash_) = DEREF_ulong(x309_ + 4);\
363 
	( type_ ) = DEREF_type ( x309_ + 5 ) ;\
 363 
	(type_) = DEREF_type(x309_ + 5);\
364 
	( tid_ ) = DEREF_id ( x309_ + 6 ) ;\
 364 
	(tid_) = DEREF_id(x309_ + 6);\
365 
    }
 365 
    }
366 
 
 366 
 
367 
#define DESTROY_hashid_conv( destroyer_, id_, cache_, next_, hash_, type_, tid_, c_class_hashid )\
 367 
#define DESTROY_hashid_conv(destroyer_, id_, cache_, next_, hash_, type_, tid_, c_class_hashid)\
368 
    {\
 368 
    {\
369 
	c_class *x310_ = CHECK_TAG ( ( c_class_hashid ), 4 ) ;\
 369 
	c_class *x310_ = CHECK_TAG((c_class_hashid), 4);\
370 
	( id_ ) = DEREF_id ( x310_ + 1 ) ;\
 370 
	(id_) = DEREF_id(x310_ + 1);\
371 
	( cache_ ) = DEREF_id ( x310_ + 2 ) ;\
 371 
	(cache_) = DEREF_id(x310_ + 2);\
372 
	( next_ ) = DEREF_hashid ( x310_ + 3 ) ;\
 372 
	(next_) = DEREF_hashid(x310_ + 3);\
373 
	( hash_ ) = DEREF_ulong ( x310_ + 4 ) ;\
 373 
	(hash_) = DEREF_ulong(x310_ + 4);\
374 
	( type_ ) = DEREF_type ( x310_ + 5 ) ;\
 374 
	(type_) = DEREF_type(x310_ + 5);\
375 
	( tid_ ) = DEREF_id ( x310_ + 6 ) ;\
 375 
	(tid_) = DEREF_id(x310_ + 6);\
376 
	( destroyer_ ) ( x310_, ( unsigned ) 7 ) ;\
 376 
	(destroyer_)(x310_, (unsigned)7);\
377 
    }
 377 
    }
378 
 
 378 
 
379 
 
 379 
 
380 
/* Operations for field op of union HASHID */
 380 
/* Operations for field op of union HASHID */
381 
 
 381 
 
382 
#define hashid_op_tag			( ( unsigned ) 5 )
 382 
#define hashid_op_tag			((unsigned)5)
383 
#define IS_hashid_op( P )		( CHECK_NULL ( P )->ag_tag == 5 )
 383 
#define IS_hashid_op(P)			(CHECK_NULL(P)->ag_tag == 5)
384 
 
 384 
 
385 
#define hashid_op_lex( P )		( CHECK_TAG ( ( P ), 5 ) + 5 )
 385 
#define hashid_op_lex(P)		(CHECK_TAG((P), 5) + 5)
386 
 
 386 
 
387 
#define MAKE_hashid_op( next_, hash_, lex_, c_class_hashid )\
 387 
#define MAKE_hashid_op(next_, hash_, lex_, c_class_hashid)\
388 
    {\
 388 
    {\
389 
	c_class *x311_ = GEN_c_class ( 6, TYPEID_hashid ) ;\
 389 
	c_class *x311_ = GEN_c_class(6, TYPEID_hashid);\
390 
	x311_->ag_tag = 5 ;\
 390 
	x311_->ag_tag = 5;\
391 
	COPY_id ( x311_ + 1, NULL_id ) ;\
 391 
	COPY_id(x311_ + 1, NULL_id);\
392 
	COPY_id ( x311_ + 2, NULL_id ) ;\
 392 
	COPY_id(x311_ + 2, NULL_id);\
393 
	COPY_hashid ( x311_ + 3, ( next_ ) ) ;\
 393 
	COPY_hashid(x311_ + 3, (next_));\
394 
	COPY_ulong ( x311_ + 4, ( hash_ ) ) ;\
 394 
	COPY_ulong(x311_ + 4, (hash_));\
395 
	COPY_int ( x311_ + 5, ( lex_ ) ) ;\
 395 
	COPY_int(x311_ + 5, (lex_));\
396 
	( c_class_hashid ) = x311_ ;\
 396 
	(c_class_hashid) = x311_;\
397 
    }
 397 
    }
398 
 
 398 
 
399 
#define DECONS_hashid_op( id_, cache_, next_, hash_, lex_, c_class_hashid )\
 399 
#define DECONS_hashid_op(id_, cache_, next_, hash_, lex_, c_class_hashid)\
400 
    {\
 400 
    {\
401 
	c_class *x312_ = CHECK_TAG ( ( c_class_hashid ), 5 ) ;\
 401 
	c_class *x312_ = CHECK_TAG((c_class_hashid), 5);\
402 
	( id_ ) = DEREF_id ( x312_ + 1 ) ;\
 402 
	(id_) = DEREF_id(x312_ + 1);\
403 
	( cache_ ) = DEREF_id ( x312_ + 2 ) ;\
 403 
	(cache_) = DEREF_id(x312_ + 2);\
404 
	( next_ ) = DEREF_hashid ( x312_ + 3 ) ;\
 404 
	(next_) = DEREF_hashid(x312_ + 3);\
405 
	( hash_ ) = DEREF_ulong ( x312_ + 4 ) ;\
 405 
	(hash_) = DEREF_ulong(x312_ + 4);\
406 
	( lex_ ) = DEREF_int ( x312_ + 5 ) ;\
 406 
	(lex_) = DEREF_int(x312_ + 5);\
407 
    }
 407 
    }
408 
 
 408 
 
409 
#define DESTROY_hashid_op( destroyer_, id_, cache_, next_, hash_, lex_, c_class_hashid )\
 409 
#define DESTROY_hashid_op(destroyer_, id_, cache_, next_, hash_, lex_, c_class_hashid)\
410 
    {\
 410 
    {\
411 
	c_class *x313_ = CHECK_TAG ( ( c_class_hashid ), 5 ) ;\
 411 
	c_class *x313_ = CHECK_TAG((c_class_hashid), 5);\
412 
	( id_ ) = DEREF_id ( x313_ + 1 ) ;\
 412 
	(id_) = DEREF_id(x313_ + 1);\
413 
	( cache_ ) = DEREF_id ( x313_ + 2 ) ;\
 413 
	(cache_) = DEREF_id(x313_ + 2);\
414 
	( next_ ) = DEREF_hashid ( x313_ + 3 ) ;\
 414 
	(next_) = DEREF_hashid(x313_ + 3);\
415 
	( hash_ ) = DEREF_ulong ( x313_ + 4 ) ;\
 415 
	(hash_) = DEREF_ulong(x313_ + 4);\
416 
	( lex_ ) = DEREF_int ( x313_ + 5 ) ;\
 416 
	(lex_) = DEREF_int(x313_ + 5);\
417 
	( destroyer_ ) ( x313_, ( unsigned ) 6 ) ;\
 417 
	(destroyer_)(x313_, (unsigned)6);\
418 
    }
 418 
    }
419 
 
 419 
 
420 
 
 420 
 
421 
/* Operations for field anon of union HASHID */
 421 
/* Operations for field anon of union HASHID */
422 
 
 422 
 
423 
#define hashid_anon_tag			( ( unsigned ) 6 )
 423 
#define hashid_anon_tag			((unsigned)6)
424 
#define IS_hashid_anon( P )		( CHECK_NULL ( P )->ag_tag == 6 )
 424 
#define IS_hashid_anon(P)		(CHECK_NULL(P)->ag_tag == 6)
425 
 
 425 
 
426 
#define hashid_anon_uniq( P )		( CHECK_TAG ( ( P ), 6 ) + 5 )
 426 
#define hashid_anon_uniq(P)		(CHECK_TAG((P), 6) + 5)
427 
 
 427 
 
428 
#define MAKE_hashid_anon( next_, hash_, uniq_, c_class_hashid )\
 428 
#define MAKE_hashid_anon(next_, hash_, uniq_, c_class_hashid)\
429 
    {\
 429 
    {\
430 
	c_class *x314_ = GEN_c_class ( 6, TYPEID_hashid ) ;\
 430 
	c_class *x314_ = GEN_c_class(6, TYPEID_hashid);\
431 
	x314_->ag_tag = 6 ;\
 431 
	x314_->ag_tag = 6;\
432 
	COPY_id ( x314_ + 1, NULL_id ) ;\
 432 
	COPY_id(x314_ + 1, NULL_id);\
433 
	COPY_id ( x314_ + 2, NULL_id ) ;\
 433 
	COPY_id(x314_ + 2, NULL_id);\
434 
	COPY_hashid ( x314_ + 3, ( next_ ) ) ;\
 434 
	COPY_hashid(x314_ + 3, (next_));\
435 
	COPY_ulong ( x314_ + 4, ( hash_ ) ) ;\
 435 
	COPY_ulong(x314_ + 4, (hash_));\
436 
	COPY_ulong ( x314_ + 5, ( uniq_ ) ) ;\
 436 
	COPY_ulong(x314_ + 5, (uniq_));\
437 
	( c_class_hashid ) = x314_ ;\
 437 
	(c_class_hashid) = x314_;\
438 
    }
 438 
    }
439 
 
 439 
 
440 
#define DECONS_hashid_anon( id_, cache_, next_, hash_, uniq_, c_class_hashid )\
 440 
#define DECONS_hashid_anon(id_, cache_, next_, hash_, uniq_, c_class_hashid)\
441 
    {\
 441 
    {\
442 
	c_class *x315_ = CHECK_TAG ( ( c_class_hashid ), 6 ) ;\
 442 
	c_class *x315_ = CHECK_TAG((c_class_hashid), 6);\
443 
	( id_ ) = DEREF_id ( x315_ + 1 ) ;\
 443 
	(id_) = DEREF_id(x315_ + 1);\
444 
	( cache_ ) = DEREF_id ( x315_ + 2 ) ;\
 444 
	(cache_) = DEREF_id(x315_ + 2);\
445 
	( next_ ) = DEREF_hashid ( x315_ + 3 ) ;\
 445 
	(next_) = DEREF_hashid(x315_ + 3);\
446 
	( hash_ ) = DEREF_ulong ( x315_ + 4 ) ;\
 446 
	(hash_) = DEREF_ulong(x315_ + 4);\
447 
	( uniq_ ) = DEREF_ulong ( x315_ + 5 ) ;\
 447 
	(uniq_) = DEREF_ulong(x315_ + 5);\
448 
    }
 448 
    }
449 
 
 449 
 
450 
#define DESTROY_hashid_anon( destroyer_, id_, cache_, next_, hash_, uniq_, c_class_hashid )\
 450 
#define DESTROY_hashid_anon(destroyer_, id_, cache_, next_, hash_, uniq_, c_class_hashid)\
451 
    {\
 451 
    {\
452 
	c_class *x316_ = CHECK_TAG ( ( c_class_hashid ), 6 ) ;\
 452 
	c_class *x316_ = CHECK_TAG((c_class_hashid), 6);\
453 
	( id_ ) = DEREF_id ( x316_ + 1 ) ;\
 453 
	(id_) = DEREF_id(x316_ + 1);\
454 
	( cache_ ) = DEREF_id ( x316_ + 2 ) ;\
 454 
	(cache_) = DEREF_id(x316_ + 2);\
455 
	( next_ ) = DEREF_hashid ( x316_ + 3 ) ;\
 455 
	(next_) = DEREF_hashid(x316_ + 3);\
456 
	( hash_ ) = DEREF_ulong ( x316_ + 4 ) ;\
 456 
	(hash_) = DEREF_ulong(x316_ + 4);\
457 
	( uniq_ ) = DEREF_ulong ( x316_ + 5 ) ;\
 457 
	(uniq_) = DEREF_ulong(x316_ + 5);\
458 
	( destroyer_ ) ( x316_, ( unsigned ) 6 ) ;\
 458 
	(destroyer_)(x316_, (unsigned)6);\
459 
    }
 459 
    }
460 
 
 460 
 
461 
 
 461 
 
462 
#endif
 462 
#endif