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 43... Line 43...
43 
#ifndef READ_disk_list_ptr_type
 43 
#ifndef READ_disk_list_ptr_type
44 
#define READ_disk_list_ptr_type() READ_list_ptr_type()
 44 
#define READ_disk_list_ptr_type() READ_list_ptr_type()
45 
#endif
 45 
#endif
46 
 
 46 
 
47 
#ifndef READ_list_ptr_type
 47 
#ifndef READ_list_ptr_type
48 
static LIST ( PTR ( TYPE ) ) READ_list_ptr_type PROTO_S ( ( void ) ) ;
 48 
static LIST(PTR(TYPE)) READ_list_ptr_type(void);
49 
#endif
 49 
#endif
50 
 
 50 
 
51 
#ifndef READ_disk_string
 51 
#ifndef READ_disk_string
52 
#define READ_disk_string() READ_string()
 52 
#define READ_disk_string() READ_string()
53 
#endif
 53 
#endif
Line 55... Line 55...
55 
#ifndef READ_disk_int
 55 
#ifndef READ_disk_int
56 
#define READ_disk_int() READ_int()
 56 
#define READ_disk_int() READ_int()
57 
#endif
 57 
#endif
58 
 
 58 
 
59 
#ifndef READ_type
 59 
#ifndef READ_type
60 
static TYPE READ_type PROTO_S ( ( void ) ) ;
 60 
static TYPE READ_type(void);
61 
#endif
 61 
#endif
62 
 
 62 
 
63 
#ifndef READ_zero_int
 63 
#ifndef READ_zero_int
64 
#define READ_zero_int() READ_int()
 64 
#define READ_zero_int() READ_int()
65 
#endif
 65 
#endif
Line 67... Line 67...
67 
#ifndef READ_PRIMITIVE_P
 67 
#ifndef READ_PRIMITIVE_P
68 
#define READ_PRIMITIVE_P() READ_ptr_prim()
 68 
#define READ_PRIMITIVE_P() READ_ptr_prim()
69 
#endif
 69 
#endif
70 
 
 70 
 
71 
#ifndef READ_ptr_prim
 71 
#ifndef READ_ptr_prim
72 
static PTR ( PRIMITIVE ) READ_ptr_prim PROTO_S ( ( void ) ) ;
 72 
static PTR(PRIMITIVE) READ_ptr_prim(void);
73 
#endif
 73 
#endif
74 
 
 74 
 
75 
#ifndef READ_prim
 75 
#ifndef READ_prim
76 
static PRIMITIVE READ_prim PROTO_S ( ( void ) ) ;
 76 
static PRIMITIVE READ_prim(void);
77 
#endif
 77 
#endif
78 
 
 78 
 
79 
#ifndef READ_CLASS_ID_P
 79 
#ifndef READ_CLASS_ID_P
80 
#define READ_CLASS_ID_P() READ_ptr_cid()
 80 
#define READ_CLASS_ID_P() READ_ptr_cid()
81 
#endif
 81 
#endif
82 
 
 82 
 
83 
#ifndef READ_ptr_cid
 83 
#ifndef READ_ptr_cid
84 
static PTR ( CLASS_ID ) READ_ptr_cid PROTO_S ( ( void ) ) ;
 84 
static PTR(CLASS_ID) READ_ptr_cid(void);
85 
#endif
 85 
#endif
86 
 
 86 
 
87 
#ifndef READ_cid
 87 
#ifndef READ_cid
88 
static CLASS_ID READ_cid PROTO_S ( ( void ) ) ;
 88 
static CLASS_ID READ_cid(void);
89 
#endif
 89 
#endif
90 
 
 90 
 
91 
#ifndef READ_name_string
 91 
#ifndef READ_name_string
92 
#define READ_name_string() READ_string()
 92 
#define READ_name_string() READ_string()
93 
#endif
 93 
#endif
Line 95... Line 95...
95 
#ifndef READ_IDENTITY_P
 95 
#ifndef READ_IDENTITY_P
96 
#define READ_IDENTITY_P() READ_ptr_ident()
 96 
#define READ_IDENTITY_P() READ_ptr_ident()
97 
#endif
 97 
#endif
98 
 
 98 
 
99 
#ifndef READ_ptr_ident
 99 
#ifndef READ_ptr_ident
100 
static PTR ( IDENTITY ) READ_ptr_ident PROTO_S ( ( void ) ) ;
 100 
static PTR(IDENTITY) READ_ptr_ident(void);
101 
#endif
 101 
#endif
102 
 
 102 
 
103 
#ifndef READ_ident
 103 
#ifndef READ_ident
104 
static IDENTITY READ_ident PROTO_S ( ( void ) ) ;
 104 
static IDENTITY READ_ident(void);
105 
#endif
 105 
#endif
106 
 
 106 
 
107 
#ifndef READ_TYPE_P
 107 
#ifndef READ_TYPE_P
108 
#define READ_TYPE_P() READ_ptr_type()
 108 
#define READ_TYPE_P() READ_ptr_type()
109 
#endif
 109 
#endif
110 
 
 110 
 
111 
#ifndef READ_ptr_type
 111 
#ifndef READ_ptr_type
112 
static PTR ( TYPE ) READ_ptr_type PROTO_S ( ( void ) ) ;
 112 
static PTR(TYPE) READ_ptr_type(void);
113 
#endif
 113 
#endif
114 
 
 114 
 
115 
#ifndef READ_ENUM_P
 115 
#ifndef READ_ENUM_P
116 
#define READ_ENUM_P() READ_ptr_en()
 116 
#define READ_ENUM_P() READ_ptr_en()
117 
#endif
 117 
#endif
118 
 
 118 
 
119 
#ifndef READ_ptr_en
 119 
#ifndef READ_ptr_en
120 
static PTR ( ENUM ) READ_ptr_en PROTO_S ( ( void ) ) ;
 120 
static PTR(ENUM) READ_ptr_en(void);
121 
#endif
 121 
#endif
122 
 
 122 
 
123 
#ifndef READ_en
 123 
#ifndef READ_en
124 
static ENUM READ_en PROTO_S ( ( void ) ) ;
 124 
static ENUM READ_en(void);
125 
#endif
 125 
#endif
126 
 
 126 
 
127 
#ifndef READ_list_ptr_ec
 127 
#ifndef READ_list_ptr_ec
128 
static LIST ( PTR ( ECONST ) ) READ_list_ptr_ec PROTO_S ( ( void ) ) ;
 128 
static LIST(PTR(ECONST)) READ_list_ptr_ec(void);
129 
#endif
 129 
#endif
130 
 
 130 
 
131 
#ifndef READ_list_ECONST_P
 131 
#ifndef READ_list_ECONST_P
132 
#define READ_list_ECONST_P() READ_list_ptr_ec()
 132 
#define READ_list_ECONST_P() READ_list_ptr_ec()
133 
#endif
 133 
#endif
Line 135... Line 135...
135 
#ifndef READ_ECONST_P
 135 
#ifndef READ_ECONST_P
136 
#define READ_ECONST_P() READ_ptr_ec()
 136 
#define READ_ECONST_P() READ_ptr_ec()
137 
#endif
 137 
#endif
138 
 
 138 
 
139 
#ifndef READ_ptr_ec
 139 
#ifndef READ_ptr_ec
140 
static PTR ( ECONST ) READ_ptr_ec PROTO_S ( ( void ) ) ;
 140 
static PTR(ECONST) READ_ptr_ec(void);
141 
#endif
 141 
#endif
142 
 
 142 
 
143 
#ifndef READ_ec
 143 
#ifndef READ_ec
144 
static ECONST READ_ec PROTO_S ( ( void ) ) ;
 144 
static ECONST READ_ec(void);
145 
#endif
 145 
#endif
146 
 
 146 
 
147 
#ifndef READ_STRUCTURE_P
 147 
#ifndef READ_STRUCTURE_P
148 
#define READ_STRUCTURE_P() READ_ptr_str()
 148 
#define READ_STRUCTURE_P() READ_ptr_str()
149 
#endif
 149 
#endif
150 
 
 150 
 
151 
#ifndef READ_ptr_str
 151 
#ifndef READ_ptr_str
152 
static PTR ( STRUCTURE ) READ_ptr_str PROTO_S ( ( void ) ) ;
 152 
static PTR(STRUCTURE) READ_ptr_str(void);
153 
#endif
 153 
#endif
154 
 
 154 
 
155 
#ifndef READ_str
 155 
#ifndef READ_str
156 
static STRUCTURE READ_str PROTO_S ( ( void ) ) ;
 156 
static STRUCTURE READ_str(void);
157 
#endif
 157 
#endif
158 
 
 158 
 
159 
#ifndef READ_list_ptr_cmp
 159 
#ifndef READ_list_ptr_cmp
160 
static LIST ( PTR ( COMPONENT ) ) READ_list_ptr_cmp PROTO_S ( ( void ) ) ;
 160 
static LIST(PTR(COMPONENT)) READ_list_ptr_cmp(void);
161 
#endif
 161 
#endif
162 
 
 162 
 
163 
#ifndef READ_list_COMPONENT_P
 163 
#ifndef READ_list_COMPONENT_P
164 
#define READ_list_COMPONENT_P() READ_list_ptr_cmp()
 164 
#define READ_list_COMPONENT_P() READ_list_ptr_cmp()
165 
#endif
 165 
#endif
Line 167... Line 167...
167 
#ifndef READ_COMPONENT_P
 167 
#ifndef READ_COMPONENT_P
168 
#define READ_COMPONENT_P() READ_ptr_cmp()
 168 
#define READ_COMPONENT_P() READ_ptr_cmp()
169 
#endif
 169 
#endif
170 
 
 170 
 
171 
#ifndef READ_ptr_cmp
 171 
#ifndef READ_ptr_cmp
172 
static PTR ( COMPONENT ) READ_ptr_cmp PROTO_S ( ( void ) ) ;
 172 
static PTR(COMPONENT) READ_ptr_cmp(void);
173 
#endif
 173 
#endif
174 
 
 174 
 
175 
#ifndef READ_cmp
 175 
#ifndef READ_cmp
176 
static COMPONENT READ_cmp PROTO_S ( ( void ) ) ;
 176 
static COMPONENT READ_cmp(void);
177 
#endif
 177 
#endif
178 
 
 178 
 
179 
#ifndef READ_UNION_P
 179 
#ifndef READ_UNION_P
180 
#define READ_UNION_P() READ_ptr_un()
 180 
#define READ_UNION_P() READ_ptr_un()
181 
#endif
 181 
#endif
182 
 
 182 
 
183 
#ifndef READ_ptr_un
 183 
#ifndef READ_ptr_un
184 
static PTR ( UNION ) READ_ptr_un PROTO_S ( ( void ) ) ;
 184 
static PTR(UNION) READ_ptr_un(void);
185 
#endif
 185 
#endif
186 
 
 186 
 
187 
#ifndef READ_un
 187 
#ifndef READ_un
188 
static UNION READ_un PROTO_S ( ( void ) ) ;
 188 
static UNION READ_un(void);
189 
#endif
 189 
#endif
190 
 
 190 
 
191 
#ifndef READ_list_ptr_fld
 191 
#ifndef READ_list_ptr_fld
192 
static LIST ( PTR ( FIELD ) ) READ_list_ptr_fld PROTO_S ( ( void ) ) ;
 192 
static LIST(PTR(FIELD)) READ_list_ptr_fld(void);
193 
#endif
 193 
#endif
194 
 
 194 
 
195 
#ifndef READ_list_FIELD_P
 195 
#ifndef READ_list_FIELD_P
196 
#define READ_list_FIELD_P() READ_list_ptr_fld()
 196 
#define READ_list_FIELD_P() READ_list_ptr_fld()
197 
#endif
 197 
#endif
Line 199... Line 199...
199 
#ifndef READ_FIELD_P
 199 
#ifndef READ_FIELD_P
200 
#define READ_FIELD_P() READ_ptr_fld()
 200 
#define READ_FIELD_P() READ_ptr_fld()
201 
#endif
 201 
#endif
202 
 
 202 
 
203 
#ifndef READ_ptr_fld
 203 
#ifndef READ_ptr_fld
204 
static PTR ( FIELD ) READ_ptr_fld PROTO_S ( ( void ) ) ;
 204 
static PTR(FIELD) READ_ptr_fld(void);
205 
#endif
 205 
#endif
206 
 
 206 
 
207 
#ifndef READ_fld
 207 
#ifndef READ_fld
208 
static FIELD READ_fld PROTO_S ( ( void ) ) ;
 208 
static FIELD READ_fld(void);
209 
#endif
 209 
#endif
210 
 
 210 
 
211 
#ifndef READ_list_ptr_map
 211 
#ifndef READ_list_ptr_map
212 
static LIST ( PTR ( MAP ) ) READ_list_ptr_map PROTO_S ( ( void ) ) ;
 212 
static LIST(PTR(MAP)) READ_list_ptr_map(void);
213 
#endif
 213 
#endif
214 
 
 214 
 
215 
#ifndef READ_list_MAP_P
 215 
#ifndef READ_list_MAP_P
216 
#define READ_list_MAP_P() READ_list_ptr_map()
 216 
#define READ_list_MAP_P() READ_list_ptr_map()
217 
#endif
 217 
#endif
Line 219... Line 219...
219 
#ifndef READ_MAP_P
 219 
#ifndef READ_MAP_P
220 
#define READ_MAP_P() READ_ptr_map()
 220 
#define READ_MAP_P() READ_ptr_map()
221 
#endif
 221 
#endif
222 
 
 222 
 
223 
#ifndef READ_ptr_map
 223 
#ifndef READ_ptr_map
224 
static PTR ( MAP ) READ_ptr_map PROTO_S ( ( void ) ) ;
 224 
static PTR(MAP) READ_ptr_map(void);
225 
#endif
 225 
#endif
226 
 
 226 
 
227 
#ifndef READ_map
 227 
#ifndef READ_map
228 
static MAP READ_map PROTO_S ( ( void ) ) ;
 228 
static MAP READ_map(void);
229 
#endif
 229 
#endif
230 
 
 230 
 
231 
#ifndef READ_list_ptr_arg
 231 
#ifndef READ_list_ptr_arg
232 
static LIST ( PTR ( ARGUMENT ) ) READ_list_ptr_arg PROTO_S ( ( void ) ) ;
 232 
static LIST(PTR(ARGUMENT)) READ_list_ptr_arg(void);
233 
#endif
 233 
#endif
234 
 
 234 
 
235 
#ifndef READ_list_ARGUMENT_P
 235 
#ifndef READ_list_ARGUMENT_P
236 
#define READ_list_ARGUMENT_P() READ_list_ptr_arg()
 236 
#define READ_list_ARGUMENT_P() READ_list_ptr_arg()
237 
#endif
 237 
#endif
Line 239... Line 239...
239 
#ifndef READ_ARGUMENT_P
 239 
#ifndef READ_ARGUMENT_P
240 
#define READ_ARGUMENT_P() READ_ptr_arg()
 240 
#define READ_ARGUMENT_P() READ_ptr_arg()
241 
#endif
 241 
#endif
242 
 
 242 
 
243 
#ifndef READ_ptr_arg
 243 
#ifndef READ_ptr_arg
244 
static PTR ( ARGUMENT ) READ_ptr_arg PROTO_S ( ( void ) ) ;
 244 
static PTR(ARGUMENT) READ_ptr_arg(void);
245 
#endif
 245 
#endif
246 
 
 246 
 
247 
#ifndef READ_arg
 247 
#ifndef READ_arg
248 
static ARGUMENT READ_arg PROTO_S ( ( void ) ) ;
 248 
static ARGUMENT READ_arg(void);
249 
#endif
 249 
#endif
250 
 
 250 
 
251 
 
 251 
 
252 
/* Disk reading routine for LIST ( PTR ( TYPE ) ) */
 252 
/* Disk reading routine for LIST(PTR(TYPE)) */
253 
 
 253 
 
254 
#ifndef READ_list_ptr_type
 254 
#ifndef READ_list_ptr_type
255 
 
 255 
 
256 
static LIST ( PTR ( TYPE ) ) READ_list_ptr_type
 256 
static LIST(PTR(TYPE)) READ_list_ptr_type
257 
    PROTO_Z ()
 257 
(void)
258 
{
 258 
{
259 
    LIST ( PTR ( TYPE ) ) x_ ;
 259 
    LIST(PTR(TYPE)) x_;
260 
    x_ = NULL_list ( PTR ( TYPE ) ) ;
 260 
    x_ = NULL_list(PTR(TYPE));
261 
    while ( READ_BITS ( 1 ) ) {
 261 
    while (READ_BITS(1)) {
262 
	PTR ( TYPE ) y_ ;
 262 
	PTR(TYPE) y_;
263 
	LIST ( PTR ( TYPE ) ) z_ ;
 263 
	LIST(PTR(TYPE)) z_;
264 
	y_ = READ_ptr_type () ;
 264 
	y_ = READ_ptr_type();
265 
	CONS_ptr ( y_, NULL_list ( PTR ( TYPE ) ), z_ ) ;
 265 
	CONS_ptr(y_, NULL_list(PTR(TYPE)), z_);
266 
	x_ = APPEND_list ( x_, z_ ) ;
 266 
	x_ = APPEND_list(x_, z_);
267 
    }
 267 
    }
268 
    return ( x_ ) ;
 268 
    return(x_);
269 
}
 269 
}
270 
 
 270 
 
271 
#endif
 271 
#endif
272 
 
 272 
 
273 
 
 273 
 
274 
/* Disk reading routine for TYPE */
 274 
/* Disk reading routine for TYPE */
275 
 
 275 
 
276 
#ifndef READ_type
 276 
#ifndef READ_type
277 
 
 277 
 
278 
static TYPE READ_type
 278 
static TYPE READ_type
279 
    PROTO_Z ()
 279 
(void)
280 
{
 280 
{
281 
    TYPE x_ ;
 281 
    TYPE x_;
282 
    x_ = NULL_type ;
 282 
    x_ = NULL_type;
283 
    if ( READ_BITS ( 1 ) == 1 ) {
 283 
    if (READ_BITS(1) == 1) {
284 
	zero_int size ;
 284 
	zero_int size;
285 
	unsigned tag_ = READ_BITS ( 4 ) ;
 285 
	unsigned tag_ = READ_BITS(4);
286 
	switch ( tag_ ) {
 286 
	switch (tag_) {
287 
	    case type_primitive_tag : {
 287 
	    case type_primitive_tag: {
288 
		PRIMITIVE_P prim ;
 288 
		PRIMITIVE_P prim;
289 
		unsigned alias_ = READ_ALIAS () ;
 289 
		unsigned alias_ = READ_ALIAS();
290 
		if ( READ_BITS ( 1 ) == 0 ) {
 290 
		if (READ_BITS(1) == 0) {
291 
		    x_ = FIND_ALIAS_type_primitive ( alias_ ) ;
 291 
		    x_ = FIND_ALIAS_type_primitive(alias_);
292 
		    break ;
 292 
		    break;
293 
		}
 293 
		}
294 
		NEW_ALIAS_type_primitive ( x_, alias_ ) ;
 294 
		NEW_ALIAS_type_primitive(x_, alias_);
295 
		size = READ_zero_int () ;
 295 
		size = READ_zero_int();
296 
		prim = READ_PRIMITIVE_P () ;
 296 
		prim = READ_PRIMITIVE_P();
297 
		COPY_int ( type_size ( x_ ), size ) ;
 297 
		COPY_int(type_size(x_), size);
298 
		COPY_ptr ( type_primitive_prim ( x_ ), prim ) ;
 298 
		COPY_ptr(type_primitive_prim(x_), prim);
299 
		break ;
 299 
		break;
300 
	    }
 300 
	    }
301 
	    case type_ident_tag : {
 301 
	    case type_ident_tag: {
302 
		IDENTITY_P id ;
 302 
		IDENTITY_P id;
303 
		unsigned alias_ = READ_ALIAS () ;
 303 
		unsigned alias_ = READ_ALIAS();
304 
		if ( READ_BITS ( 1 ) == 0 ) {
 304 
		if (READ_BITS(1) == 0) {
305 
		    x_ = FIND_ALIAS_type_ident ( alias_ ) ;
 305 
		    x_ = FIND_ALIAS_type_ident(alias_);
306 
		    break ;
 306 
		    break;
307 
		}
 307 
		}
308 
		NEW_ALIAS_type_ident ( x_, alias_ ) ;
 308 
		NEW_ALIAS_type_ident(x_, alias_);
309 
		size = READ_zero_int () ;
 309 
		size = READ_zero_int();
310 
		id = READ_IDENTITY_P () ;
 310 
		id = READ_IDENTITY_P();
311 
		COPY_int ( type_size ( x_ ), size ) ;
 311 
		COPY_int(type_size(x_), size);
312 
		COPY_ptr ( type_ident_id ( x_ ), id ) ;
 312 
		COPY_ptr(type_ident_id(x_), id);
313 
		break ;
 313 
		break;
314 
	    }
 314 
	    }
315 
	    case type_enumeration_tag : {
 315 
	    case type_enumeration_tag: {
316 
		ENUM_P en ;
 316 
		ENUM_P en;
317 
		unsigned alias_ = READ_ALIAS () ;
 317 
		unsigned alias_ = READ_ALIAS();
318 
		if ( READ_BITS ( 1 ) == 0 ) {
 318 
		if (READ_BITS(1) == 0) {
319 
		    x_ = FIND_ALIAS_type_enumeration ( alias_ ) ;
 319 
		    x_ = FIND_ALIAS_type_enumeration(alias_);
320 
		    break ;
 320 
		    break;
321 
		}
 321 
		}
322 
		NEW_ALIAS_type_enumeration ( x_, alias_ ) ;
 322 
		NEW_ALIAS_type_enumeration(x_, alias_);
323 
		size = READ_zero_int () ;
 323 
		size = READ_zero_int();
324 
		en = READ_ENUM_P () ;
 324 
		en = READ_ENUM_P();
325 
		COPY_int ( type_size ( x_ ), size ) ;
 325 
		COPY_int(type_size(x_), size);
326 
		COPY_ptr ( type_enumeration_en ( x_ ), en ) ;
 326 
		COPY_ptr(type_enumeration_en(x_), en);
327 
		break ;
 327 
		break;
328 
	    }
 328 
	    }
329 
	    case type_structure_tag : {
 329 
	    case type_structure_tag: {
330 
		STRUCTURE_P struc ;
 330 
		STRUCTURE_P struc;
331 
		unsigned alias_ = READ_ALIAS () ;
 331 
		unsigned alias_ = READ_ALIAS();
332 
		if ( READ_BITS ( 1 ) == 0 ) {
 332 
		if (READ_BITS(1) == 0) {
333 
		    x_ = FIND_ALIAS_type_structure ( alias_ ) ;
 333 
		    x_ = FIND_ALIAS_type_structure(alias_);
334 
		    break ;
 334 
		    break;
335 
		}
 335 
		}
336 
		NEW_ALIAS_type_structure ( x_, alias_ ) ;
 336 
		NEW_ALIAS_type_structure(x_, alias_);
337 
		size = READ_zero_int () ;
 337 
		size = READ_zero_int();
338 
		struc = READ_STRUCTURE_P () ;
 338 
		struc = READ_STRUCTURE_P();
339 
		COPY_int ( type_size ( x_ ), size ) ;
 339 
		COPY_int(type_size(x_), size);
340 
		COPY_ptr ( type_structure_struc ( x_ ), struc ) ;
 340 
		COPY_ptr(type_structure_struc(x_), struc);
341 
		break ;
 341 
		break;
342 
	    }
 342 
	    }
343 
	    case type_onion_tag : {
 343 
	    case type_onion_tag: {
344 
		UNION_P un ;
 344 
		UNION_P un;
345 
		unsigned alias_ = READ_ALIAS () ;
 345 
		unsigned alias_ = READ_ALIAS();
346 
		if ( READ_BITS ( 1 ) == 0 ) {
 346 
		if (READ_BITS(1) == 0) {
347 
		    x_ = FIND_ALIAS_type_onion ( alias_ ) ;
 347 
		    x_ = FIND_ALIAS_type_onion(alias_);
348 
		    break ;
 348 
		    break;
349 
		}
 349 
		}
350 
		NEW_ALIAS_type_onion ( x_, alias_ ) ;
 350 
		NEW_ALIAS_type_onion(x_, alias_);
351 
		size = READ_zero_int () ;
 351 
		size = READ_zero_int();
352 
		un = READ_UNION_P () ;
 352 
		un = READ_UNION_P();
353 
		COPY_int ( type_size ( x_ ), size ) ;
 353 
		COPY_int(type_size(x_), size);
354 
		COPY_ptr ( type_onion_un ( x_ ), un ) ;
 354 
		COPY_ptr(type_onion_un(x_), un);
355 
		break ;
 355 
		break;
356 
	    }
 356 
	    }
357 
	    case type_ptr_tag : {
 357 
	    case type_ptr_tag: {
358 
		TYPE_P sub ;
 358 
		TYPE_P sub;
359 
		unsigned alias_ = READ_ALIAS () ;
 359 
		unsigned alias_ = READ_ALIAS();
360 
		if ( READ_BITS ( 1 ) == 0 ) {
 360 
		if (READ_BITS(1) == 0) {
361 
		    x_ = FIND_ALIAS_type_ptr ( alias_ ) ;
 361 
		    x_ = FIND_ALIAS_type_ptr(alias_);
362 
		    break ;
 362 
		    break;
363 
		}
 363 
		}
364 
		NEW_ALIAS_type_ptr ( x_, alias_ ) ;
 364 
		NEW_ALIAS_type_ptr(x_, alias_);
365 
		size = READ_zero_int () ;
 365 
		size = READ_zero_int();
366 
		sub = READ_TYPE_P () ;
 366 
		sub = READ_TYPE_P();
367 
		COPY_int ( type_size ( x_ ), size ) ;
 367 
		COPY_int(type_size(x_), size);
368 
		COPY_ptr ( type_ptr_sub ( x_ ), sub ) ;
 368 
		COPY_ptr(type_ptr_sub(x_), sub);
369 
		break ;
 369 
		break;
370 
	    }
 370 
	    }
371 
	    case type_list_tag : {
 371 
	    case type_list_tag: {
372 
		TYPE_P sub ;
 372 
		TYPE_P sub;
373 
		unsigned alias_ = READ_ALIAS () ;
 373 
		unsigned alias_ = READ_ALIAS();
374 
		if ( READ_BITS ( 1 ) == 0 ) {
 374 
		if (READ_BITS(1) == 0) {
375 
		    x_ = FIND_ALIAS_type_list ( alias_ ) ;
 375 
		    x_ = FIND_ALIAS_type_list(alias_);
376 
		    break ;
 376 
		    break;
377 
		}
 377 
		}
378 
		NEW_ALIAS_type_list ( x_, alias_ ) ;
 378 
		NEW_ALIAS_type_list(x_, alias_);
379 
		size = READ_zero_int () ;
 379 
		size = READ_zero_int();
380 
		sub = READ_TYPE_P () ;
 380 
		sub = READ_TYPE_P();
381 
		COPY_int ( type_size ( x_ ), size ) ;
 381 
		COPY_int(type_size(x_), size);
382 
		COPY_ptr ( type_list_sub ( x_ ), sub ) ;
 382 
		COPY_ptr(type_list_sub(x_), sub);
383 
		break ;
 383 
		break;
384 
	    }
 384 
	    }
385 
	    case type_stack_tag : {
 385 
	    case type_stack_tag: {
386 
		TYPE_P sub ;
 386 
		TYPE_P sub;
387 
		unsigned alias_ = READ_ALIAS () ;
 387 
		unsigned alias_ = READ_ALIAS();
388 
		if ( READ_BITS ( 1 ) == 0 ) {
 388 
		if (READ_BITS(1) == 0) {
389 
		    x_ = FIND_ALIAS_type_stack ( alias_ ) ;
 389 
		    x_ = FIND_ALIAS_type_stack(alias_);
390 
		    break ;
 390 
		    break;
391 
		}
 391 
		}
392 
		NEW_ALIAS_type_stack ( x_, alias_ ) ;
 392 
		NEW_ALIAS_type_stack(x_, alias_);
393 
		size = READ_zero_int () ;
 393 
		size = READ_zero_int();
394 
		sub = READ_TYPE_P () ;
 394 
		sub = READ_TYPE_P();
395 
		COPY_int ( type_size ( x_ ), size ) ;
 395 
		COPY_int(type_size(x_), size);
396 
		COPY_ptr ( type_stack_sub ( x_ ), sub ) ;
 396 
		COPY_ptr(type_stack_sub(x_), sub);
397 
		break ;
 397 
		break;
398 
	    }
 398 
	    }
399 
	    case type_vec_tag : {
 399 
	    case type_vec_tag: {
400 
		TYPE_P sub ;
 400 
		TYPE_P sub;
401 
		unsigned alias_ = READ_ALIAS () ;
 401 
		unsigned alias_ = READ_ALIAS();
402 
		if ( READ_BITS ( 1 ) == 0 ) {
 402 
		if (READ_BITS(1) == 0) {
403 
		    x_ = FIND_ALIAS_type_vec ( alias_ ) ;
 403 
		    x_ = FIND_ALIAS_type_vec(alias_);
404 
		    break ;
 404 
		    break;
405 
		}
 405 
		}
406 
		NEW_ALIAS_type_vec ( x_, alias_ ) ;
 406 
		NEW_ALIAS_type_vec(x_, alias_);
407 
		size = READ_zero_int () ;
 407 
		size = READ_zero_int();
408 
		sub = READ_TYPE_P () ;
 408 
		sub = READ_TYPE_P();
409 
		COPY_int ( type_size ( x_ ), size ) ;
 409 
		COPY_int(type_size(x_), size);
410 
		COPY_ptr ( type_vec_sub ( x_ ), sub ) ;
 410 
		COPY_ptr(type_vec_sub(x_), sub);
411 
		break ;
 411 
		break;
412 
	    }
 412 
	    }
413 
	    case type_vec_ptr_tag : {
 413 
	    case type_vec_ptr_tag: {
414 
		TYPE_P sub ;
 414 
		TYPE_P sub;
415 
		unsigned alias_ = READ_ALIAS () ;
 415 
		unsigned alias_ = READ_ALIAS();
416 
		if ( READ_BITS ( 1 ) == 0 ) {
 416 
		if (READ_BITS(1) == 0) {
417 
		    x_ = FIND_ALIAS_type_vec_ptr ( alias_ ) ;
 417 
		    x_ = FIND_ALIAS_type_vec_ptr(alias_);
418 
		    break ;
 418 
		    break;
419 
		}
 419 
		}
420 
		NEW_ALIAS_type_vec_ptr ( x_, alias_ ) ;
 420 
		NEW_ALIAS_type_vec_ptr(x_, alias_);
421 
		size = READ_zero_int () ;
 421 
		size = READ_zero_int();
422 
		sub = READ_TYPE_P () ;
 422 
		sub = READ_TYPE_P();
423 
		COPY_int ( type_size ( x_ ), size ) ;
 423 
		COPY_int(type_size(x_), size);
424 
		COPY_ptr ( type_vec_ptr_sub ( x_ ), sub ) ;
 424 
		COPY_ptr(type_vec_ptr_sub(x_), sub);
425 
		break ;
 425 
		break;
426 
	    }
 426 
	    }
427 
	    case type_quote_tag : {
 427 
	    case type_quote_tag: {
428 
		string defn ;
 428 
		string defn;
429 
		size = READ_zero_int () ;
 429 
		size = READ_zero_int();
430 
		defn = READ_string () ;
 430 
		defn = READ_string();
431 
		MAKE_type_quote ( size, defn, x_ ) ;
 431 
		MAKE_type_quote(size, defn, x_ );
432 
		break ;
 432 
		break;
433 
	    }
 433 
	    }
434 
	    case type_undef_tag : {
 434 
	    case type_undef_tag: {
435 
		string name ;
 435 
		string name;
436 
		size = READ_zero_int () ;
 436 
		size = READ_zero_int();
437 
		name = READ_string () ;
 437 
		name = READ_string();
438 
		MAKE_type_undef ( size, name, x_ ) ;
 438 
		MAKE_type_undef(size, name, x_ );
439 
		break ;
 439 
		break;
440 
	    }
 440 
	    }
441 
	}
 441 
	}
442 
    }
 442 
    }
443 
    return ( x_ ) ;
 443 
    return(x_);
444 
}
 444 
}
445 
 
 445 
 
446 
#endif
 446 
#endif
447 
 
 447 
 
448 
 
 448 
 
449 
/* Disk reading routine for PTR ( PRIMITIVE ) */
 449 
/* Disk reading routine for PTR(PRIMITIVE) */
450 
 
 450 
 
451 
#ifndef READ_ptr_prim
 451 
#ifndef READ_ptr_prim
452 
 
 452 
 
453 
static PTR ( PRIMITIVE ) READ_ptr_prim
 453 
static PTR(PRIMITIVE) READ_ptr_prim
454 
    PROTO_Z ()
 454 
(void)
455 
{
 455 
{
456 
    PTR ( PRIMITIVE ) x_ ;
 456 
    PTR(PRIMITIVE) x_;
457 
    if ( READ_BITS ( 1 ) == 0 ) {
 457 
    if (READ_BITS(1) == 0) {
458 
	x_ = NULL_ptr ( PRIMITIVE ) ;
 458 
	x_ = NULL_ptr(PRIMITIVE);
459 
    } else {
 459 
    } else {
460 
	x_ = MAKE_ptr ( SIZE_prim ) ;
 460 
	x_ = MAKE_ptr(SIZE_prim);
461 
	COPY_prim ( x_, READ_prim () ) ;
 461 
	COPY_prim(x_, READ_prim());
462 
    }
 462 
    }
463 
    return ( x_ ) ;
 463 
    return(x_);
464 
}
 464 
}
465 
 
 465 
 
466 
#endif
 466 
#endif
467 
 
 467 
 
468 
 
 468 
 
469 
/* Disk reading routine for PRIMITIVE */
 469 
/* Disk reading routine for PRIMITIVE */
470 
 
 470 
 
471 
#ifndef READ_prim
 471 
#ifndef READ_prim
472 
 
 472 
 
473 
static PRIMITIVE READ_prim
 473 
static PRIMITIVE READ_prim
474 
    PROTO_Z ()
 474 
(void)
475 
{
 475 
{
476 
    PRIMITIVE x_ ;
 476 
    PRIMITIVE x_;
477 
    x_.id = READ_CLASS_ID_P () ;
 477 
    x_.id = READ_CLASS_ID_P();
478 
    x_.defn = READ_string () ;
 478 
    x_.defn = READ_string();
479 
    return ( x_ ) ;
 479 
    return(x_);
480 
}
 480 
}
481 
 
 481 
 
482 
#endif
 482 
#endif
483 
 
 483 
 
484 
 
 484 
 
485 
/* Disk reading routine for PTR ( CLASS_ID ) */
 485 
/* Disk reading routine for PTR(CLASS_ID) */
486 
 
 486 
 
487 
#ifndef READ_ptr_cid
 487 
#ifndef READ_ptr_cid
488 
 
 488 
 
489 
static PTR ( CLASS_ID ) READ_ptr_cid
 489 
static PTR(CLASS_ID) READ_ptr_cid
490 
    PROTO_Z ()
 490 
(void)
491 
{
 491 
{
492 
    PTR ( CLASS_ID ) x_ ;
 492 
    PTR(CLASS_ID) x_;
493 
    if ( READ_BITS ( 1 ) == 0 ) {
 493 
    if (READ_BITS(1) == 0) {
494 
	x_ = NULL_ptr ( CLASS_ID ) ;
 494 
	x_ = NULL_ptr(CLASS_ID);
495 
    } else {
 495 
    } else {
496 
	x_ = MAKE_ptr ( SIZE_cid ) ;
 496 
	x_ = MAKE_ptr(SIZE_cid);
497 
	COPY_cid ( x_, READ_cid () ) ;
 497 
	COPY_cid(x_, READ_cid());
498 
    }
 498 
    }
499 
    return ( x_ ) ;
 499 
    return(x_);
500 
}
 500 
}
501 
 
 501 
 
502 
#endif
 502 
#endif
503 
 
 503 
 
504 
 
 504 
 
505 
/* Disk reading routine for CLASS_ID */
 505 
/* Disk reading routine for CLASS_ID */
506 
 
 506 
 
507 
#ifndef READ_cid
 507 
#ifndef READ_cid
508 
 
 508 
 
509 
static CLASS_ID READ_cid
 509 
static CLASS_ID READ_cid
510 
    PROTO_Z ()
 510 
(void)
511 
{
 511 
{
512 
    CLASS_ID x_ ;
 512 
    CLASS_ID x_;
513 
    x_.name = READ_string () ;
 513 
    x_.name = READ_string();
514 
    x_.name_aux = READ_string () ;
 514 
    x_.name_aux = READ_string();
515 
    x_.flag = READ_int () ;
 515 
    x_.flag = READ_int();
516 
    x_.file = READ_name_string () ;
 516 
    x_.file = READ_name_string();
517 
    x_.line = READ_int () ;
 517 
    x_.line = READ_int();
518 
    return ( x_ ) ;
 518 
    return(x_);
519 
}
 519 
}
520 
 
 520 
 
521 
#endif
 521 
#endif
522 
 
 522 
 
523 
 
 523 
 
524 
/* Disk reading routine for PTR ( IDENTITY ) */
 524 
/* Disk reading routine for PTR(IDENTITY) */
525 
 
 525 
 
526 
#ifndef READ_ptr_ident
 526 
#ifndef READ_ptr_ident
527 
 
 527 
 
528 
static PTR ( IDENTITY ) READ_ptr_ident
 528 
static PTR(IDENTITY) READ_ptr_ident
529 
    PROTO_Z ()
 529 
(void)
530 
{
 530 
{
531 
    PTR ( IDENTITY ) x_ ;
 531 
    PTR(IDENTITY) x_;
532 
    if ( READ_BITS ( 1 ) == 0 ) {
 532 
    if (READ_BITS(1) == 0) {
533 
	x_ = NULL_ptr ( IDENTITY ) ;
 533 
	x_ = NULL_ptr(IDENTITY);
534 
    } else {
 534 
    } else {
535 
	x_ = MAKE_ptr ( SIZE_ident ) ;
 535 
	x_ = MAKE_ptr(SIZE_ident);
536 
	COPY_ident ( x_, READ_ident () ) ;
 536 
	COPY_ident(x_, READ_ident());
537 
    }
 537 
    }
538 
    return ( x_ ) ;
 538 
    return(x_);
539 
}
 539 
}
540 
 
 540 
 
541 
#endif
 541 
#endif
542 
 
 542 
 
543 
 
 543 
 
544 
/* Disk reading routine for IDENTITY */
 544 
/* Disk reading routine for IDENTITY */
545 
 
 545 
 
546 
#ifndef READ_ident
 546 
#ifndef READ_ident
547 
 
 547 
 
548 
static IDENTITY READ_ident
 548 
static IDENTITY READ_ident
549 
    PROTO_Z ()
 549 
(void)
550 
{
 550 
{
551 
    IDENTITY x_ ;
 551 
    IDENTITY x_;
552 
    x_.id = READ_CLASS_ID_P () ;
 552 
    x_.id = READ_CLASS_ID_P();
553 
    x_.defn = READ_TYPE_P () ;
 553 
    x_.defn = READ_TYPE_P();
554 
    return ( x_ ) ;
 554 
    return(x_);
555 
}
 555 
}
556 
 
 556 
 
557 
#endif
 557 
#endif
558 
 
 558 
 
559 
 
 559 
 
560 
/* Disk reading routine for PTR ( TYPE ) */
 560 
/* Disk reading routine for PTR(TYPE) */
561 
 
 561 
 
562 
#ifndef READ_ptr_type
 562 
#ifndef READ_ptr_type
563 
 
 563 
 
564 
static PTR ( TYPE ) READ_ptr_type
 564 
static PTR(TYPE) READ_ptr_type
565 
    PROTO_Z ()
 565 
(void)
566 
{
 566 
{
567 
    PTR ( TYPE ) x_ ;
 567 
    PTR(TYPE) x_;
568 
    if ( READ_BITS ( 1 ) == 0 ) {
 568 
    if (READ_BITS(1) == 0) {
569 
	x_ = NULL_ptr ( TYPE ) ;
 569 
	x_ = NULL_ptr(TYPE);
570 
    } else {
 570 
    } else {
571 
	x_ = MAKE_ptr ( SIZE_type ) ;
 571 
	x_ = MAKE_ptr(SIZE_type);
572 
	COPY_type ( x_, READ_type () ) ;
 572 
	COPY_type(x_, READ_type());
573 
    }
 573 
    }
574 
    return ( x_ ) ;
 574 
    return(x_);
575 
}
 575 
}
576 
 
 576 
 
577 
#endif
 577 
#endif
578 
 
 578 
 
579 
 
 579 
 
580 
/* Disk reading routine for PTR ( ENUM ) */
 580 
/* Disk reading routine for PTR(ENUM) */
581 
 
 581 
 
582 
#ifndef READ_ptr_en
 582 
#ifndef READ_ptr_en
583 
 
 583 
 
584 
static PTR ( ENUM ) READ_ptr_en
 584 
static PTR(ENUM) READ_ptr_en
585 
    PROTO_Z ()
 585 
(void)
586 
{
 586 
{
587 
    PTR ( ENUM ) x_ ;
 587 
    PTR(ENUM) x_;
588 
    if ( READ_BITS ( 1 ) == 0 ) {
 588 
    if (READ_BITS(1) == 0) {
589 
	x_ = NULL_ptr ( ENUM ) ;
 589 
	x_ = NULL_ptr(ENUM);
590 
    } else {
 590 
    } else {
591 
	x_ = MAKE_ptr ( SIZE_en ) ;
 591 
	x_ = MAKE_ptr(SIZE_en);
592 
	COPY_en ( x_, READ_en () ) ;
 592 
	COPY_en(x_, READ_en());
593 
    }
 593 
    }
594 
    return ( x_ ) ;
 594 
    return(x_);
595 
}
 595 
}
596 
 
 596 
 
597 
#endif
 597 
#endif
598 
 
 598 
 
599 
 
 599 
 
600 
/* Disk reading routine for ENUM */
 600 
/* Disk reading routine for ENUM */
601 
 
 601 
 
602 
#ifndef READ_en
 602 
#ifndef READ_en
603 
 
 603 
 
604 
static ENUM READ_en
 604 
static ENUM READ_en
605 
    PROTO_Z ()
 605 
(void)
606 
{
 606 
{
607 
    ENUM x_ ;
 607 
    ENUM x_;
608 
    x_.id = READ_CLASS_ID_P () ;
 608 
    x_.id = READ_CLASS_ID_P();
609 
    x_.consts = READ_list_ECONST_P () ;
 609 
    x_.consts = READ_list_ECONST_P();
610 
    x_.order = READ_number () ;
 610 
    x_.order = READ_number();
611 
    x_.lists = READ_int () ;
 611 
    x_.lists = READ_int();
612 
    return ( x_ ) ;
 612 
    return(x_);
613 
}
 613 
}
614 
 
 614 
 
615 
#endif
 615 
#endif
616 
 
 616 
 
617 
 
 617 
 
618 
/* Disk reading routine for LIST ( PTR ( ECONST ) ) */
 618 
/* Disk reading routine for LIST(PTR(ECONST)) */
619 
 
 619 
 
620 
#ifndef READ_list_ptr_ec
 620 
#ifndef READ_list_ptr_ec
621 
 
 621 
 
622 
static LIST ( PTR ( ECONST ) ) READ_list_ptr_ec
 622 
static LIST(PTR(ECONST)) READ_list_ptr_ec
623 
    PROTO_Z ()
 623 
(void)
624 
{
 624 
{
625 
    LIST ( PTR ( ECONST ) ) x_ ;
 625 
    LIST(PTR(ECONST)) x_;
626 
    x_ = NULL_list ( PTR ( ECONST ) ) ;
 626 
    x_ = NULL_list(PTR(ECONST));
627 
    while ( READ_BITS ( 1 ) ) {
 627 
    while (READ_BITS(1)) {
628 
	PTR ( ECONST ) y_ ;
 628 
	PTR(ECONST) y_;
629 
	LIST ( PTR ( ECONST ) ) z_ ;
 629 
	LIST(PTR(ECONST)) z_;
630 
	y_ = READ_ptr_ec () ;
 630 
	y_ = READ_ptr_ec();
631 
	CONS_ptr ( y_, NULL_list ( PTR ( ECONST ) ), z_ ) ;
 631 
	CONS_ptr(y_, NULL_list(PTR(ECONST)), z_);
632 
	x_ = APPEND_list ( x_, z_ ) ;
 632 
	x_ = APPEND_list(x_, z_);
633 
    }
 633 
    }
634 
    return ( x_ ) ;
 634 
    return(x_);
635 
}
 635 
}
636 
 
 636 
 
637 
#endif
 637 
#endif
638 
 
 638 
 
639 
 
 639 
 
640 
/* Disk reading routine for PTR ( ECONST ) */
 640 
/* Disk reading routine for PTR(ECONST) */
641 
 
 641 
 
642 
#ifndef READ_ptr_ec
 642 
#ifndef READ_ptr_ec
643 
 
 643 
 
644 
static PTR ( ECONST ) READ_ptr_ec
 644 
static PTR(ECONST) READ_ptr_ec
645 
    PROTO_Z ()
 645 
(void)
646 
{
 646 
{
647 
    PTR ( ECONST ) x_ ;
 647 
    PTR(ECONST) x_;
648 
    if ( READ_BITS ( 1 ) == 0 ) {
 648 
    if (READ_BITS(1) == 0) {
649 
	x_ = NULL_ptr ( ECONST ) ;
 649 
	x_ = NULL_ptr(ECONST);
650 
    } else {
 650 
    } else {
651 
	x_ = MAKE_ptr ( SIZE_ec ) ;
 651 
	x_ = MAKE_ptr(SIZE_ec);
652 
	COPY_ec ( x_, READ_ec () ) ;
 652 
	COPY_ec(x_, READ_ec());
653 
    }
 653 
    }
654 
    return ( x_ ) ;
 654 
    return(x_);
655 
}
 655 
}
656 
 
 656 
 
657 
#endif
 657 
#endif
658 
 
 658 
 
659 
 
 659 
 
660 
/* Disk reading routine for ECONST */
 660 
/* Disk reading routine for ECONST */
661 
 
 661 
 
662 
#ifndef READ_ec
 662 
#ifndef READ_ec
663 
 
 663 
 
664 
static ECONST READ_ec
 664 
static ECONST READ_ec
665 
    PROTO_Z ()
 665 
(void)
666 
{
 666 
{
667 
    ECONST x_ ;
 667 
    ECONST x_;
668 
    x_.name = READ_string () ;
 668 
    x_.name = READ_string();
669 
    x_.value = READ_number () ;
 669 
    x_.value = READ_number();
670 
    return ( x_ ) ;
 670 
    return(x_);
671 
}
 671 
}
672 
 
 672 
 
673 
#endif
 673 
#endif
674 
 
 674 
 
675 
 
 675 
 
676 
/* Disk reading routine for PTR ( STRUCTURE ) */
 676 
/* Disk reading routine for PTR(STRUCTURE) */
677 
 
 677 
 
678 
#ifndef READ_ptr_str
 678 
#ifndef READ_ptr_str
679 
 
 679 
 
680 
static PTR ( STRUCTURE ) READ_ptr_str
 680 
static PTR(STRUCTURE) READ_ptr_str
681 
    PROTO_Z ()
 681 
(void)
682 
{
 682 
{
683 
    PTR ( STRUCTURE ) x_ ;
 683 
    PTR(STRUCTURE) x_;
684 
    if ( READ_BITS ( 1 ) == 0 ) {
 684 
    if (READ_BITS(1) == 0) {
685 
	x_ = NULL_ptr ( STRUCTURE ) ;
 685 
	x_ = NULL_ptr(STRUCTURE);
686 
    } else {
 686 
    } else {
687 
	x_ = MAKE_ptr ( SIZE_str ) ;
 687 
	x_ = MAKE_ptr(SIZE_str);
688 
	COPY_str ( x_, READ_str () ) ;
 688 
	COPY_str(x_, READ_str());
689 
    }
 689 
    }
690 
    return ( x_ ) ;
 690 
    return(x_);
691 
}
 691 
}
692 
 
 692 
 
693 
#endif
 693 
#endif
694 
 
 694 
 
695 
 
 695 
 
696 
/* Disk reading routine for STRUCTURE */
 696 
/* Disk reading routine for STRUCTURE */
697 
 
 697 
 
698 
#ifndef READ_str
 698 
#ifndef READ_str
699 
 
 699 
 
700 
static STRUCTURE READ_str
 700 
static STRUCTURE READ_str
701 
    PROTO_Z ()
 701 
(void)
702 
{
 702 
{
703 
    STRUCTURE x_ ;
 703 
    STRUCTURE x_;
704 
    x_.id = READ_CLASS_ID_P () ;
 704 
    x_.id = READ_CLASS_ID_P();
705 
    x_.base = READ_STRUCTURE_P () ;
 705 
    x_.base = READ_STRUCTURE_P();
706 
    x_.defn = READ_list_COMPONENT_P () ;
 706 
    x_.defn = READ_list_COMPONENT_P();
707 
    x_.output = READ_zero_int () ;
 707 
    x_.output = READ_zero_int();
708 
    return ( x_ ) ;
 708 
    return(x_);
709 
}
 709 
}
710 
 
 710 
 
711 
#endif
 711 
#endif
712 
 
 712 
 
713 
 
 713 
 
714 
/* Disk reading routine for LIST ( PTR ( COMPONENT ) ) */
 714 
/* Disk reading routine for LIST(PTR(COMPONENT)) */
715 
 
 715 
 
716 
#ifndef READ_list_ptr_cmp
 716 
#ifndef READ_list_ptr_cmp
717 
 
 717 
 
718 
static LIST ( PTR ( COMPONENT ) ) READ_list_ptr_cmp
 718 
static LIST(PTR(COMPONENT)) READ_list_ptr_cmp
719 
    PROTO_Z ()
 719 
(void)
720 
{
 720 
{
721 
    LIST ( PTR ( COMPONENT ) ) x_ ;
 721 
    LIST(PTR(COMPONENT)) x_;
722 
    x_ = NULL_list ( PTR ( COMPONENT ) ) ;
 722 
    x_ = NULL_list(PTR(COMPONENT));
723 
    while ( READ_BITS ( 1 ) ) {
 723 
    while (READ_BITS(1)) {
724 
	PTR ( COMPONENT ) y_ ;
 724 
	PTR(COMPONENT) y_;
725 
	LIST ( PTR ( COMPONENT ) ) z_ ;
 725 
	LIST(PTR(COMPONENT)) z_;
726 
	y_ = READ_ptr_cmp () ;
 726 
	y_ = READ_ptr_cmp();
727 
	CONS_ptr ( y_, NULL_list ( PTR ( COMPONENT ) ), z_ ) ;
 727 
	CONS_ptr(y_, NULL_list(PTR(COMPONENT)), z_);
728 
	x_ = APPEND_list ( x_, z_ ) ;
 728 
	x_ = APPEND_list(x_, z_);
729 
    }
 729 
    }
730 
    return ( x_ ) ;
 730 
    return(x_);
731 
}
 731 
}
732 
 
 732 
 
733 
#endif
 733 
#endif
734 
 
 734 
 
735 
 
 735 
 
736 
/* Disk reading routine for PTR ( COMPONENT ) */
 736 
/* Disk reading routine for PTR(COMPONENT) */
737 
 
 737 
 
738 
#ifndef READ_ptr_cmp
 738 
#ifndef READ_ptr_cmp
739 
 
 739 
 
740 
static PTR ( COMPONENT ) READ_ptr_cmp
 740 
static PTR(COMPONENT) READ_ptr_cmp
741 
    PROTO_Z ()
 741 
(void)
742 
{
 742 
{
743 
    PTR ( COMPONENT ) x_ ;
 743 
    PTR(COMPONENT) x_;
744 
    if ( READ_BITS ( 1 ) == 0 ) {
 744 
    if (READ_BITS(1) == 0) {
745 
	x_ = NULL_ptr ( COMPONENT ) ;
 745 
	x_ = NULL_ptr(COMPONENT);
746 
    } else {
 746 
    } else {
747 
	x_ = MAKE_ptr ( SIZE_cmp ) ;
 747 
	x_ = MAKE_ptr(SIZE_cmp);
748 
	COPY_cmp ( x_, READ_cmp () ) ;
 748 
	COPY_cmp(x_, READ_cmp());
749 
    }
 749 
    }
750 
    return ( x_ ) ;
 750 
    return(x_);
751 
}
 751 
}
752 
 
 752 
 
753 
#endif
 753 
#endif
754 
 
 754 
 
755 
 
 755 
 
756 
/* Disk reading routine for COMPONENT */
 756 
/* Disk reading routine for COMPONENT */
757 
 
 757 
 
758 
#ifndef READ_cmp
 758 
#ifndef READ_cmp
759 
 
 759 
 
760 
static COMPONENT READ_cmp
 760 
static COMPONENT READ_cmp
761 
    PROTO_Z ()
 761 
(void)
762 
{
 762 
{
763 
    COMPONENT x_ ;
 763 
    COMPONENT x_;
764 
    x_.name = READ_string () ;
 764 
    x_.name = READ_string();
765 
    x_.type = READ_TYPE_P () ;
 765 
    x_.type = READ_TYPE_P();
766 
    x_.value = READ_string () ;
 766 
    x_.value = READ_string();
767 
    return ( x_ ) ;
 767 
    return(x_);
768 
}
 768 
}
769 
 
 769 
 
770 
#endif
 770 
#endif
771 
 
 771 
 
772 
 
 772 
 
773 
/* Disk reading routine for PTR ( UNION ) */
 773 
/* Disk reading routine for PTR(UNION) */
774 
 
 774 
 
775 
#ifndef READ_ptr_un
 775 
#ifndef READ_ptr_un
776 
 
 776 
 
777 
static PTR ( UNION ) READ_ptr_un
 777 
static PTR(UNION) READ_ptr_un
778 
    PROTO_Z ()
 778 
(void)
779 
{
 779 
{
780 
    PTR ( UNION ) x_ ;
 780 
    PTR(UNION) x_;
781 
    if ( READ_BITS ( 1 ) == 0 ) {
 781 
    if (READ_BITS(1) == 0) {
782 
	x_ = NULL_ptr ( UNION ) ;
 782 
	x_ = NULL_ptr(UNION);
783 
    } else {
 783 
    } else {
784 
	x_ = MAKE_ptr ( SIZE_un ) ;
 784 
	x_ = MAKE_ptr(SIZE_un);
785 
	COPY_un ( x_, READ_un () ) ;
 785 
	COPY_un(x_, READ_un());
786 
    }
 786 
    }
787 
    return ( x_ ) ;
 787 
    return(x_);
788 
}
 788 
}
789 
 
 789 
 
790 
#endif
 790 
#endif
791 
 
 791 
 
792 
 
 792 
 
793 
/* Disk reading routine for UNION */
 793 
/* Disk reading routine for UNION */
794 
 
 794 
 
795 
#ifndef READ_un
 795 
#ifndef READ_un
796 
 
 796 
 
797 
static UNION READ_un
 797 
static UNION READ_un
798 
    PROTO_Z ()
 798 
(void)
799 
{
 799 
{
800 
    UNION x_ ;
 800 
    UNION x_;
801 
    x_.id = READ_CLASS_ID_P () ;
 801 
    x_.id = READ_CLASS_ID_P();
802 
    x_.base = READ_UNION_P () ;
 802 
    x_.base = READ_UNION_P();
803 
    x_.s_defn = READ_list_COMPONENT_P () ;
 803 
    x_.s_defn = READ_list_COMPONENT_P();
804 
    x_.u_defn = READ_list_FIELD_P () ;
 804 
    x_.u_defn = READ_list_FIELD_P();
805 
    x_.map = READ_list_MAP_P () ;
 805 
    x_.map = READ_list_MAP_P();
806 
    x_.no_fields = READ_int () ;
 806 
    x_.no_fields = READ_int();
807 
    return ( x_ ) ;
 807 
    return(x_);
808 
}
 808 
}
809 
 
 809 
 
810 
#endif
 810 
#endif
811 
 
 811 
 
812 
 
 812 
 
813 
/* Disk reading routine for LIST ( PTR ( FIELD ) ) */
 813 
/* Disk reading routine for LIST(PTR(FIELD)) */
814 
 
 814 
 
815 
#ifndef READ_list_ptr_fld
 815 
#ifndef READ_list_ptr_fld
816 
 
 816 
 
817 
static LIST ( PTR ( FIELD ) ) READ_list_ptr_fld
 817 
static LIST(PTR(FIELD)) READ_list_ptr_fld
818 
    PROTO_Z ()
 818 
(void)
819 
{
 819 
{
820 
    LIST ( PTR ( FIELD ) ) x_ ;
 820 
    LIST(PTR(FIELD)) x_;
821 
    x_ = NULL_list ( PTR ( FIELD ) ) ;
 821 
    x_ = NULL_list(PTR(FIELD));
822 
    while ( READ_BITS ( 1 ) ) {
 822 
    while (READ_BITS(1)) {
823 
	PTR ( FIELD ) y_ ;
 823 
	PTR(FIELD) y_;
824 
	LIST ( PTR ( FIELD ) ) z_ ;
 824 
	LIST(PTR(FIELD)) z_;
825 
	y_ = READ_ptr_fld () ;
 825 
	y_ = READ_ptr_fld();
826 
	CONS_ptr ( y_, NULL_list ( PTR ( FIELD ) ), z_ ) ;
 826 
	CONS_ptr(y_, NULL_list(PTR(FIELD)), z_);
827 
	x_ = APPEND_list ( x_, z_ ) ;
 827 
	x_ = APPEND_list(x_, z_);
828 
    }
 828 
    }
829 
    return ( x_ ) ;
 829 
    return(x_);
830 
}
 830 
}
831 
 
 831 
 
832 
#endif
 832 
#endif
833 
 
 833 
 
834 
 
 834 
 
835 
/* Disk reading routine for PTR ( FIELD ) */
 835 
/* Disk reading routine for PTR(FIELD) */
836 
 
 836 
 
837 
#ifndef READ_ptr_fld
 837 
#ifndef READ_ptr_fld
838 
 
 838 
 
839 
static PTR ( FIELD ) READ_ptr_fld
 839 
static PTR(FIELD) READ_ptr_fld
840 
    PROTO_Z ()
 840 
(void)
841 
{
 841 
{
842 
    PTR ( FIELD ) x_ ;
 842 
    PTR(FIELD) x_;
843 
    if ( READ_BITS ( 1 ) == 0 ) {
 843 
    if (READ_BITS(1) == 0) {
844 
	x_ = NULL_ptr ( FIELD ) ;
 844 
	x_ = NULL_ptr(FIELD);
845 
    } else {
 845 
    } else {
846 
	x_ = MAKE_ptr ( SIZE_fld ) ;
 846 
	x_ = MAKE_ptr(SIZE_fld);
847 
	COPY_fld ( x_, READ_fld () ) ;
 847 
	COPY_fld(x_, READ_fld());
848 
    }
 848 
    }
849 
    return ( x_ ) ;
 849 
    return(x_);
850 
}
 850 
}
851 
 
 851 
 
852 
#endif
 852 
#endif
853 
 
 853 
 
854 
 
 854 
 
855 
/* Disk reading routine for FIELD */
 855 
/* Disk reading routine for FIELD */
856 
 
 856 
 
857 
#ifndef READ_fld
 857 
#ifndef READ_fld
858 
 
 858 
 
859 
static FIELD READ_fld
 859 
static FIELD READ_fld
860 
    PROTO_Z ()
 860 
(void)
861 
{
 861 
{
862 
    FIELD x_ ;
 862 
    FIELD x_;
863 
    x_.name = READ_string () ;
 863 
    x_.name = READ_string();
864 
    x_.tag = READ_int () ;
 864 
    x_.tag = READ_int();
865 
    x_.flag = READ_int () ;
 865 
    x_.flag = READ_int();
866 
    x_.set = READ_int () ;
 866 
    x_.set = READ_int();
867 
    x_.base = READ_FIELD_P () ;
 867 
    x_.base = READ_FIELD_P();
868 
    x_.defn = READ_list_COMPONENT_P () ;
 868 
    x_.defn = READ_list_COMPONENT_P();
869 
    return ( x_ ) ;
 869 
    return(x_);
870 
}
 870 
}
871 
 
 871 
 
872 
#endif
 872 
#endif
873 
 
 873 
 
874 
 
 874 
 
875 
/* Disk reading routine for LIST ( PTR ( MAP ) ) */
 875 
/* Disk reading routine for LIST(PTR(MAP)) */
876 
 
 876 
 
877 
#ifndef READ_list_ptr_map
 877 
#ifndef READ_list_ptr_map
878 
 
 878 
 
879 
static LIST ( PTR ( MAP ) ) READ_list_ptr_map
 879 
static LIST(PTR(MAP)) READ_list_ptr_map
880 
    PROTO_Z ()
 880 
(void)
881 
{
 881 
{
882 
    LIST ( PTR ( MAP ) ) x_ ;
 882 
    LIST(PTR(MAP)) x_;
883 
    x_ = NULL_list ( PTR ( MAP ) ) ;
 883 
    x_ = NULL_list(PTR(MAP));
884 
    while ( READ_BITS ( 1 ) ) {
 884 
    while (READ_BITS(1)) {
885 
	PTR ( MAP ) y_ ;
 885 
	PTR(MAP) y_;
886 
	LIST ( PTR ( MAP ) ) z_ ;
 886 
	LIST(PTR(MAP)) z_;
887 
	y_ = READ_ptr_map () ;
 887 
	y_ = READ_ptr_map();
888 
	CONS_ptr ( y_, NULL_list ( PTR ( MAP ) ), z_ ) ;
 888 
	CONS_ptr(y_, NULL_list(PTR(MAP)), z_);
889 
	x_ = APPEND_list ( x_, z_ ) ;
 889 
	x_ = APPEND_list(x_, z_);
890 
    }
 890 
    }
891 
    return ( x_ ) ;
 891 
    return(x_);
892 
}
 892 
}
893 
 
 893 
 
894 
#endif
 894 
#endif
895 
 
 895 
 
896 
 
 896 
 
897 
/* Disk reading routine for PTR ( MAP ) */
 897 
/* Disk reading routine for PTR(MAP) */
898 
 
 898 
 
899 
#ifndef READ_ptr_map
 899 
#ifndef READ_ptr_map
900 
 
 900 
 
901 
static PTR ( MAP ) READ_ptr_map
 901 
static PTR(MAP) READ_ptr_map
902 
    PROTO_Z ()
 902 
(void)
903 
{
 903 
{
904 
    PTR ( MAP ) x_ ;
 904 
    PTR(MAP) x_;
905 
    if ( READ_BITS ( 1 ) == 0 ) {
 905 
    if (READ_BITS(1) == 0) {
906 
	x_ = NULL_ptr ( MAP ) ;
 906 
	x_ = NULL_ptr(MAP);
907 
    } else {
 907 
    } else {
908 
	x_ = MAKE_ptr ( SIZE_map ) ;
 908 
	x_ = MAKE_ptr(SIZE_map);
909 
	COPY_map ( x_, READ_map () ) ;
 909 
	COPY_map(x_, READ_map());
910 
    }
 910 
    }
911 
    return ( x_ ) ;
 911 
    return(x_);
912 
}
 912 
}
913 
 
 913 
 
914 
#endif
 914 
#endif
915 
 
 915 
 
916 
 
 916 
 
917 
/* Disk reading routine for MAP */
 917 
/* Disk reading routine for MAP */
918 
 
 918 
 
919 
#ifndef READ_map
 919 
#ifndef READ_map
920 
 
 920 
 
921 
static MAP READ_map
 921 
static MAP READ_map
922 
    PROTO_Z ()
 922 
(void)
923 
{
 923 
{
924 
    MAP x_ ;
 924 
    MAP x_;
925 
    x_.name = READ_string () ;
 925 
    x_.name = READ_string();
926 
    x_.flag = READ_int () ;
 926 
    x_.flag = READ_int();
927 
    x_.ret_type = READ_TYPE_P () ;
 927 
    x_.ret_type = READ_TYPE_P();
928 
    x_.args = READ_list_ARGUMENT_P () ;
 928 
    x_.args = READ_list_ARGUMENT_P();
929 
    return ( x_ ) ;
 929 
    return(x_);
930 
}
 930 
}
931 
 
 931 
 
932 
#endif
 932 
#endif
933 
 
 933 
 
934 
 
 934 
 
935 
/* Disk reading routine for LIST ( PTR ( ARGUMENT ) ) */
 935 
/* Disk reading routine for LIST(PTR(ARGUMENT)) */
936 
 
 936 
 
937 
#ifndef READ_list_ptr_arg
 937 
#ifndef READ_list_ptr_arg
938 
 
 938 
 
939 
static LIST ( PTR ( ARGUMENT ) ) READ_list_ptr_arg
 939 
static LIST(PTR(ARGUMENT)) READ_list_ptr_arg
940 
    PROTO_Z ()
 940 
(void)
941 
{
 941 
{
942 
    LIST ( PTR ( ARGUMENT ) ) x_ ;
 942 
    LIST(PTR(ARGUMENT)) x_;
943 
    x_ = NULL_list ( PTR ( ARGUMENT ) ) ;
 943 
    x_ = NULL_list(PTR(ARGUMENT));
944 
    while ( READ_BITS ( 1 ) ) {
 944 
    while (READ_BITS(1)) {
945 
	PTR ( ARGUMENT ) y_ ;
 945 
	PTR(ARGUMENT) y_;
946 
	LIST ( PTR ( ARGUMENT ) ) z_ ;
 946 
	LIST(PTR(ARGUMENT)) z_;
947 
	y_ = READ_ptr_arg () ;
 947 
	y_ = READ_ptr_arg();
948 
	CONS_ptr ( y_, NULL_list ( PTR ( ARGUMENT ) ), z_ ) ;
 948 
	CONS_ptr(y_, NULL_list(PTR(ARGUMENT)), z_);
949 
	x_ = APPEND_list ( x_, z_ ) ;
 949 
	x_ = APPEND_list(x_, z_);
950 
    }
 950 
    }
951 
    return ( x_ ) ;
 951 
    return(x_);
952 
}
 952 
}
953 
 
 953 
 
954 
#endif
 954 
#endif
955 
 
 955 
 
956 
 
 956 
 
957 
/* Disk reading routine for PTR ( ARGUMENT ) */
 957 
/* Disk reading routine for PTR(ARGUMENT) */
958 
 
 958 
 
959 
#ifndef READ_ptr_arg
 959 
#ifndef READ_ptr_arg
960 
 
 960 
 
961 
static PTR ( ARGUMENT ) READ_ptr_arg
 961 
static PTR(ARGUMENT) READ_ptr_arg
962 
    PROTO_Z ()
 962 
(void)
963 
{
 963 
{
964 
    PTR ( ARGUMENT ) x_ ;
 964 
    PTR(ARGUMENT) x_;
965 
    if ( READ_BITS ( 1 ) == 0 ) {
 965 
    if (READ_BITS(1) == 0) {
966 
	x_ = NULL_ptr ( ARGUMENT ) ;
 966 
	x_ = NULL_ptr(ARGUMENT);
967 
    } else {
 967 
    } else {
968 
	x_ = MAKE_ptr ( SIZE_arg ) ;
 968 
	x_ = MAKE_ptr(SIZE_arg);
969 
	COPY_arg ( x_, READ_arg () ) ;
 969 
	COPY_arg(x_, READ_arg());
970 
    }
 970 
    }
971 
    return ( x_ ) ;
 971 
    return(x_);
972 
}
 972 
}
973 
 
 973 
 
974 
#endif
 974 
#endif
975 
 
 975 
 
976 
 
 976 
 
977 
/* Disk reading routine for ARGUMENT */
 977 
/* Disk reading routine for ARGUMENT */
978 
 
 978 
 
979 
#ifndef READ_arg
 979 
#ifndef READ_arg
980 
 
 980 
 
981 
static ARGUMENT READ_arg
 981 
static ARGUMENT READ_arg
982 
    PROTO_Z ()
 982 
(void)
983 
{
 983 
{
984 
    ARGUMENT x_ ;
 984 
    ARGUMENT x_;
985 
    x_.name = READ_string () ;
 985 
    x_.name = READ_string();
986 
    x_.type = READ_TYPE_P () ;
 986 
    x_.type = READ_TYPE_P();
987 
    return ( x_ ) ;
 987 
    return(x_);
988 
}
 988 
}
989 
 
 989 
 
990 
#endif
 990 
#endif
991 
 
 991 
 
992 
 
 992