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 42... Line 42...
42 
#define c_class_IMPLEMENTATION		0
 42 
#define c_class_IMPLEMENTATION		0
43 
#endif
 43 
#endif
44 
 
 44 
 
45 
 
 45 
 
46 
/* Prototype macros */
 46 
/* Prototype macros */
47 
 
 - 
 
48 
#ifndef PROTO_S
 - 
 
49 
#ifdef __STDC__
 - 
 
50 
#define PROTO_S( types )		types
 - 
 
51 
#define PROTO_N( names )
 - 
 
52 
#define PROTO_T( parms )		( parms )
 - 
 
53 
#define PROTO_Z()			( void )
 - 
 
54 
#define X				,
 - 
 
55 
#else
 - 
 
56 
#define PROTO_S( types )		()
 - 
 
57 
#define PROTO_N( names )		names
 - 
 
58 
#define PROTO_T( parms )		parms ;
 - 
 
59 
#define PROTO_Z()			()
 - 
 
60 
#define X				;
 - 
 
61 
#endif
 - 
 
62 
#endif
 - 
 
63 
 
 47 
 
64 
#ifndef CONST_S
 48 
#ifndef CONST_S
65 
#define CONST_S
 49 
#define CONST_S
66 
#endif
 50 
#endif
67 
 
 51 
 
68 
 
 52 
 
69 
/* Primitive types */
 53 
/* Primitive types */
70 
 
 54 
 
71 
typedef character * string ;
 55 
typedef character * string;
72 
typedef unsigned long ulong_type ;
 56 
typedef unsigned long ulong_type;
73 
typedef struct bits_tag * BITSTREAM_P ;
 57 
typedef struct bits_tag * BITSTREAM_P;
74 
typedef struct pptok_tag * PPTOKEN_P ;
 58 
typedef struct pptok_tag * PPTOKEN_P;
75 
 
 59 
 
76 
 
 60 
 
77 
/* Basic types */
 61 
/* Basic types */
78 
 
 62 
 
79 
#ifndef c_class_DESTR_DEFINED
 63 
#ifndef c_class_DESTR_DEFINED
80 
#define c_class_DESTR_DEFINED
 64 
#define c_class_DESTR_DEFINED
81 
typedef void ( *DESTROYER ) () ;
 65 
typedef void (*DESTROYER)();
82 
#endif
 66 
#endif
83 
 
 67 
 
84 
#pragma token PROC ( TYPE ) TYPE PTR #
 68 
#pragma token PROC(TYPE) TYPE PTR #
85 
#pragma token PROC ( TYPE ) TYPE LIST #
 69 
#pragma token PROC(TYPE) TYPE LIST #
86 
#pragma token PROC ( TYPE ) TYPE STACK #
 70 
#pragma token PROC(TYPE) TYPE STACK #
87 
#pragma token PROC ( TYPE ) TYPE SIZE #
 71 
#pragma token PROC(TYPE) TYPE SIZE #
88 
 
 72 
 
89 
#pragma interface PTR LIST STACK SIZE
 73 
#pragma interface PTR LIST STACK SIZE
90 
 
 74 
 
91 
 
 75 
 
92 
/* Enumeration type definitions */
 76 
/* Enumeration type definitions */
Line 153... Line 137...
153 
#pragma interface ERROR
 137 
#pragma interface ERROR
154 
 
 138 
 
155 
 
 139 
 
156 
/* Structure declarations */
 140 
/* Structure declarations */
157 
 
 141 
 
158 
typedef struct var_tag VARIABLE ;
 142 
typedef struct var_tag VARIABLE;
159 
typedef struct loc_tag LOCATION ;
 143 
typedef struct loc_tag LOCATION;
160 
typedef struct posn_tag POSITION ;
 144 
typedef struct posn_tag POSITION;
161 
 
 145 
 
162 
 
 146 
 
163 
/* Identity type definitions */
 147 
/* Identity type definitions */
164 
 
 148 
 
165 
 
 149 
 
Line 168... Line 152...
168 
 
 152 
 
169 
#ifndef c_class_STRUCT_DEFINED
 153 
#ifndef c_class_STRUCT_DEFINED
170 
#define c_class_STRUCT_DEFINED
 154 
#define c_class_STRUCT_DEFINED
171 
 
 155 
 
172 
struct var_tag {
 156 
struct var_tag {
173 
    IDENTIFIER id ;
 157 
    IDENTIFIER id;
174 
    DECL_SPEC info ;
 158 
    DECL_SPEC info;
175 
} ;
 159 
};
176 
 
 160 
 
177 
struct loc_tag {
 161 
struct loc_tag {
178 
    ulong_type line ;
 162 
    ulong_type line;
179 
    ulong_type column ;
 163 
    ulong_type column;
180 
    PTR ( POSITION ) posn ;
 164 
    PTR(POSITION) posn;
181 
} ;
 165 
};
182 
 
 166 
 
183 
struct posn_tag {
 167 
struct posn_tag {
184 
    string file ;
 168 
    string file;
185 
    string input ;
 169 
    string input;
186 
    string base ;
 170 
    string base;
187 
    string dir ;
 171 
    string dir;
188 
    ulong_type offset ;
 172 
    ulong_type offset;
189 
    PTR ( LOCATION ) from ;
 173 
    PTR(LOCATION) from;
190 
    ulong_type datestamp ;
 174 
    ulong_type datestamp;
191 
    ulong_type tok ;
 175 
    ulong_type tok;
192 
} ;
 176 
};
193 
 
 177 
 
194 
#endif /* c_class_STRUCT_DEFINED */
 178 
#endif /* c_class_STRUCT_DEFINED */
195 
 
 179 
 
196 
 
 180 
 
197 
/* Function declarations */
 181 
/* Function declarations */
198 
 
 182 
 
199 
extern void destroy_c_class () ;
 183 
extern void destroy_c_class();
200 
extern void dummy_destroy_c_class () ;
 184 
extern void dummy_destroy_c_class();
201 
#ifdef c_class_IO_ROUTINES
 185 
#ifdef c_class_IO_ROUTINES
202 
extern unsigned crt_c_class_alias ;
 186 
extern unsigned crt_c_class_alias;
203 
extern void clear_c_class_alias PROTO_S ( ( void ) ) ;
 187 
extern void clear_c_class_alias(void);
204 
#endif
 188 
#endif
205 
 
 189 
 
206 
 
 190 
 
207 
/* Pointer token specifications */
 191 
/* Pointer token specifications */
208 
 
 192 
 
209 
#pragma token PROC {\
 193 
#pragma token PROC {\
210 
	TYPE t, EXP : PTR ( t ) : e1, EXP : SIZE ( t ) : e2 |\
 194 
	TYPE t, EXP : PTR(t) : e1, EXP : SIZE(t) : e2 |\
211 
	EXP e1, EXP e2\
 195 
	EXP e1, EXP e2\
212 
    } EXP : PTR ( t ) : STEP_ptr #
 196 
    } EXP : PTR(t) : STEP_ptr #
213 
 
 197 
 
214 
#pragma token PROC (\
 198 
#pragma token PROC(\
215 
	TYPE t\
 199 
	TYPE t\
216 
    ) EXP const : PTR ( t ) : NULL_ptr #
 200 
    ) EXP const : PTR(t) : NULL_ptr #
217 
 
 201 
 
218 
#pragma token PROC {\
 202 
#pragma token PROC {\
219 
	TYPE t, EXP : PTR ( t ) : e |\
 203 
	TYPE t, EXP : PTR(t) : e |\
220 
	EXP e\
 204 
	EXP e\
221 
    } EXP : int : IS_NULL_ptr #
 205 
    } EXP : int : IS_NULL_ptr #
222 
 
 206 
 
223 
#pragma token PROC {\
 207 
#pragma token PROC {\
224 
	TYPE t, EXP : PTR ( t ) : e1, EXP : PTR ( t ) : e2 |\
 208 
	TYPE t, EXP : PTR(t) : e1, EXP : PTR(t) : e2 |\
225 
	EXP e1, EXP e2\
 209 
	EXP e1, EXP e2\
226 
    } EXP : int : EQ_ptr #
 210 
    } EXP : int : EQ_ptr #
227 
 
 211 
 
228 
#pragma token PROC {\
 212 
#pragma token PROC {\
229 
	TYPE t, EXP : SIZE ( t ) : e |\
 213 
	TYPE t, EXP : SIZE(t) : e |\
230 
	EXP e\
 214 
	EXP e\
231 
    } EXP : PTR ( t ) : MAKE_ptr #
 215 
    } EXP : PTR(t) : MAKE_ptr #
232 
 
 216 
 
233 
#pragma token PROC {\
 217 
#pragma token PROC {\
234 
	TYPE t, EXP : PTR ( t ) : e1, EXP : SIZE ( t ) : e2 |\
 218 
	TYPE t, EXP : PTR(t) : e1, EXP : SIZE(t) : e2 |\
235 
	EXP e1, EXP e2\
 219 
	EXP e1, EXP e2\
236 
    } EXP : void : DESTROY_ptr #
 220 
    } EXP : void : DESTROY_ptr #
237 
 
 221 
 
238 
#pragma token PROC (\
 222 
#pragma token PROC(\
239 
	TYPE t\
 223 
	TYPE t\
240 
    ) EXP : PTR ( t ) : UNIQ_ptr #
 224 
    ) EXP : PTR(t) : UNIQ_ptr #
241 
 
 225 
 
242 
#pragma token PROC {\
 226 
#pragma token PROC {\
243 
	TYPE t, EXP : PTR ( t ) : e |\
 227 
	TYPE t, EXP : PTR(t) : e |\
244 
	EXP e\
 228 
	EXP e\
245 
    } EXP : void : DESTROY_UNIQ_ptr #
 229 
    } EXP : void : DESTROY_UNIQ_ptr #
246 
 
 230 
 
247 
#pragma interface STEP_ptr NULL_ptr IS_NULL_ptr EQ_ptr
 231 
#pragma interface STEP_ptr NULL_ptr IS_NULL_ptr EQ_ptr
248 
#pragma interface MAKE_ptr DESTROY_ptr
 232 
#pragma interface MAKE_ptr DESTROY_ptr
249 
 
 233 
 
250 
#ifdef c_class_IO_ROUTINES
 234 
#ifdef c_class_IO_ROUTINES
251 
#pragma token PROC {\
 235 
#pragma token PROC {\
252 
	TYPE t, EXP : PTR ( t ) : e |\
 236 
	TYPE t, EXP : PTR(t) : e |\
253 
	EXP e\
 237 
	EXP e\
254 
    } EXP : void * : VOIDSTAR_ptr #
 238 
    } EXP : void * : VOIDSTAR_ptr #
255 
#pragma interface VOIDSTAR_ptr
 239 
#pragma interface VOIDSTAR_ptr
256 
#endif
 240 
#endif
257 
 
 241 
 
258 
#pragma token PROC (\
 242 
#pragma token PROC(\
259 
	TYPE t\
 243 
	TYPE t\
260 
    ) EXP const : SIZE ( PTR ( t ) ) : SIZE_ptr #
 244 
    ) EXP const : SIZE(PTR(t)) : SIZE_ptr #
261 
 
 245 
 
262 
#pragma token PROC {\
 246 
#pragma token PROC {\
263 
	TYPE t, EXP : PTR ( PTR ( t ) ) : e1,\
 247 
	TYPE t, EXP : PTR(PTR(t)) : e1,\
264 
	EXP : PTR ( t ) : e2 |\
 248 
	EXP : PTR(t) : e2 |\
265 
	EXP e1, EXP e2\
 249 
	EXP e1, EXP e2\
266 
    } EXP : void : COPY_ptr #
 250 
    } EXP : void : COPY_ptr #
267 
 
 251 
 
268 
#pragma token PROC {\
 252 
#pragma token PROC {\
269 
	TYPE t, EXP : PTR ( PTR ( t ) ) : e |\
 253 
	TYPE t, EXP : PTR(PTR(t)) : e |\
270 
	EXP e\
 254 
	EXP e\
271 
    } EXP : PTR ( t ) : DEREF_ptr #
 255 
    } EXP : PTR(t) : DEREF_ptr #
272 
 
 256 
 
273 
#pragma token PROC {\
 257 
#pragma token PROC {\
274 
	TYPE t, EXP : PTR ( t ) : e2,\
 258 
	TYPE t, EXP : PTR(t) : e2,\
275 
	EXP : LIST ( PTR ( t ) ) : e3,\
 259 
	EXP : LIST(PTR(t)) : e3,\
276 
	EXP lvalue : LIST ( PTR ( t ) ) : e4 |\
 260 
	EXP lvalue : LIST(PTR(t)) : e4 |\
277 
	EXP e2, EXP e3, EXP e4\
 261 
	EXP e2, EXP e3, EXP e4\
278 
    } STATEMENT CONS_ptr #
 262 
    } STATEMENT CONS_ptr #
279 
 
 263 
 
280 
#pragma token PROC {\
 264 
#pragma token PROC {\
281 
	TYPE t, EXP lvalue : PTR ( t ) : e2,\
 265 
	TYPE t, EXP lvalue : PTR(t) : e2,\
282 
	EXP lvalue : LIST ( PTR ( t ) ) : e3,\
 266 
	EXP lvalue : LIST(PTR(t)) : e3,\
283 
	EXP : LIST ( PTR ( t ) ) : e4 |\
 267 
	EXP : LIST(PTR(t)) : e4 |\
284 
	EXP e2, EXP e3, EXP e4\
 268 
	EXP e2, EXP e3, EXP e4\
285 
    } STATEMENT UN_CONS_ptr #
 269 
    } STATEMENT UN_CONS_ptr #
286 
 
 270 
 
287 
#pragma token PROC {\
 271 
#pragma token PROC {\
288 
	TYPE t, EXP : DESTROYER : e1,\
 272 
	TYPE t, EXP : DESTROYER : e1,\
289 
	EXP lvalue : PTR ( t ) : e2,\
 273 
	EXP lvalue : PTR(t) : e2,\
290 
	EXP lvalue : LIST ( PTR ( t ) ) : e3,\
 274 
	EXP lvalue : LIST(PTR(t)) : e3,\
291 
	EXP : LIST ( PTR ( t ) ) : e4 |\
 275 
	EXP : LIST(PTR(t)) : e4 |\
292 
	EXP e1, EXP e2, EXP e3, EXP e4\
 276 
	EXP e1, EXP e2, EXP e3, EXP e4\
293 
    } STATEMENT DESTROY_CONS_ptr #
 277 
    } STATEMENT DESTROY_CONS_ptr #
294 
 
 278 
 
295 
#pragma token PROC {\
 279 
#pragma token PROC {\
296 
	TYPE t, EXP : PTR ( t ) : e2,\
 280 
	TYPE t, EXP : PTR(t) : e2,\
297 
	EXP lvalue : STACK ( PTR ( t ) ) : e3 |\
 281 
	EXP lvalue : STACK(PTR(t)) : e3 |\
298 
	EXP e2, EXP e3\
 282 
	EXP e2, EXP e3\
299 
    } STATEMENT PUSH_ptr #
 283 
    } STATEMENT PUSH_ptr #
300 
 
 284 
 
301 
#pragma token PROC {\
 285 
#pragma token PROC {\
302 
	TYPE t, EXP lvalue : PTR ( t ) : e2,\
 286 
	TYPE t, EXP lvalue : PTR(t) : e2,\
303 
	EXP lvalue : STACK ( PTR ( t ) ) : e3 |\
 287 
	EXP lvalue : STACK(PTR(t)) : e3 |\
304 
	EXP e2, EXP e3\
 288 
	EXP e2, EXP e3\
305 
    } STATEMENT POP_ptr #
 289 
    } STATEMENT POP_ptr #
306 
 
 290 
 
307 
#pragma interface SIZE_ptr COPY_ptr DEREF_ptr
 291 
#pragma interface SIZE_ptr COPY_ptr DEREF_ptr
308 
#pragma interface CONS_ptr UN_CONS_ptr DESTROY_CONS_ptr
 292 
#pragma interface CONS_ptr UN_CONS_ptr DESTROY_CONS_ptr
Line 310... Line 294...
310 
 
 294 
 
311 
 
 295 
 
312 
/* List token specifications */
 296 
/* List token specifications */
313 
 
 297 
 
314 
#pragma token PROC {\
 298 
#pragma token PROC {\
315 
	TYPE t, EXP : LIST ( t ) : e |\
 299 
	TYPE t, EXP : LIST(t) : e |\
316 
	EXP e\
 300 
	EXP e\
317 
    } EXP : PTR ( t ) : HEAD_list #
 301 
    } EXP : PTR(t) : HEAD_list #
318 
 
 302 
 
319 
#pragma token PROC {\
 303 
#pragma token PROC {\
320 
	TYPE t, EXP : LIST ( t ) : e |\
 304 
	TYPE t, EXP : LIST(t) : e |\
321 
	EXP e\
 305 
	EXP e\
322 
    } EXP : PTR ( LIST ( t ) ) : PTR_TAIL_list #
 306 
    } EXP : PTR(LIST(t)) : PTR_TAIL_list #
323 
 
 307 
 
324 
#pragma token PROC {\
 308 
#pragma token PROC {\
325 
	TYPE t, EXP : LIST ( t ) : e |\
 309 
	TYPE t, EXP : LIST(t) : e |\
326 
	EXP e\
 310 
	EXP e\
327 
    } EXP : LIST ( t ) : TAIL_list #
 311 
    } EXP : LIST(t) : TAIL_list #
328 
 
 312 
 
329 
#pragma token PROC {\
 313 
#pragma token PROC {\
330 
	TYPE t, EXP : LIST ( t ) : e1 |\
 314 
	TYPE t, EXP : LIST(t) : e1 |\
331 
	EXP e1\
 315 
	EXP e1\
332 
    } EXP : unsigned : LENGTH_list #
 316 
    } EXP : unsigned : LENGTH_list #
333 
 
 317 
 
334 
#pragma token PROC {\
 318 
#pragma token PROC {\
335 
	TYPE t, EXP : LIST ( t ) : e1 |\
 319 
	TYPE t, EXP : LIST(t) : e1 |\
336 
	EXP e1\
 320 
	EXP e1\
337 
    } EXP : LIST ( t ) : END_list #
 321 
    } EXP : LIST(t) : END_list #
338 
 
 322 
 
339 
#pragma token PROC {\
 323 
#pragma token PROC {\
340 
	TYPE t, EXP : LIST ( t ) : e1 |\
 324 
	TYPE t, EXP : LIST(t) : e1 |\
341 
	EXP e1\
 325 
	EXP e1\
342 
    } EXP : LIST ( t ) : REVERSE_list #
 326 
    } EXP : LIST(t) : REVERSE_list #
343 
 
 327 
 
344 
#pragma token PROC {\
 328 
#pragma token PROC {\
345 
	TYPE t, EXP : LIST ( t ) : e1, EXP : LIST ( t ) : e2 |\
 329 
	TYPE t, EXP : LIST(t) : e1, EXP : LIST(t) : e2 |\
346 
	EXP e1, EXP e2\
 330 
	EXP e1, EXP e2\
347 
    } EXP : LIST ( t ) : APPEND_list #
 331 
    } EXP : LIST(t) : APPEND_list #
348 
 
 332 
 
349 
#pragma token PROC (\
 333 
#pragma token PROC(\
350 
	TYPE t\
 334 
	TYPE t\
351 
    ) EXP const : LIST ( t ) : NULL_list #
 335 
    ) EXP const : LIST(t) : NULL_list #
352 
 
 336 
 
353 
#pragma token PROC {\
 337 
#pragma token PROC {\
354 
	TYPE t, EXP : LIST ( t ) : e |\
 338 
	TYPE t, EXP : LIST(t) : e |\
355 
	EXP e\
 339 
	EXP e\
356 
    } EXP : int : IS_NULL_list #
 340 
    } EXP : int : IS_NULL_list #
357 
 
 341 
 
358 
#pragma token PROC {\
 342 
#pragma token PROC {\
359 
	TYPE t, EXP : LIST ( t ) : e1, EXP : LIST ( t ) : e2 |\
 343 
	TYPE t, EXP : LIST(t) : e1, EXP : LIST(t) : e2 |\
360 
	EXP e1, EXP e2\
 344 
	EXP e1, EXP e2\
361 
    } EXP : int : EQ_list #
 345 
    } EXP : int : EQ_list #
362 
 
 346 
 
363 
#pragma token PROC (\
 347 
#pragma token PROC(\
364 
	TYPE t\
 348 
	TYPE t\
365 
    ) EXP : LIST ( t ) : UNIQ_list #
 349 
    ) EXP : LIST(t) : UNIQ_list #
366 
 
 350 
 
367 
#pragma token PROC {\
 351 
#pragma token PROC {\
368 
	TYPE t, EXP : LIST ( t ) : e |\
 352 
	TYPE t, EXP : LIST(t) : e |\
369 
	EXP e\
 353 
	EXP e\
370 
    } EXP : void : DESTROY_UNIQ_list #
 354 
    } EXP : void : DESTROY_UNIQ_list #
371 
 
 355 
 
372 
#pragma token PROC {\
 356 
#pragma token PROC {\
373 
	TYPE t, EXP : LIST ( t ) : e1, EXP : SIZE ( t ) : e2 |\
 357 
	TYPE t, EXP : LIST(t) : e1, EXP : SIZE(t) : e2 |\
374 
	EXP e1, EXP e2\
 358 
	EXP e1, EXP e2\
375 
    } STATEMENT DESTROY_list #
 359 
    } STATEMENT DESTROY_list #
376 
 
 360 
 
377 
#pragma interface HEAD_list PTR_TAIL_list TAIL_list
 361 
#pragma interface HEAD_list PTR_TAIL_list TAIL_list
378 
#pragma interface LENGTH_list END_list REVERSE_list APPEND_list
 362 
#pragma interface LENGTH_list END_list REVERSE_list APPEND_list
379 
#pragma interface NULL_list IS_NULL_list EQ_list
 363 
#pragma interface NULL_list IS_NULL_list EQ_list
380 
#pragma interface UNIQ_list DESTROY_UNIQ_list DESTROY_list
 364 
#pragma interface UNIQ_list DESTROY_UNIQ_list DESTROY_list
381 
 
 365 
 
382 
#ifdef c_class_IO_ROUTINES
 366 
#ifdef c_class_IO_ROUTINES
383 
#pragma token PROC {\
 367 
#pragma token PROC {\
384 
	TYPE t, EXP : LIST ( t ) : e |\
 368 
	TYPE t, EXP : LIST(t) : e |\
385 
	EXP e\
 369 
	EXP e\
386 
    } EXP : void * : VOIDSTAR_list #
 370 
    } EXP : void * : VOIDSTAR_list #
387 
#pragma interface VOIDSTAR_list
 371 
#pragma interface VOIDSTAR_list
388 
#endif
 372 
#endif
389 
 
 373 
 
390 
#pragma token PROC (\
 374 
#pragma token PROC(\
391 
	TYPE t\
 375 
	TYPE t\
392 
    ) EXP const : SIZE ( LIST ( t ) ) : SIZE_list #
 376 
    ) EXP const : SIZE(LIST(t)) : SIZE_list #
393 
 
 377 
 
394 
#pragma token PROC {\
 378 
#pragma token PROC {\
395 
	TYPE t, EXP : PTR ( LIST ( t ) ) : e1,\
 379 
	TYPE t, EXP : PTR(LIST(t)) : e1,\
396 
	EXP : LIST ( t ) : e2 |\
 380 
	EXP : LIST(t) : e2 |\
397 
	EXP e1, EXP e2\
 381 
	EXP e1, EXP e2\
398 
    } EXP : void : COPY_list #
 382 
    } EXP : void : COPY_list #
399 
 
 383 
 
400 
#pragma token PROC {\
 384 
#pragma token PROC {\
401 
	TYPE t, EXP : PTR ( LIST ( t ) ) : e |\
 385 
	TYPE t, EXP : PTR(LIST(t)) : e |\
402 
	EXP e\
 386 
	EXP e\
403 
    } EXP : LIST ( t ) : DEREF_list #
 387 
    } EXP : LIST(t) : DEREF_list #
404 
 
 388 
 
405 
#pragma token PROC {\
 389 
#pragma token PROC {\
406 
	TYPE t, EXP : LIST ( t ) : e2,\
 390 
	TYPE t, EXP : LIST(t) : e2,\
407 
	EXP : LIST ( LIST ( t ) ) : e3,\
 391 
	EXP : LIST(LIST(t)) : e3,\
408 
	EXP lvalue : LIST ( LIST ( t ) ) : e4 |\
 392 
	EXP lvalue : LIST(LIST(t)) : e4 |\
409 
	EXP e2, EXP e3, EXP e4\
 393 
	EXP e2, EXP e3, EXP e4\
410 
    } STATEMENT CONS_list #
 394 
    } STATEMENT CONS_list #
411 
 
 395 
 
412 
#pragma token PROC {\
 396 
#pragma token PROC {\
413 
	TYPE t, EXP lvalue : LIST ( t ) : e2,\
 397 
	TYPE t, EXP lvalue : LIST(t) : e2,\
414 
	EXP lvalue : LIST ( LIST ( t ) ) : e3,\
 398 
	EXP lvalue : LIST(LIST(t)) : e3,\
415 
	EXP : LIST ( LIST ( t ) ) : e4 |\
 399 
	EXP : LIST(LIST(t)) : e4 |\
416 
	EXP e2, EXP e3, EXP e4\
 400 
	EXP e2, EXP e3, EXP e4\
417 
    } STATEMENT UN_CONS_list #
 401 
    } STATEMENT UN_CONS_list #
418 
 
 402 
 
419 
#pragma token PROC {\
 403 
#pragma token PROC {\
420 
	TYPE t, EXP : DESTROYER : e1,\
 404 
	TYPE t, EXP : DESTROYER : e1,\
421 
	EXP lvalue : LIST ( t ) : e2,\
 405 
	EXP lvalue : LIST(t) : e2,\
422 
	EXP lvalue : LIST ( LIST ( t ) ) : e3,\
 406 
	EXP lvalue : LIST(LIST(t)) : e3,\
423 
	EXP : LIST ( LIST ( t ) ) : e4 |\
 407 
	EXP : LIST(LIST(t)) : e4 |\
424 
	EXP e1, EXP e2, EXP e3, EXP e4\
 408 
	EXP e1, EXP e2, EXP e3, EXP e4\
425 
    } STATEMENT DESTROY_CONS_list #
 409 
    } STATEMENT DESTROY_CONS_list #
426 
 
 410 
 
427 
#pragma token PROC {\
 411 
#pragma token PROC {\
428 
	TYPE t, EXP : LIST ( t ) : e2,\
 412 
	TYPE t, EXP : LIST(t) : e2,\
429 
	EXP lvalue : STACK ( LIST ( t ) ) : e3 |\
 413 
	EXP lvalue : STACK(LIST(t)) : e3 |\
430 
	EXP e2, EXP e3\
 414 
	EXP e2, EXP e3\
431 
    } STATEMENT PUSH_list #
 415 
    } STATEMENT PUSH_list #
432 
 
 416 
 
433 
#pragma token PROC {\
 417 
#pragma token PROC {\
434 
	TYPE t, EXP lvalue : LIST ( t ) : e2,\
 418 
	TYPE t, EXP lvalue : LIST(t) : e2,\
435 
	EXP lvalue : STACK ( LIST ( t ) ) : e3 |\
 419 
	EXP lvalue : STACK(LIST(t)) : e3 |\
436 
	EXP e2, EXP e3\
 420 
	EXP e2, EXP e3\
437 
    } STATEMENT POP_list #
 421 
    } STATEMENT POP_list #
438 
 
 422 
 
439 
#pragma interface SIZE_list COPY_list DEREF_list
 423 
#pragma interface SIZE_list COPY_list DEREF_list
440 
#pragma interface CONS_list UN_CONS_list DESTROY_CONS_list
 424 
#pragma interface CONS_list UN_CONS_list DESTROY_CONS_list
441 
#pragma interface PUSH_list POP_list
 425 
#pragma interface PUSH_list POP_list
442 
 
 426 
 
443 
 
 427 
 
444 
/* Stack token specifications */
 428 
/* Stack token specifications */
445 
 
 429 
 
446 
#pragma token PROC (\
 430 
#pragma token PROC(\
447 
	TYPE t\
 431 
	TYPE t\
448 
    ) EXP const : STACK ( t ) : NULL_stack #
 432 
    ) EXP const : STACK(t) : NULL_stack #
449 
 
 433 
 
450 
#pragma token PROC {\
 434 
#pragma token PROC {\
451 
	TYPE t, EXP : STACK ( t ) : e |\
 435 
	TYPE t, EXP : STACK(t) : e |\
452 
	EXP e\
 436 
	EXP e\
453 
    } EXP : int : IS_NULL_stack #
 437 
    } EXP : int : IS_NULL_stack #
454 
 
 438 
 
455 
#pragma token PROC {\
 439 
#pragma token PROC {\
456 
	TYPE t, EXP : STACK ( t ) : e1 |\
 440 
	TYPE t, EXP : STACK(t) : e1 |\
457 
	EXP e1\
 441 
	EXP e1\
458 
    } EXP : LIST ( t ) : LIST_stack #
 442 
    } EXP : LIST(t) : LIST_stack #
459 
 
 443 
 
460 
#pragma token PROC {\
 444 
#pragma token PROC {\
461 
	TYPE t, EXP : LIST ( t ) : e1 |\
 445 
	TYPE t, EXP : LIST(t) : e1 |\
462 
	EXP e1\
 446 
	EXP e1\
463 
    } EXP : STACK ( t ) : STACK_list #
 447 
    } EXP : STACK(t) : STACK_list #
464 
 
 448 
 
465 
#pragma interface NULL_stack IS_NULL_stack LIST_stack STACK_list
 449 
#pragma interface NULL_stack IS_NULL_stack LIST_stack STACK_list
466 
 
 450 
 
467 
#pragma token PROC (\
 451 
#pragma token PROC(\
468 
	TYPE t\
 452 
	TYPE t\
469 
    ) EXP const : SIZE ( STACK ( t ) ) : SIZE_stack #
 453 
    ) EXP const : SIZE(STACK(t)) : SIZE_stack #
470 
 
 454 
 
471 
#pragma token PROC {\
 455 
#pragma token PROC {\
472 
	TYPE t, EXP : PTR ( STACK ( t ) ) : e1,\
 456 
	TYPE t, EXP : PTR(STACK(t)) : e1,\
473 
	EXP : STACK ( t ) : e2 |\
 457 
	EXP : STACK(t) : e2 |\
474 
	EXP e1, EXP e2\
 458 
	EXP e1, EXP e2\
475 
    } EXP : void : COPY_stack #
 459 
    } EXP : void : COPY_stack #
476 
 
 460 
 
477 
#pragma token PROC {\
 461 
#pragma token PROC {\
478 
	TYPE t, EXP : PTR ( STACK ( t ) ) : e |\
 462 
	TYPE t, EXP : PTR(STACK(t)) : e |\
479 
	EXP e\
 463 
	EXP e\
480 
    } EXP : STACK ( t ) : DEREF_stack #
 464 
    } EXP : STACK(t) : DEREF_stack #
481 
 
 465 
 
482 
#pragma token PROC {\
 466 
#pragma token PROC {\
483 
	TYPE t, EXP : STACK ( t ) : e2,\
 467 
	TYPE t, EXP : STACK(t) : e2,\
484 
	EXP : LIST ( STACK ( t ) ) : e3,\
 468 
	EXP : LIST(STACK(t)) : e3,\
485 
	EXP lvalue : LIST ( STACK ( t ) ) : e4 |\
 469 
	EXP lvalue : LIST(STACK(t)) : e4 |\
486 
	EXP e2, EXP e3, EXP e4\
 470 
	EXP e2, EXP e3, EXP e4\
487 
    } STATEMENT CONS_stack #
 471 
    } STATEMENT CONS_stack #
488 
 
 472 
 
489 
#pragma token PROC {\
 473 
#pragma token PROC {\
490 
	TYPE t, EXP lvalue : STACK ( t ) : e2,\
 474 
	TYPE t, EXP lvalue : STACK(t) : e2,\
491 
	EXP lvalue : LIST ( STACK ( t ) ) : e3,\
 475 
	EXP lvalue : LIST(STACK(t)) : e3,\
492 
	EXP : LIST ( STACK ( t ) ) : e4 |\
 476 
	EXP : LIST(STACK(t)) : e4 |\
493 
	EXP e2, EXP e3, EXP e4\
 477 
	EXP e2, EXP e3, EXP e4\
494 
    } STATEMENT UN_CONS_stack #
 478 
    } STATEMENT UN_CONS_stack #
495 
 
 479 
 
496 
#pragma token PROC {\
 480 
#pragma token PROC {\
497 
	TYPE t, EXP : DESTROYER : e1,\
 481 
	TYPE t, EXP : DESTROYER : e1,\
498 
	EXP lvalue : STACK ( t ) : e2,\
 482 
	EXP lvalue : STACK(t) : e2,\
499 
	EXP lvalue : LIST ( STACK ( t ) ) : e3,\
 483 
	EXP lvalue : LIST(STACK(t)) : e3,\
500 
	EXP : LIST ( STACK ( t ) ) : e4 |\
 484 
	EXP : LIST(STACK(t)) : e4 |\
501 
	EXP e1, EXP e2, EXP e3, EXP e4\
 485 
	EXP e1, EXP e2, EXP e3, EXP e4\
502 
    } STATEMENT DESTROY_CONS_stack #
 486 
    } STATEMENT DESTROY_CONS_stack #
503 
 
 487 
 
504 
#pragma token PROC {\
 488 
#pragma token PROC {\
505 
	TYPE t, EXP : STACK ( t ) : e2,\
 489 
	TYPE t, EXP : STACK(t) : e2,\
506 
	EXP lvalue : STACK ( STACK ( t ) ) : e3 |\
 490 
	EXP lvalue : STACK(STACK(t)) : e3 |\
507 
	EXP e2, EXP e3\
 491 
	EXP e2, EXP e3\
508 
    } STATEMENT PUSH_stack #
 492 
    } STATEMENT PUSH_stack #
509 
 
 493 
 
510 
#pragma token PROC {\
 494 
#pragma token PROC {\
511 
	TYPE t, EXP lvalue : STACK ( t ) : e2,\
 495 
	TYPE t, EXP lvalue : STACK(t) : e2,\
512 
	EXP lvalue : STACK ( STACK ( t ) ) : e3 |\
 496 
	EXP lvalue : STACK(STACK(t)) : e3 |\
513 
	EXP e2, EXP e3\
 497 
	EXP e2, EXP e3\
514 
    } STATEMENT POP_stack #
 498 
    } STATEMENT POP_stack #
515 
 
 499 
 
516 
#pragma interface SIZE_stack COPY_stack DEREF_stack
 500 
#pragma interface SIZE_stack COPY_stack DEREF_stack
517 
#pragma interface CONS_stack UN_CONS_stack DESTROY_CONS_stack
 501 
#pragma interface CONS_stack UN_CONS_stack DESTROY_CONS_stack
Line 520... Line 504...
520 
 
 504 
 
521 
/* Size token specifications */
 505 
/* Size token specifications */
522 
 
 506 
 
523 
#pragma token PROC {\
 507 
#pragma token PROC {\
524 
	TYPE t, VARIETY v,\
 508 
	TYPE t, VARIETY v,\
525 
	EXP : SIZE ( t ) : e1, EXP : v : e2 |\
 509 
	EXP : SIZE(t) : e1, EXP : v : e2 |\
526 
	EXP e1, EXP e2\
 510 
	EXP e1, EXP e2\
527 
    } EXP : SIZE ( t ) : SCALE #
 511 
    } EXP : SIZE(t) : SCALE #
528 
 
 512 
 
529 
#pragma interface SCALE
 513 
#pragma interface SCALE
530 
 
 514 
 
531 
 
 515 
 
532 
/* Definitions for primitive int */
 516 
/* Definitions for primitive int */
533 
 
 517 
 
534 
#pragma token EXP const : SIZE ( int ) : SIZE_int #
 518 
#pragma token EXP const : SIZE(int) : SIZE_int #
535 
 
 519 
 
536 
#pragma token PROC (\
 520 
#pragma token PROC(\
537 
	EXP : PTR ( int ) :,\
 521 
	EXP : PTR(int) :,\
538 
	EXP : int :\
 522 
	EXP : int :\
539 
    ) EXP : void : COPY_int #
 523 
    ) EXP : void : COPY_int #
540 
 
 524 
 
541 
#pragma token PROC (\
 525 
#pragma token PROC(\
542 
	EXP : PTR ( int ) :\
 526 
	EXP : PTR(int) :\
543 
    ) EXP : int : DEREF_int #
 527 
    ) EXP : int : DEREF_int #
544 
 
 528 
 
545 
#pragma token PROC (\
 529 
#pragma token PROC(\
546 
	EXP : int :,\
 530 
	EXP : int :,\
547 
	EXP : LIST ( int ) :,\
 531 
	EXP : LIST(int) :,\
548 
	EXP lvalue : LIST ( int ) :\
 532 
	EXP lvalue : LIST(int) :\
549 
    ) STATEMENT CONS_int #
 533 
    ) STATEMENT CONS_int #
550 
 
 534 
 
551 
#pragma token PROC (\
 535 
#pragma token PROC(\
552 
	EXP lvalue : int :,\
 536 
	EXP lvalue : int :,\
553 
	EXP lvalue : LIST ( int ) :,\
 537 
	EXP lvalue : LIST(int) :,\
554 
	EXP : LIST ( int ) :\
 538 
	EXP : LIST(int) :\
555 
    ) STATEMENT UN_CONS_int #
 539 
    ) STATEMENT UN_CONS_int #
556 
 
 540 
 
557 
#pragma token PROC (\
 541 
#pragma token PROC(\
558 
	EXP : DESTROYER :,\
 542 
	EXP : DESTROYER :,\
559 
	EXP lvalue : int :,\
 543 
	EXP lvalue : int :,\
560 
	EXP lvalue : LIST ( int ) :,\
 544 
	EXP lvalue : LIST(int) :,\
561 
	EXP : LIST ( int ) :\
 545 
	EXP : LIST(int) :\
562 
    ) STATEMENT DESTROY_CONS_int #
 546 
    ) STATEMENT DESTROY_CONS_int #
563 
 
 547 
 
564 
#pragma token PROC (\
 548 
#pragma token PROC(\
565 
	EXP : int :,\
 549 
	EXP : int :,\
566 
	EXP lvalue : STACK ( int ) :\
 550 
	EXP lvalue : STACK(int) :\
567 
    ) STATEMENT PUSH_int #
 551 
    ) STATEMENT PUSH_int #
568 
 
 552 
 
569 
#pragma token PROC (\
 553 
#pragma token PROC(\
570 
	EXP lvalue : int :,\
 554 
	EXP lvalue : int :,\
571 
	EXP lvalue : STACK ( int ) :\
 555 
	EXP lvalue : STACK(int) :\
572 
    ) STATEMENT POP_int #
 556 
    ) STATEMENT POP_int #
573 
 
 557 
 
574 
#pragma interface SIZE_int COPY_int DEREF_int
 558 
#pragma interface SIZE_int COPY_int DEREF_int
575 
#pragma interface CONS_int UN_CONS_int DESTROY_CONS_int
 559 
#pragma interface CONS_int UN_CONS_int DESTROY_CONS_int
576 
#pragma interface PUSH_int POP_int
 560 
#pragma interface PUSH_int POP_int
577 
 
 561 
 
578 
 
 562 
 
579 
/* Definitions for primitive unsigned */
 563 
/* Definitions for primitive unsigned */
580 
 
 564 
 
581 
#pragma token EXP const : SIZE ( unsigned ) : SIZE_unsigned #
 565 
#pragma token EXP const : SIZE(unsigned) : SIZE_unsigned #
582 
 
 566 
 
583 
#pragma token PROC (\
 567 
#pragma token PROC(\
584 
	EXP : PTR ( unsigned ) :,\
 568 
	EXP : PTR(unsigned) :,\
585 
	EXP : unsigned :\
 569 
	EXP : unsigned :\
586 
    ) EXP : void : COPY_unsigned #
 570 
    ) EXP : void : COPY_unsigned #
587 
 
 571 
 
588 
#pragma token PROC (\
 572 
#pragma token PROC(\
589 
	EXP : PTR ( unsigned ) :\
 573 
	EXP : PTR(unsigned) :\
590 
    ) EXP : unsigned : DEREF_unsigned #
 574 
    ) EXP : unsigned : DEREF_unsigned #
591 
 
 575 
 
592 
#pragma token PROC (\
 576 
#pragma token PROC(\
593 
	EXP : unsigned :,\
 577 
	EXP : unsigned :,\
594 
	EXP : LIST ( unsigned ) :,\
 578 
	EXP : LIST(unsigned) :,\
595 
	EXP lvalue : LIST ( unsigned ) :\
 579 
	EXP lvalue : LIST(unsigned) :\
596 
    ) STATEMENT CONS_unsigned #
 580 
    ) STATEMENT CONS_unsigned #
597 
 
 581 
 
598 
#pragma token PROC (\
 582 
#pragma token PROC(\
599 
	EXP lvalue : unsigned :,\
 583 
	EXP lvalue : unsigned :,\
600 
	EXP lvalue : LIST ( unsigned ) :,\
 584 
	EXP lvalue : LIST(unsigned) :,\
601 
	EXP : LIST ( unsigned ) :\
 585 
	EXP : LIST(unsigned) :\
602 
    ) STATEMENT UN_CONS_unsigned #
 586 
    ) STATEMENT UN_CONS_unsigned #
603 
 
 587 
 
604 
#pragma token PROC (\
 588 
#pragma token PROC(\
605 
	EXP : DESTROYER :,\
 589 
	EXP : DESTROYER :,\
606 
	EXP lvalue : unsigned :,\
 590 
	EXP lvalue : unsigned :,\
607 
	EXP lvalue : LIST ( unsigned ) :,\
 591 
	EXP lvalue : LIST(unsigned) :,\
608 
	EXP : LIST ( unsigned ) :\
 592 
	EXP : LIST(unsigned) :\
609 
    ) STATEMENT DESTROY_CONS_unsigned #
 593 
    ) STATEMENT DESTROY_CONS_unsigned #
610 
 
 594 
 
611 
#pragma token PROC (\
 595 
#pragma token PROC(\
612 
	EXP : unsigned :,\
 596 
	EXP : unsigned :,\
613 
	EXP lvalue : STACK ( unsigned ) :\
 597 
	EXP lvalue : STACK(unsigned) :\
614 
    ) STATEMENT PUSH_unsigned #
 598 
    ) STATEMENT PUSH_unsigned #
615 
 
 599 
 
616 
#pragma token PROC (\
 600 
#pragma token PROC(\
617 
	EXP lvalue : unsigned :,\
 601 
	EXP lvalue : unsigned :,\
618 
	EXP lvalue : STACK ( unsigned ) :\
 602 
	EXP lvalue : STACK(unsigned) :\
619 
    ) STATEMENT POP_unsigned #
 603 
    ) STATEMENT POP_unsigned #
620 
 
 604 
 
621 
#pragma interface SIZE_unsigned COPY_unsigned DEREF_unsigned
 605 
#pragma interface SIZE_unsigned COPY_unsigned DEREF_unsigned
622 
#pragma interface CONS_unsigned UN_CONS_unsigned DESTROY_CONS_unsigned
 606 
#pragma interface CONS_unsigned UN_CONS_unsigned DESTROY_CONS_unsigned
623 
#pragma interface PUSH_unsigned POP_unsigned
 607 
#pragma interface PUSH_unsigned POP_unsigned
624 
 
 608 
 
625 
 
 609 
 
626 
/* Definitions for primitive string */
 610 
/* Definitions for primitive string */
627 
 
 611 
 
628 
#pragma token EXP const : SIZE ( string ) : SIZE_string #
 612 
#pragma token EXP const : SIZE(string) : SIZE_string #
629 
 
 613 
 
630 
#pragma token PROC (\
 614 
#pragma token PROC(\
631 
	EXP : PTR ( string ) :,\
 615 
	EXP : PTR(string) :,\
632 
	EXP : string :\
 616 
	EXP : string :\
633 
    ) EXP : void : COPY_string #
 617 
    ) EXP : void : COPY_string #
634 
 
 618 
 
635 
#pragma token PROC (\
 619 
#pragma token PROC(\
636 
	EXP : PTR ( string ) :\
 620 
	EXP : PTR(string) :\
637 
    ) EXP : string : DEREF_string #
 621 
    ) EXP : string : DEREF_string #
638 
 
 622 
 
639 
#pragma token PROC (\
 623 
#pragma token PROC(\
640 
	EXP : string :,\
 624 
	EXP : string :,\
641 
	EXP : LIST ( string ) :,\
 625 
	EXP : LIST(string) :,\
642 
	EXP lvalue : LIST ( string ) :\
 626 
	EXP lvalue : LIST(string) :\
643 
    ) STATEMENT CONS_string #
 627 
    ) STATEMENT CONS_string #
644 
 
 628 
 
645 
#pragma token PROC (\
 629 
#pragma token PROC(\
646 
	EXP lvalue : string :,\
 630 
	EXP lvalue : string :,\
647 
	EXP lvalue : LIST ( string ) :,\
 631 
	EXP lvalue : LIST(string) :,\
648 
	EXP : LIST ( string ) :\
 632 
	EXP : LIST(string) :\
649 
    ) STATEMENT UN_CONS_string #
 633 
    ) STATEMENT UN_CONS_string #
650 
 
 634 
 
651 
#pragma token PROC (\
 635 
#pragma token PROC(\
652 
	EXP : DESTROYER :,\
 636 
	EXP : DESTROYER :,\
653 
	EXP lvalue : string :,\
 637 
	EXP lvalue : string :,\
654 
	EXP lvalue : LIST ( string ) :,\
 638 
	EXP lvalue : LIST(string) :,\
655 
	EXP : LIST ( string ) :\
 639 
	EXP : LIST(string) :\
656 
    ) STATEMENT DESTROY_CONS_string #
 640 
    ) STATEMENT DESTROY_CONS_string #
657 
 
 641 
 
658 
#pragma token PROC (\
 642 
#pragma token PROC(\
659 
	EXP : string :,\
 643 
	EXP : string :,\
660 
	EXP lvalue : STACK ( string ) :\
 644 
	EXP lvalue : STACK(string) :\
661 
    ) STATEMENT PUSH_string #
 645 
    ) STATEMENT PUSH_string #
662 
 
 646 
 
663 
#pragma token PROC (\
 647 
#pragma token PROC(\
664 
	EXP lvalue : string :,\
 648 
	EXP lvalue : string :,\
665 
	EXP lvalue : STACK ( string ) :\
 649 
	EXP lvalue : STACK(string) :\
666 
    ) STATEMENT POP_string #
 650 
    ) STATEMENT POP_string #
667 
 
 651 
 
668 
#pragma interface SIZE_string COPY_string DEREF_string
 652 
#pragma interface SIZE_string COPY_string DEREF_string
669 
#pragma interface CONS_string UN_CONS_string DESTROY_CONS_string
 653 
#pragma interface CONS_string UN_CONS_string DESTROY_CONS_string
670 
#pragma interface PUSH_string POP_string
 654 
#pragma interface PUSH_string POP_string
671 
 
 655 
 
672 
 
 656 
 
673 
/* Definitions for primitive ulong_type */
 657 
/* Definitions for primitive ulong_type */
674 
 
 658 
 
675 
#pragma token EXP const : SIZE ( ulong_type ) : SIZE_ulong #
 659 
#pragma token EXP const : SIZE(ulong_type) : SIZE_ulong #
676 
 
 660 
 
677 
#pragma token PROC (\
 661 
#pragma token PROC(\
678 
	EXP : PTR ( ulong_type ) :,\
 662 
	EXP : PTR(ulong_type) :,\
679 
	EXP : ulong_type :\
 663 
	EXP : ulong_type :\
680 
    ) EXP : void : COPY_ulong #
 664 
    ) EXP : void : COPY_ulong #
681 
 
 665 
 
682 
#pragma token PROC (\
 666 
#pragma token PROC(\
683 
	EXP : PTR ( ulong_type ) :\
 667 
	EXP : PTR(ulong_type) :\
684 
    ) EXP : ulong_type : DEREF_ulong #
 668 
    ) EXP : ulong_type : DEREF_ulong #
685 
 
 669 
 
686 
#pragma token PROC (\
 670 
#pragma token PROC(\
687 
	EXP : ulong_type :,\
 671 
	EXP : ulong_type :,\
688 
	EXP : LIST ( ulong_type ) :,\
 672 
	EXP : LIST(ulong_type) :,\
689 
	EXP lvalue : LIST ( ulong_type ) :\
 673 
	EXP lvalue : LIST(ulong_type) :\
690 
    ) STATEMENT CONS_ulong #
 674 
    ) STATEMENT CONS_ulong #
691 
 
 675 
 
692 
#pragma token PROC (\
 676 
#pragma token PROC(\
693 
	EXP lvalue : ulong_type :,\
 677 
	EXP lvalue : ulong_type :,\
694 
	EXP lvalue : LIST ( ulong_type ) :,\
 678 
	EXP lvalue : LIST(ulong_type) :,\
695 
	EXP : LIST ( ulong_type ) :\
 679 
	EXP : LIST(ulong_type) :\
696 
    ) STATEMENT UN_CONS_ulong #
 680 
    ) STATEMENT UN_CONS_ulong #
697 
 
 681 
 
698 
#pragma token PROC (\
 682 
#pragma token PROC(\
699 
	EXP : DESTROYER :,\
 683 
	EXP : DESTROYER :,\
700 
	EXP lvalue : ulong_type :,\
 684 
	EXP lvalue : ulong_type :,\
701 
	EXP lvalue : LIST ( ulong_type ) :,\
 685 
	EXP lvalue : LIST(ulong_type) :,\
702 
	EXP : LIST ( ulong_type ) :\
 686 
	EXP : LIST(ulong_type) :\
703 
    ) STATEMENT DESTROY_CONS_ulong #
 687 
    ) STATEMENT DESTROY_CONS_ulong #
704 
 
 688 
 
705 
#pragma token PROC (\
 689 
#pragma token PROC(\
706 
	EXP : ulong_type :,\
 690 
	EXP : ulong_type :,\
707 
	EXP lvalue : STACK ( ulong_type ) :\
 691 
	EXP lvalue : STACK(ulong_type) :\
708 
    ) STATEMENT PUSH_ulong #
 692 
    ) STATEMENT PUSH_ulong #
709 
 
 693 
 
710 
#pragma token PROC (\
 694 
#pragma token PROC(\
711 
	EXP lvalue : ulong_type :,\
 695 
	EXP lvalue : ulong_type :,\
712 
	EXP lvalue : STACK ( ulong_type ) :\
 696 
	EXP lvalue : STACK(ulong_type) :\
713 
    ) STATEMENT POP_ulong #
 697 
    ) STATEMENT POP_ulong #
714 
 
 698 
 
715 
#pragma interface SIZE_ulong COPY_ulong DEREF_ulong
 699 
#pragma interface SIZE_ulong COPY_ulong DEREF_ulong
716 
#pragma interface CONS_ulong UN_CONS_ulong DESTROY_CONS_ulong
 700 
#pragma interface CONS_ulong UN_CONS_ulong DESTROY_CONS_ulong
717 
#pragma interface PUSH_ulong POP_ulong
 701 
#pragma interface PUSH_ulong POP_ulong
718 
 
 702 
 
719 
 
 703 
 
720 
/* Definitions for primitive BITSTREAM_P */
 704 
/* Definitions for primitive BITSTREAM_P */
721 
 
 705 
 
722 
#pragma token EXP const : SIZE ( BITSTREAM_P ) : SIZE_bits #
 706 
#pragma token EXP const : SIZE(BITSTREAM_P) : SIZE_bits #
723 
 
 707 
 
724 
#pragma token PROC (\
 708 
#pragma token PROC(\
725 
	EXP : PTR ( BITSTREAM_P ) :,\
 709 
	EXP : PTR(BITSTREAM_P) :,\
726 
	EXP : BITSTREAM_P :\
 710 
	EXP : BITSTREAM_P :\
727 
    ) EXP : void : COPY_bits #
 711 
    ) EXP : void : COPY_bits #
728 
 
 712 
 
729 
#pragma token PROC (\
 713 
#pragma token PROC(\
730 
	EXP : PTR ( BITSTREAM_P ) :\
 714 
	EXP : PTR(BITSTREAM_P) :\
731 
    ) EXP : BITSTREAM_P : DEREF_bits #
 715 
    ) EXP : BITSTREAM_P : DEREF_bits #
732 
 
 716 
 
733 
#pragma token PROC (\
 717 
#pragma token PROC(\
734 
	EXP : BITSTREAM_P :,\
 718 
	EXP : BITSTREAM_P :,\
735 
	EXP : LIST ( BITSTREAM_P ) :,\
 719 
	EXP : LIST(BITSTREAM_P) :,\
736 
	EXP lvalue : LIST ( BITSTREAM_P ) :\
 720 
	EXP lvalue : LIST(BITSTREAM_P) :\
737 
    ) STATEMENT CONS_bits #
 721 
    ) STATEMENT CONS_bits #
738 
 
 722 
 
739 
#pragma token PROC (\
 723 
#pragma token PROC(\
740 
	EXP lvalue : BITSTREAM_P :,\
 724 
	EXP lvalue : BITSTREAM_P :,\
741 
	EXP lvalue : LIST ( BITSTREAM_P ) :,\
 725 
	EXP lvalue : LIST(BITSTREAM_P) :,\
742 
	EXP : LIST ( BITSTREAM_P ) :\
 726 
	EXP : LIST(BITSTREAM_P) :\
743 
    ) STATEMENT UN_CONS_bits #
 727 
    ) STATEMENT UN_CONS_bits #
744 
 
 728 
 
745 
#pragma token PROC (\
 729 
#pragma token PROC(\
746 
	EXP : DESTROYER :,\
 730 
	EXP : DESTROYER :,\
747 
	EXP lvalue : BITSTREAM_P :,\
 731 
	EXP lvalue : BITSTREAM_P :,\
748 
	EXP lvalue : LIST ( BITSTREAM_P ) :,\
 732 
	EXP lvalue : LIST(BITSTREAM_P) :,\
749 
	EXP : LIST ( BITSTREAM_P ) :\
 733 
	EXP : LIST(BITSTREAM_P) :\
750 
    ) STATEMENT DESTROY_CONS_bits #
 734 
    ) STATEMENT DESTROY_CONS_bits #
751 
 
 735 
 
752 
#pragma token PROC (\
 736 
#pragma token PROC(\
753 
	EXP : BITSTREAM_P :,\
 737 
	EXP : BITSTREAM_P :,\
754 
	EXP lvalue : STACK ( BITSTREAM_P ) :\
 738 
	EXP lvalue : STACK(BITSTREAM_P) :\
755 
    ) STATEMENT PUSH_bits #
 739 
    ) STATEMENT PUSH_bits #
756 
 
 740 
 
757 
#pragma token PROC (\
 741 
#pragma token PROC(\
758 
	EXP lvalue : BITSTREAM_P :,\
 742 
	EXP lvalue : BITSTREAM_P :,\
759 
	EXP lvalue : STACK ( BITSTREAM_P ) :\
 743 
	EXP lvalue : STACK(BITSTREAM_P) :\
760 
    ) STATEMENT POP_bits #
 744 
    ) STATEMENT POP_bits #
761 
 
 745 
 
762 
#pragma interface SIZE_bits COPY_bits DEREF_bits
 746 
#pragma interface SIZE_bits COPY_bits DEREF_bits
763 
#pragma interface CONS_bits UN_CONS_bits DESTROY_CONS_bits
 747 
#pragma interface CONS_bits UN_CONS_bits DESTROY_CONS_bits
764 
#pragma interface PUSH_bits POP_bits
 748 
#pragma interface PUSH_bits POP_bits
765 
 
 749 
 
766 
 
 750 
 
767 
/* Definitions for primitive PPTOKEN_P */
 751 
/* Definitions for primitive PPTOKEN_P */
768 
 
 752 
 
769 
#pragma token EXP const : SIZE ( PPTOKEN_P ) : SIZE_pptok #
 753 
#pragma token EXP const : SIZE(PPTOKEN_P) : SIZE_pptok #
770 
 
 754 
 
771 
#pragma token PROC (\
 755 
#pragma token PROC(\
772 
	EXP : PTR ( PPTOKEN_P ) :,\
 756 
	EXP : PTR(PPTOKEN_P) :,\
773 
	EXP : PPTOKEN_P :\
 757 
	EXP : PPTOKEN_P :\
774 
    ) EXP : void : COPY_pptok #
 758 
    ) EXP : void : COPY_pptok #
775 
 
 759 
 
776 
#pragma token PROC (\
 760 
#pragma token PROC(\
777 
	EXP : PTR ( PPTOKEN_P ) :\
 761 
	EXP : PTR(PPTOKEN_P) :\
778 
    ) EXP : PPTOKEN_P : DEREF_pptok #
 762 
    ) EXP : PPTOKEN_P : DEREF_pptok #
779 
 
 763 
 
780 
#pragma token PROC (\
 764 
#pragma token PROC(\
781 
	EXP : PPTOKEN_P :,\
 765 
	EXP : PPTOKEN_P :,\
782 
	EXP : LIST ( PPTOKEN_P ) :,\
 766 
	EXP : LIST(PPTOKEN_P) :,\
783 
	EXP lvalue : LIST ( PPTOKEN_P ) :\
 767 
	EXP lvalue : LIST(PPTOKEN_P) :\
784 
    ) STATEMENT CONS_pptok #
 768 
    ) STATEMENT CONS_pptok #
785 
 
 769 
 
786 
#pragma token PROC (\
 770 
#pragma token PROC(\
787 
	EXP lvalue : PPTOKEN_P :,\
 771 
	EXP lvalue : PPTOKEN_P :,\
788 
	EXP lvalue : LIST ( PPTOKEN_P ) :,\
 772 
	EXP lvalue : LIST(PPTOKEN_P) :,\
789 
	EXP : LIST ( PPTOKEN_P ) :\
 773 
	EXP : LIST(PPTOKEN_P) :\
790 
    ) STATEMENT UN_CONS_pptok #
 774 
    ) STATEMENT UN_CONS_pptok #
791 
 
 775 
 
792 
#pragma token PROC (\
 776 
#pragma token PROC(\
793 
	EXP : DESTROYER :,\
 777 
	EXP : DESTROYER :,\
794 
	EXP lvalue : PPTOKEN_P :,\
 778 
	EXP lvalue : PPTOKEN_P :,\
795 
	EXP lvalue : LIST ( PPTOKEN_P ) :,\
 779 
	EXP lvalue : LIST(PPTOKEN_P) :,\
796 
	EXP : LIST ( PPTOKEN_P ) :\
 780 
	EXP : LIST(PPTOKEN_P) :\
797 
    ) STATEMENT DESTROY_CONS_pptok #
 781 
    ) STATEMENT DESTROY_CONS_pptok #
798 
 
 782 
 
799 
#pragma token PROC (\
 783 
#pragma token PROC(\
800 
	EXP : PPTOKEN_P :,\
 784 
	EXP : PPTOKEN_P :,\
801 
	EXP lvalue : STACK ( PPTOKEN_P ) :\
 785 
	EXP lvalue : STACK(PPTOKEN_P) :\
802 
    ) STATEMENT PUSH_pptok #
 786 
    ) STATEMENT PUSH_pptok #
803 
 
 787 
 
804 
#pragma token PROC (\
 788 
#pragma token PROC(\
805 
	EXP lvalue : PPTOKEN_P :,\
 789 
	EXP lvalue : PPTOKEN_P :,\
806 
	EXP lvalue : STACK ( PPTOKEN_P ) :\
 790 
	EXP lvalue : STACK(PPTOKEN_P) :\
807 
    ) STATEMENT POP_pptok #
 791 
    ) STATEMENT POP_pptok #
808 
 
 792 
 
809 
#pragma interface SIZE_pptok COPY_pptok DEREF_pptok
 793 
#pragma interface SIZE_pptok COPY_pptok DEREF_pptok
810 
#pragma interface CONS_pptok UN_CONS_pptok DESTROY_CONS_pptok
 794 
#pragma interface CONS_pptok UN_CONS_pptok DESTROY_CONS_pptok
811 
#pragma interface PUSH_pptok POP_pptok
 795 
#pragma interface PUSH_pptok POP_pptok
812 
 
 796 
 
813 
 
 797 
 
814 
/* Definitions for enumeration CV_SPEC */
 798 
/* Definitions for enumeration CV_SPEC */
815 
 
 799 
 
816 
#define cv_none				( ( CV_SPEC ) 0 )
 800 
#define cv_none				((CV_SPEC) 0)
817 
#define cv_const			( ( CV_SPEC ) 1 )
 801 
#define cv_const			((CV_SPEC) 1)
818 
#define cv_volatile			( ( CV_SPEC ) 2 )
 802 
#define cv_volatile			((CV_SPEC) 2)
819 
#define cv_lvalue			( ( CV_SPEC ) 4 )
 803 
#define cv_lvalue			((CV_SPEC) 4)
820 
#define cv_c				( ( CV_SPEC ) 8 )
 804 
#define cv_c				((CV_SPEC) 8)
821 
#define cv_cpp				( ( CV_SPEC ) 16 )
 805 
#define cv_cpp				((CV_SPEC) 16)
822 
#define cv_qual				( ( CV_SPEC ) 3 )
 806 
#define cv_qual				((CV_SPEC) 3)
823 
#define cv_mask				( ( CV_SPEC ) 7 )
 807 
#define cv_mask				((CV_SPEC) 7)
824 
#define cv_language			( ( CV_SPEC ) 24 )
 808 
#define cv_language			((CV_SPEC) 24)
825 
#define ORDER_cv			( ( unsigned long ) 25 )
 809 
#define ORDER_cv			((unsigned long) 25)
826 
#pragma token EXP const : SIZE ( CV_SPEC ) : SIZE_cv #
 810 
#pragma token EXP const : SIZE(CV_SPEC) : SIZE_cv #
827 
 
 811 
 
828 
#pragma token PROC (\
 812 
#pragma token PROC(\
829 
	EXP : PTR ( CV_SPEC ) :,\
 813 
	EXP : PTR(CV_SPEC) :,\
830 
	EXP : CV_SPEC :\
 814 
	EXP : CV_SPEC :\
831 
    ) EXP : void : COPY_cv #
 815 
    ) EXP : void : COPY_cv #
832 
 
 816 
 
833 
#pragma token PROC (\
 817 
#pragma token PROC(\
834 
	EXP : PTR ( CV_SPEC ) :\
 818 
	EXP : PTR(CV_SPEC) :\
835 
    ) EXP : CV_SPEC : DEREF_cv #
 819 
    ) EXP : CV_SPEC : DEREF_cv #
836 
 
 820 
 
837 
#pragma interface SIZE_cv COPY_cv DEREF_cv
 821 
#pragma interface SIZE_cv COPY_cv DEREF_cv
838 
 
 822 
 
839 
 
 823 
 
840 
/* Definitions for enumeration BUILTIN_TYPE */
 824 
/* Definitions for enumeration BUILTIN_TYPE */
841 
 
 825 
 
842 
#define ntype_none			( ( BUILTIN_TYPE ) 0 )
 826 
#define ntype_none			((BUILTIN_TYPE) 0)
843 
#define ntype_char			( ( BUILTIN_TYPE ) 1 )
 827 
#define ntype_char			((BUILTIN_TYPE) 1)
844 
#define ntype_schar			( ( BUILTIN_TYPE ) 2 )
 828 
#define ntype_schar			((BUILTIN_TYPE) 2)
845 
#define ntype_uchar			( ( BUILTIN_TYPE ) 3 )
 829 
#define ntype_uchar			((BUILTIN_TYPE) 3)
846 
#define ntype_sshort			( ( BUILTIN_TYPE ) 4 )
 830 
#define ntype_sshort			((BUILTIN_TYPE) 4)
847 
#define ntype_ushort			( ( BUILTIN_TYPE ) 5 )
 831 
#define ntype_ushort			((BUILTIN_TYPE) 5)
848 
#define ntype_sint			( ( BUILTIN_TYPE ) 6 )
 832 
#define ntype_sint			((BUILTIN_TYPE) 6)
849 
#define ntype_uint			( ( BUILTIN_TYPE ) 7 )
 833 
#define ntype_uint			((BUILTIN_TYPE) 7)
850 
#define ntype_slong			( ( BUILTIN_TYPE ) 8 )
 834 
#define ntype_slong			((BUILTIN_TYPE) 8)
851 
#define ntype_ulong			( ( BUILTIN_TYPE ) 9 )
 835 
#define ntype_ulong			((BUILTIN_TYPE) 9)
852 
#define ntype_sllong			( ( BUILTIN_TYPE ) 10 )
 836 
#define ntype_sllong			((BUILTIN_TYPE) 10)
853 
#define ntype_ullong			( ( BUILTIN_TYPE ) 11 )
 837 
#define ntype_ullong			((BUILTIN_TYPE) 11)
854 
#define ntype_float			( ( BUILTIN_TYPE ) 12 )
 838 
#define ntype_float			((BUILTIN_TYPE) 12)
855 
#define ntype_double			( ( BUILTIN_TYPE ) 13 )
 839 
#define ntype_double			((BUILTIN_TYPE) 13)
856 
#define ntype_ldouble			( ( BUILTIN_TYPE ) 14 )
 840 
#define ntype_ldouble			((BUILTIN_TYPE) 14)
857 
#define ntype_void			( ( BUILTIN_TYPE ) 15 )
 841 
#define ntype_void			((BUILTIN_TYPE) 15)
858 
#define ntype_bottom			( ( BUILTIN_TYPE ) 16 )
 842 
#define ntype_bottom			((BUILTIN_TYPE) 16)
859 
#define ntype_bool			( ( BUILTIN_TYPE ) 17 )
 843 
#define ntype_bool			((BUILTIN_TYPE) 17)
860 
#define ntype_ptrdiff_t			( ( BUILTIN_TYPE ) 18 )
 844 
#define ntype_ptrdiff_t			((BUILTIN_TYPE) 18)
861 
#define ntype_size_t			( ( BUILTIN_TYPE ) 19 )
 845 
#define ntype_size_t			((BUILTIN_TYPE) 19)
862 
#define ntype_wchar_t			( ( BUILTIN_TYPE ) 20 )
 846 
#define ntype_wchar_t			((BUILTIN_TYPE) 20)
863 
#define ntype_ellipsis			( ( BUILTIN_TYPE ) 21 )
 847 
#define ntype_ellipsis			((BUILTIN_TYPE) 21)
864 
#define ORDER_ntype			( ( unsigned long ) 22 )
 848 
#define ORDER_ntype			((unsigned long) 22)
865 
#pragma token EXP const : SIZE ( BUILTIN_TYPE ) : SIZE_ntype #
 849 
#pragma token EXP const : SIZE(BUILTIN_TYPE) : SIZE_ntype #
866 
 
 850 
 
867 
#pragma token PROC (\
 851 
#pragma token PROC(\
868 
	EXP : PTR ( BUILTIN_TYPE ) :,\
 852 
	EXP : PTR(BUILTIN_TYPE) :,\
869 
	EXP : BUILTIN_TYPE :\
 853 
	EXP : BUILTIN_TYPE :\
870 
    ) EXP : void : COPY_ntype #
 854 
    ) EXP : void : COPY_ntype #
871 
 
 855 
 
872 
#pragma token PROC (\
 856 
#pragma token PROC(\
873 
	EXP : PTR ( BUILTIN_TYPE ) :\
 857 
	EXP : PTR(BUILTIN_TYPE) :\
874 
    ) EXP : BUILTIN_TYPE : DEREF_ntype #
 858 
    ) EXP : BUILTIN_TYPE : DEREF_ntype #
875 
 
 859 
 
876 
#pragma interface SIZE_ntype COPY_ntype DEREF_ntype
 860 
#pragma interface SIZE_ntype COPY_ntype DEREF_ntype
877 
 
 861 
 
878 
 
 862 
 
879 
/* Definitions for enumeration BASE_TYPE */
 863 
/* Definitions for enumeration BASE_TYPE */
880 
 
 864 
 
881 
#ifdef __STDC__
 865 
#ifdef __STDC__
882 
#define btype_none			( ( BASE_TYPE ) 0UL )
 866 
#define btype_none			((BASE_TYPE) 0UL)
883 
#define btype_class			( ( BASE_TYPE ) 1UL )
 867 
#define btype_class			((BASE_TYPE) 1UL)
884 
#define btype_struct_			( ( BASE_TYPE ) 2UL )
 868 
#define btype_struct_			((BASE_TYPE) 2UL)
885 
#define btype_union_			( ( BASE_TYPE ) 3UL )
 869 
#define btype_union_			((BASE_TYPE) 3UL)
886 
#define btype_enum_			( ( BASE_TYPE ) 4UL )
 870 
#define btype_enum_			((BASE_TYPE) 4UL)
887 
#define btype_alias			( ( BASE_TYPE ) 5UL )
 871 
#define btype_alias			((BASE_TYPE) 5UL)
888 
#define btype_any			( ( BASE_TYPE ) 6UL )
 872 
#define btype_any			((BASE_TYPE) 6UL)
889 
#define btype_named			( ( BASE_TYPE ) 7UL )
 873 
#define btype_named			((BASE_TYPE) 7UL)
890 
#define btype_signed			( ( BASE_TYPE ) 8UL )
 874 
#define btype_signed			((BASE_TYPE) 8UL)
891 
#define btype_unsigned			( ( BASE_TYPE ) 16UL )
 875 
#define btype_unsigned			((BASE_TYPE) 16UL)
892 
#define btype_char			( ( BASE_TYPE ) 32UL )
 876 
#define btype_char			((BASE_TYPE) 32UL)
893 
#define btype_short			( ( BASE_TYPE ) 64UL )
 877 
#define btype_short			((BASE_TYPE) 64UL)
894 
#define btype_int			( ( BASE_TYPE ) 128UL )
 878 
#define btype_int			((BASE_TYPE) 128UL)
895 
#define btype_long			( ( BASE_TYPE ) 256UL )
 879 
#define btype_long			((BASE_TYPE) 256UL)
896 
#define btype_long2			( ( BASE_TYPE ) 512UL )
 880 
#define btype_long2			((BASE_TYPE) 512UL)
897 
#define btype_float			( ( BASE_TYPE ) 1024UL )
 881 
#define btype_float			((BASE_TYPE) 1024UL)
898 
#define btype_double			( ( BASE_TYPE ) 2048UL )
 882 
#define btype_double			((BASE_TYPE) 2048UL)
899 
#define btype_void			( ( BASE_TYPE ) 4096UL )
 883 
#define btype_void			((BASE_TYPE) 4096UL)
900 
#define btype_bottom			( ( BASE_TYPE ) 8192UL )
 884 
#define btype_bottom			((BASE_TYPE) 8192UL)
901 
#define btype_bool			( ( BASE_TYPE ) 16384UL )
 885 
#define btype_bool			((BASE_TYPE) 16384UL)
902 
#define btype_ptrdiff_t			( ( BASE_TYPE ) 32768UL )
 886 
#define btype_ptrdiff_t			((BASE_TYPE) 32768UL)
903 
#define btype_size_t			( ( BASE_TYPE ) 65536UL )
 887 
#define btype_size_t			((BASE_TYPE) 65536UL)
904 
#define btype_wchar_t			( ( BASE_TYPE ) 131072UL )
 888 
#define btype_wchar_t			((BASE_TYPE) 131072UL)
905 
#define btype_schar			( ( BASE_TYPE ) 40UL )
 889 
#define btype_schar			((BASE_TYPE) 40UL)
906 
#define btype_uchar			( ( BASE_TYPE ) 48UL )
 890 
#define btype_uchar			((BASE_TYPE) 48UL)
907 
#define btype_sshort			( ( BASE_TYPE ) 200UL )
 891 
#define btype_sshort			((BASE_TYPE) 200UL)
908 
#define btype_ushort			( ( BASE_TYPE ) 208UL )
 892 
#define btype_ushort			((BASE_TYPE) 208UL)
909 
#define btype_sint			( ( BASE_TYPE ) 136UL )
 893 
#define btype_sint			((BASE_TYPE) 136UL)
910 
#define btype_uint			( ( BASE_TYPE ) 144UL )
 894 
#define btype_uint			((BASE_TYPE) 144UL)
911 
#define btype_slong			( ( BASE_TYPE ) 392UL )
 895 
#define btype_slong			((BASE_TYPE) 392UL)
912 
#define btype_ulong			( ( BASE_TYPE ) 400UL )
 896 
#define btype_ulong			((BASE_TYPE) 400UL)
913 
#define btype_llong			( ( BASE_TYPE ) 768UL )
 897 
#define btype_llong			((BASE_TYPE) 768UL)
914 
#define btype_sllong			( ( BASE_TYPE ) 904UL )
 898 
#define btype_sllong			((BASE_TYPE) 904UL)
915 
#define btype_ullong			( ( BASE_TYPE ) 912UL )
 899 
#define btype_ullong			((BASE_TYPE) 912UL)
916 
#define btype_ldouble			( ( BASE_TYPE ) 2304UL )
 900 
#define btype_ldouble			((BASE_TYPE) 2304UL)
917 
#define btype_ellipsis			( ( BASE_TYPE ) 262144UL )
 901 
#define btype_ellipsis			((BASE_TYPE) 262144UL)
918 
#define btype_star			( ( BASE_TYPE ) 524288UL )
 902 
#define btype_star			((BASE_TYPE) 524288UL)
919 
#define btype_template			( ( BASE_TYPE ) 1048576UL )
 903 
#define btype_template			((BASE_TYPE) 1048576UL)
920 
#define btype_typename			( ( BASE_TYPE ) 2097152UL )
 904 
#define btype_typename			((BASE_TYPE) 2097152UL)
921 
#define btype_args			( ( BASE_TYPE ) 4194304UL )
 905 
#define btype_args			((BASE_TYPE) 4194304UL)
922 
#define btype_keyword			( ( BASE_TYPE ) 154624UL )
 906 
#define btype_keyword			((BASE_TYPE) 154624UL)
923 
#define btype_other			( ( BASE_TYPE ) 261120UL )
 907 
#define btype_other			((BASE_TYPE) 261120UL)
924 
#define btype_arith			( ( BASE_TYPE ) 1152UL )
 908 
#define btype_arith			((BASE_TYPE) 1152UL)
925 
#define btype_scalar			( ( BASE_TYPE ) 525440UL )
 909 
#define btype_scalar			((BASE_TYPE) 525440UL)
926 
#define ORDER_btype			( 4194305UL )
 910 
#define ORDER_btype			(4194305UL)
927 
#else
 911 
#else
928 
#define btype_none			( ( BASE_TYPE ) 0 )
 912 
#define btype_none			((BASE_TYPE) 0)
929 
#define btype_class			( ( BASE_TYPE ) 1 )
 913 
#define btype_class			((BASE_TYPE) 1)
930 
#define btype_struct_			( ( BASE_TYPE ) 2 )
 914 
#define btype_struct_			((BASE_TYPE) 2)
931 
#define btype_union_			( ( BASE_TYPE ) 3 )
 915 
#define btype_union_			((BASE_TYPE) 3)
932 
#define btype_enum_			( ( BASE_TYPE ) 4 )
 916 
#define btype_enum_			((BASE_TYPE) 4)
933 
#define btype_alias			( ( BASE_TYPE ) 5 )
 917 
#define btype_alias			((BASE_TYPE) 5)
934 
#define btype_any			( ( BASE_TYPE ) 6 )
 918 
#define btype_any			((BASE_TYPE) 6)
935 
#define btype_named			( ( BASE_TYPE ) 7 )
 919 
#define btype_named			((BASE_TYPE) 7)
936 
#define btype_signed			( ( BASE_TYPE ) 8 )
 920 
#define btype_signed			((BASE_TYPE) 8)
937 
#define btype_unsigned			( ( BASE_TYPE ) 16 )
 921 
#define btype_unsigned			((BASE_TYPE) 16)
938 
#define btype_char			( ( BASE_TYPE ) 32 )
 922 
#define btype_char			((BASE_TYPE) 32)
939 
#define btype_short			( ( BASE_TYPE ) 64 )
 923 
#define btype_short			((BASE_TYPE) 64)
940 
#define btype_int			( ( BASE_TYPE ) 128 )
 924 
#define btype_int			((BASE_TYPE) 128)
941 
#define btype_long			( ( BASE_TYPE ) 256 )
 925 
#define btype_long			((BASE_TYPE) 256)
942 
#define btype_long2			( ( BASE_TYPE ) 512 )
 926 
#define btype_long2			((BASE_TYPE) 512)
943 
#define btype_float			( ( BASE_TYPE ) 1024 )
 927 
#define btype_float			((BASE_TYPE) 1024)
944 
#define btype_double			( ( BASE_TYPE ) 2048 )
 928 
#define btype_double			((BASE_TYPE) 2048)
945 
#define btype_void			( ( BASE_TYPE ) 4096 )
 929 
#define btype_void			((BASE_TYPE) 4096)
946 
#define btype_bottom			( ( BASE_TYPE ) 8192 )
 930 
#define btype_bottom			((BASE_TYPE) 8192)
947 
#define btype_bool			( ( BASE_TYPE ) 16384 )
 931 
#define btype_bool			((BASE_TYPE) 16384)
948 
#define btype_ptrdiff_t			( ( BASE_TYPE ) 32768 )
 932 
#define btype_ptrdiff_t			((BASE_TYPE) 32768)
949 
#define btype_size_t			( ( BASE_TYPE ) 65536 )
 933 
#define btype_size_t			((BASE_TYPE) 65536)
950 
#define btype_wchar_t			( ( BASE_TYPE ) 131072 )
 934 
#define btype_wchar_t			((BASE_TYPE) 131072)
951 
#define btype_schar			( ( BASE_TYPE ) 40 )
 935 
#define btype_schar			((BASE_TYPE) 40)
952 
#define btype_uchar			( ( BASE_TYPE ) 48 )
 936 
#define btype_uchar			((BASE_TYPE) 48)
953 
#define btype_sshort			( ( BASE_TYPE ) 200 )
 937 
#define btype_sshort			((BASE_TYPE) 200)
954 
#define btype_ushort			( ( BASE_TYPE ) 208 )
 938 
#define btype_ushort			((BASE_TYPE) 208)
955 
#define btype_sint			( ( BASE_TYPE ) 136 )
 939 
#define btype_sint			((BASE_TYPE) 136)
956 
#define btype_uint			( ( BASE_TYPE ) 144 )
 940 
#define btype_uint			((BASE_TYPE) 144)
957 
#define btype_slong			( ( BASE_TYPE ) 392 )
 941 
#define btype_slong			((BASE_TYPE) 392)
958 
#define btype_ulong			( ( BASE_TYPE ) 400 )
 942 
#define btype_ulong			((BASE_TYPE) 400)
959 
#define btype_llong			( ( BASE_TYPE ) 768 )
 943 
#define btype_llong			((BASE_TYPE) 768)
960 
#define btype_sllong			( ( BASE_TYPE ) 904 )
 944 
#define btype_sllong			((BASE_TYPE) 904)
961 
#define btype_ullong			( ( BASE_TYPE ) 912 )
 945 
#define btype_ullong			((BASE_TYPE) 912)
962 
#define btype_ldouble			( ( BASE_TYPE ) 2304 )
 946 
#define btype_ldouble			((BASE_TYPE) 2304)
963 
#define btype_ellipsis			( ( BASE_TYPE ) 262144 )
 947 
#define btype_ellipsis			((BASE_TYPE) 262144)
964 
#define btype_star			( ( BASE_TYPE ) 524288 )
 948 
#define btype_star			((BASE_TYPE) 524288)
965 
#define btype_template			( ( BASE_TYPE ) 1048576 )
 949 
#define btype_template			((BASE_TYPE) 1048576)
966 
#define btype_typename			( ( BASE_TYPE ) 2097152 )
 950 
#define btype_typename			((BASE_TYPE) 2097152)
967 
#define btype_args			( ( BASE_TYPE ) 4194304 )
 951 
#define btype_args			((BASE_TYPE) 4194304)
968 
#define btype_keyword			( ( BASE_TYPE ) 154624 )
 952 
#define btype_keyword			((BASE_TYPE) 154624)
969 
#define btype_other			( ( BASE_TYPE ) 261120 )
 953 
#define btype_other			((BASE_TYPE) 261120)
970 
#define btype_arith			( ( BASE_TYPE ) 1152 )
 954 
#define btype_arith			((BASE_TYPE) 1152)
971 
#define btype_scalar			( ( BASE_TYPE ) 525440 )
 955 
#define btype_scalar			((BASE_TYPE) 525440)
972 
#define ORDER_btype			( ( unsigned long ) 4194305 )
 956 
#define ORDER_btype			((unsigned long) 4194305)
973 
#endif
 957 
#endif
974 
#pragma token EXP const : SIZE ( BASE_TYPE ) : SIZE_btype #
 958 
#pragma token EXP const : SIZE(BASE_TYPE) : SIZE_btype #
975 
 
 959 
 
976 
#pragma token PROC (\
 960 
#pragma token PROC(\
977 
	EXP : PTR ( BASE_TYPE ) :,\
 961 
	EXP : PTR(BASE_TYPE) :,\
978 
	EXP : BASE_TYPE :\
 962 
	EXP : BASE_TYPE :\
979 
    ) EXP : void : COPY_btype #
 963 
    ) EXP : void : COPY_btype #
980 
 
 964 
 
981 
#pragma token PROC (\
 965 
#pragma token PROC(\
982 
	EXP : PTR ( BASE_TYPE ) :\
 966 
	EXP : PTR(BASE_TYPE) :\
983 
    ) EXP : BASE_TYPE : DEREF_btype #
 967 
    ) EXP : BASE_TYPE : DEREF_btype #
984 
 
 968 
 
985 
#pragma interface SIZE_btype COPY_btype DEREF_btype
 969 
#pragma interface SIZE_btype COPY_btype DEREF_btype
986 
 
 970 
 
987 
 
 971 
 
988 
/* Definitions for enumeration CLASS_INFO */
 972 
/* Definitions for enumeration CLASS_INFO */
989 
 
 973 
 
990 
#ifdef __STDC__
 974 
#ifdef __STDC__
991 
#define cinfo_none			( ( CLASS_INFO ) 0UL )
 975 
#define cinfo_none			((CLASS_INFO) 0UL)
992 
#define cinfo_complete			( ( CLASS_INFO ) 1UL )
 976 
#define cinfo_complete			((CLASS_INFO) 1UL)
993 
#define cinfo_defined			( ( CLASS_INFO ) 2UL )
 977 
#define cinfo_defined			((CLASS_INFO) 2UL)
994 
#define cinfo_struct_			( ( CLASS_INFO ) 4UL )
 978 
#define cinfo_struct_			((CLASS_INFO) 4UL)
995 
#define cinfo_union_			( ( CLASS_INFO ) 8UL )
 979 
#define cinfo_union_			((CLASS_INFO) 8UL)
996 
#define cinfo_template			( ( CLASS_INFO ) 16UL )
 980 
#define cinfo_template			((CLASS_INFO) 16UL)
997 
#define cinfo_token			( ( CLASS_INFO ) 32UL )
 981 
#define cinfo_token			((CLASS_INFO) 32UL)
998 
#define cinfo_pod			( ( CLASS_INFO ) 64UL )
 982 
#define cinfo_pod			((CLASS_INFO) 64UL)
999 
#define cinfo_nested			( ( CLASS_INFO ) 128UL )
 983 
#define cinfo_nested			((CLASS_INFO) 128UL)
1000 
#define cinfo_rescan			( ( CLASS_INFO ) 256UL )
 984 
#define cinfo_rescan			((CLASS_INFO) 256UL)
1001 
#define cinfo_recursive			( ( CLASS_INFO ) 512UL )
 985 
#define cinfo_recursive			((CLASS_INFO) 512UL)
1002 
#define cinfo_incomplete		( ( CLASS_INFO ) 1024UL )
 986 
#define cinfo_incomplete		((CLASS_INFO) 1024UL)
1003 
#define cinfo_base			( ( CLASS_INFO ) 2048UL )
 987 
#define cinfo_base			((CLASS_INFO) 2048UL)
1004 
#define cinfo_multiple_base		( ( CLASS_INFO ) 4096UL )
 988 
#define cinfo_multiple_base		((CLASS_INFO) 4096UL)
1005 
#define cinfo_virtual_base		( ( CLASS_INFO ) 8192UL )
 989 
#define cinfo_virtual_base		((CLASS_INFO) 8192UL)
1006 
#define cinfo_templ_base		( ( CLASS_INFO ) 16384UL )
 990 
#define cinfo_templ_base		((CLASS_INFO) 16384UL)
1007 
#define cinfo_ambiguous			( ( CLASS_INFO ) 32768UL )
 991 
#define cinfo_ambiguous			((CLASS_INFO) 32768UL)
1008 
#define cinfo_empty			( ( CLASS_INFO ) 65536UL )
 992 
#define cinfo_empty			((CLASS_INFO) 65536UL)
1009 
#define cinfo_private			( ( CLASS_INFO ) 131072UL )
 993 
#define cinfo_private			((CLASS_INFO) 131072UL)
1010 
#define cinfo_const			( ( CLASS_INFO ) 262144UL )
 994 
#define cinfo_const			((CLASS_INFO) 262144UL)
1011 
#define cinfo_static			( ( CLASS_INFO ) 524288UL )
 995 
#define cinfo_static			((CLASS_INFO) 524288UL)
1012 
#define cinfo_function			( ( CLASS_INFO ) 1048576UL )
 996 
#define cinfo_function			((CLASS_INFO) 1048576UL)
1013 
#define cinfo_params			( ( CLASS_INFO ) 2097152UL )
 997 
#define cinfo_params			((CLASS_INFO) 2097152UL)
1014 
#define cinfo_polymorphic		( ( CLASS_INFO ) 4194304UL )
 998 
#define cinfo_polymorphic		((CLASS_INFO) 4194304UL)
1015 
#define cinfo_poly_base			( ( CLASS_INFO ) 8388608UL )
 999 
#define cinfo_poly_base			((CLASS_INFO) 8388608UL)
1016 
#define cinfo_abstract			( ( CLASS_INFO ) 16777216UL )
 1000 
#define cinfo_abstract			((CLASS_INFO) 16777216UL)
1017 
#define cinfo_trivial_constr		( ( CLASS_INFO ) 33554432UL )
 1001 
#define cinfo_trivial_constr		((CLASS_INFO) 33554432UL)
1018 
#define cinfo_trivial_destr		( ( CLASS_INFO ) 67108864UL )
 1002 
#define cinfo_trivial_destr		((CLASS_INFO) 67108864UL)
1019 
#define cinfo_trivial_copy		( ( CLASS_INFO ) 134217728UL )
 1003 
#define cinfo_trivial_copy		((CLASS_INFO) 134217728UL)
1020 
#define cinfo_trivial_assign		( ( CLASS_INFO ) 268435456UL )
 1004 
#define cinfo_trivial_assign		((CLASS_INFO) 268435456UL)
1021 
#define cinfo_const_copy		( ( CLASS_INFO ) 536870912UL )
 1005 
#define cinfo_const_copy		((CLASS_INFO) 536870912UL)
1022 
#define cinfo_const_assign		( ( CLASS_INFO ) 1073741824UL )
 1006 
#define cinfo_const_assign		((CLASS_INFO) 1073741824UL)
1023 
#define cinfo_usr_constr		( ( CLASS_INFO ) 2147483648UL )
 1007 
#define cinfo_usr_constr		((CLASS_INFO) 2147483648UL)
1024 
#define cinfo_key			( ( CLASS_INFO ) 12UL )
 1008 
#define cinfo_key			((CLASS_INFO) 12UL)
1025 
#define cinfo_non_aggregate		( ( CLASS_INFO ) 2151811104UL )
 1009 
#define cinfo_non_aggregate		((CLASS_INFO) 2151811104UL)
1026 
#define cinfo_force_copy		( ( CLASS_INFO ) 3670016UL )
 1010 
#define cinfo_force_copy		((CLASS_INFO) 3670016UL)
1027 
#define cinfo_trivial_make		( ( CLASS_INFO ) 436207616UL )
 1011 
#define cinfo_trivial_make		((CLASS_INFO) 436207616UL)
1028 
#define cinfo_trivial			( ( CLASS_INFO ) 503316480UL )
 1012 
#define cinfo_trivial			((CLASS_INFO) 503316480UL)
1029 
#define cinfo_implicit			( ( CLASS_INFO ) 2113929216UL )
 1013 
#define cinfo_implicit			((CLASS_INFO) 2113929216UL)
1030 
#define cinfo_default			( ( CLASS_INFO ) 2113994816UL )
 1014 
#define cinfo_default			((CLASS_INFO) 2113994816UL)
1031 
#define ORDER_cinfo			( 2151811105UL )
 1015 
#define ORDER_cinfo			(2151811105UL)
1032 
#else
 1016 
#else
1033 
#define cinfo_none			( ( CLASS_INFO ) 0 )
 1017 
#define cinfo_none			((CLASS_INFO) 0)
1034 
#define cinfo_complete			( ( CLASS_INFO ) 1 )
 1018 
#define cinfo_complete			((CLASS_INFO) 1)
1035 
#define cinfo_defined			( ( CLASS_INFO ) 2 )
 1019 
#define cinfo_defined			((CLASS_INFO) 2)
1036 
#define cinfo_struct_			( ( CLASS_INFO ) 4 )
 1020 
#define cinfo_struct_			((CLASS_INFO) 4)
1037 
#define cinfo_union_			( ( CLASS_INFO ) 8 )
 1021 
#define cinfo_union_			((CLASS_INFO) 8)
1038 
#define cinfo_template			( ( CLASS_INFO ) 16 )
 1022 
#define cinfo_template			((CLASS_INFO) 16)
1039 
#define cinfo_token			( ( CLASS_INFO ) 32 )
 1023 
#define cinfo_token			((CLASS_INFO) 32)
1040 
#define cinfo_pod			( ( CLASS_INFO ) 64 )
 1024 
#define cinfo_pod			((CLASS_INFO) 64)
1041 
#define cinfo_nested			( ( CLASS_INFO ) 128 )
 1025 
#define cinfo_nested			((CLASS_INFO) 128)
1042 
#define cinfo_rescan			( ( CLASS_INFO ) 256 )
 1026 
#define cinfo_rescan			((CLASS_INFO) 256)
1043 
#define cinfo_recursive			( ( CLASS_INFO ) 512 )
 1027 
#define cinfo_recursive			((CLASS_INFO) 512)
1044 
#define cinfo_incomplete		( ( CLASS_INFO ) 1024 )
 1028 
#define cinfo_incomplete		((CLASS_INFO) 1024)
1045 
#define cinfo_base			( ( CLASS_INFO ) 2048 )
 1029 
#define cinfo_base			((CLASS_INFO) 2048)
1046 
#define cinfo_multiple_base		( ( CLASS_INFO ) 4096 )
 1030 
#define cinfo_multiple_base		((CLASS_INFO) 4096)
1047 
#define cinfo_virtual_base		( ( CLASS_INFO ) 8192 )
 1031 
#define cinfo_virtual_base		((CLASS_INFO) 8192)
1048 
#define cinfo_templ_base		( ( CLASS_INFO ) 16384 )
 1032 
#define cinfo_templ_base		((CLASS_INFO) 16384)
1049 
#define cinfo_ambiguous			( ( CLASS_INFO ) 32768 )
 1033 
#define cinfo_ambiguous			((CLASS_INFO) 32768)
1050 
#define cinfo_empty			( ( CLASS_INFO ) 65536 )
 1034 
#define cinfo_empty			((CLASS_INFO) 65536)
1051 
#define cinfo_private			( ( CLASS_INFO ) 131072 )
 1035 
#define cinfo_private			((CLASS_INFO) 131072)
1052 
#define cinfo_const			( ( CLASS_INFO ) 262144 )
 1036 
#define cinfo_const			((CLASS_INFO) 262144)
1053 
#define cinfo_static			( ( CLASS_INFO ) 524288 )
 1037 
#define cinfo_static			((CLASS_INFO) 524288)
1054 
#define cinfo_function			( ( CLASS_INFO ) 1048576 )
 1038 
#define cinfo_function			((CLASS_INFO) 1048576)
1055 
#define cinfo_params			( ( CLASS_INFO ) 2097152 )
 1039 
#define cinfo_params			((CLASS_INFO) 2097152)
1056 
#define cinfo_polymorphic		( ( CLASS_INFO ) 4194304 )
 1040 
#define cinfo_polymorphic		((CLASS_INFO) 4194304)
1057 
#define cinfo_poly_base			( ( CLASS_INFO ) 8388608 )
 1041 
#define cinfo_poly_base			((CLASS_INFO) 8388608)
1058 
#define cinfo_abstract			( ( CLASS_INFO ) 16777216 )
 1042 
#define cinfo_abstract			((CLASS_INFO) 16777216)
1059 
#define cinfo_trivial_constr		( ( CLASS_INFO ) 33554432 )
 1043 
#define cinfo_trivial_constr		((CLASS_INFO) 33554432)
1060 
#define cinfo_trivial_destr		( ( CLASS_INFO ) 67108864 )
 1044 
#define cinfo_trivial_destr		((CLASS_INFO) 67108864)
1061 
#define cinfo_trivial_copy		( ( CLASS_INFO ) 134217728 )
 1045 
#define cinfo_trivial_copy		((CLASS_INFO) 134217728)
1062 
#define cinfo_trivial_assign		( ( CLASS_INFO ) 268435456 )
 1046 
#define cinfo_trivial_assign		((CLASS_INFO) 268435456)
1063 
#define cinfo_const_copy		( ( CLASS_INFO ) 536870912 )
 1047 
#define cinfo_const_copy		((CLASS_INFO) 536870912)
1064 
#define cinfo_const_assign		( ( CLASS_INFO ) 1073741824 )
 1048 
#define cinfo_const_assign		((CLASS_INFO) 1073741824)
1065 
#define cinfo_usr_constr		( ( CLASS_INFO ) 2147483648 )
 1049 
#define cinfo_usr_constr		((CLASS_INFO) 2147483648)
1066 
#define cinfo_key			( ( CLASS_INFO ) 12 )
 1050 
#define cinfo_key			((CLASS_INFO) 12)
1067 
#define cinfo_non_aggregate		( ( CLASS_INFO ) 2151811104 )
 1051 
#define cinfo_non_aggregate		((CLASS_INFO) 2151811104)
1068 
#define cinfo_force_copy		( ( CLASS_INFO ) 3670016 )
 1052 
#define cinfo_force_copy		((CLASS_INFO) 3670016)
1069 
#define cinfo_trivial_make		( ( CLASS_INFO ) 436207616 )
 1053 
#define cinfo_trivial_make		((CLASS_INFO) 436207616)
1070 
#define cinfo_trivial			( ( CLASS_INFO ) 503316480 )
 1054 
#define cinfo_trivial			((CLASS_INFO) 503316480)
1071 
#define cinfo_implicit			( ( CLASS_INFO ) 2113929216 )
 1055 
#define cinfo_implicit			((CLASS_INFO) 2113929216)
1072 
#define cinfo_default			( ( CLASS_INFO ) 2113994816 )
 1056 
#define cinfo_default			((CLASS_INFO) 2113994816)
1073 
#define ORDER_cinfo			( ( unsigned long ) 2151811105 )
 1057 
#define ORDER_cinfo			((unsigned long) 2151811105)
1074 
#endif
 1058 
#endif
1075 
#pragma token EXP const : SIZE ( CLASS_INFO ) : SIZE_cinfo #
 1059 
#pragma token EXP const : SIZE(CLASS_INFO) : SIZE_cinfo #
1076 
 
 1060 
 
1077 
#pragma token PROC (\
 1061 
#pragma token PROC(\
1078 
	EXP : PTR ( CLASS_INFO ) :,\
 1062 
	EXP : PTR(CLASS_INFO) :,\
1079 
	EXP : CLASS_INFO :\
 1063 
	EXP : CLASS_INFO :\
1080 
    ) EXP : void : COPY_cinfo #
 1064 
    ) EXP : void : COPY_cinfo #
1081 
 
 1065 
 
1082 
#pragma token PROC (\
 1066 
#pragma token PROC(\
1083 
	EXP : PTR ( CLASS_INFO ) :\
 1067 
	EXP : PTR(CLASS_INFO) :\
1084 
    ) EXP : CLASS_INFO : DEREF_cinfo #
 1068 
    ) EXP : CLASS_INFO : DEREF_cinfo #
1085 
 
 1069 
 
1086 
#pragma interface SIZE_cinfo COPY_cinfo DEREF_cinfo
 1070 
#pragma interface SIZE_cinfo COPY_cinfo DEREF_cinfo
1087 
 
 1071 
 
1088 
 
 1072 
 
1089 
/* Definitions for enumeration CLASS_USAGE */
 1073 
/* Definitions for enumeration CLASS_USAGE */
1090 
 
 1074 
 
1091 
#define cusage_none			( ( CLASS_USAGE ) 0 )
 1075 
#define cusage_none			((CLASS_USAGE) 0)
1092 
#define cusage_address			( ( CLASS_USAGE ) 1 )
 1076 
#define cusage_address			((CLASS_USAGE) 1)
1093 
#define cusage_destr			( ( CLASS_USAGE ) 2 )
 1077 
#define cusage_destr			((CLASS_USAGE) 2)
1094 
#define cusage_delete			( ( CLASS_USAGE ) 4 )
 1078 
#define cusage_delete			((CLASS_USAGE) 4)
1095 
#define cusage_delete_array		( ( CLASS_USAGE ) 8 )
 1079 
#define cusage_delete_array		((CLASS_USAGE) 8)
1096 
#define ORDER_cusage			( ( unsigned long ) 9 )
 1080 
#define ORDER_cusage			((unsigned long) 9)
1097 
#pragma token EXP const : SIZE ( CLASS_USAGE ) : SIZE_cusage #
 1081 
#pragma token EXP const : SIZE(CLASS_USAGE) : SIZE_cusage #
1098 
 
 1082 
 
1099 
#pragma token PROC (\
 1083 
#pragma token PROC(\
1100 
	EXP : PTR ( CLASS_USAGE ) :,\
 1084 
	EXP : PTR(CLASS_USAGE) :,\
1101 
	EXP : CLASS_USAGE :\
 1085 
	EXP : CLASS_USAGE :\
1102 
    ) EXP : void : COPY_cusage #
 1086 
    ) EXP : void : COPY_cusage #
1103 
 
 1087 
 
1104 
#pragma token PROC (\
 1088 
#pragma token PROC(\
1105 
	EXP : PTR ( CLASS_USAGE ) :\
 1089 
	EXP : PTR(CLASS_USAGE) :\
1106 
    ) EXP : CLASS_USAGE : DEREF_cusage #
 1090 
    ) EXP : CLASS_USAGE : DEREF_cusage #
1107 
 
 1091 
 
1108 
#pragma interface SIZE_cusage COPY_cusage DEREF_cusage
 1092 
#pragma interface SIZE_cusage COPY_cusage DEREF_cusage
1109 
 
 1093 
 
1110 
 
 1094 
 
1111 
/* Definitions for enumeration DECL_SPEC */
 1095 
/* Definitions for enumeration DECL_SPEC */
1112 
 
 1096 
 
1113 
#ifdef __STDC__
 1097 
#ifdef __STDC__
1114 
#define dspec_none			( ( DECL_SPEC ) 0UL )
 1098 
#define dspec_none			((DECL_SPEC) 0UL)
1115 
#define dspec_used			( ( DECL_SPEC ) 1UL )
 1099 
#define dspec_used			((DECL_SPEC) 1UL)
1116 
#define dspec_called			( ( DECL_SPEC ) 2UL )
 1100 
#define dspec_called			((DECL_SPEC) 2UL)
1117 
#define dspec_defn			( ( DECL_SPEC ) 4UL )
 1101 
#define dspec_defn			((DECL_SPEC) 4UL)
1118 
#define dspec_inherit			( ( DECL_SPEC ) 8UL )
 1102 
#define dspec_inherit			((DECL_SPEC) 8UL)
1119 
#define dspec_alias			( ( DECL_SPEC ) 16UL )
 1103 
#define dspec_alias			((DECL_SPEC) 16UL)
1120 
#define dspec_done			( ( DECL_SPEC ) 32UL )
 1104 
#define dspec_done			((DECL_SPEC) 32UL)
1121 
#define dspec_static			( ( DECL_SPEC ) 64UL )
 1105 
#define dspec_static			((DECL_SPEC) 64UL)
1122 
#define dspec_extern			( ( DECL_SPEC ) 128UL )
 1106 
#define dspec_extern			((DECL_SPEC) 128UL)
1123 
#define dspec_auto			( ( DECL_SPEC ) 256UL )
 1107 
#define dspec_auto			((DECL_SPEC) 256UL)
1124 
#define dspec_register			( ( DECL_SPEC ) 512UL )
 1108 
#define dspec_register			((DECL_SPEC) 512UL)
1125 
#define dspec_mutable			( ( DECL_SPEC ) 1024UL )
 1109 
#define dspec_mutable			((DECL_SPEC) 1024UL)
1126 
#define dspec_inline			( ( DECL_SPEC ) 2048UL )
 1110 
#define dspec_inline			((DECL_SPEC) 2048UL)
1127 
#define dspec_virtual			( ( DECL_SPEC ) 4096UL )
 1111 
#define dspec_virtual			((DECL_SPEC) 4096UL)
1128 
#define dspec_explicit			( ( DECL_SPEC ) 8192UL )
 1112 
#define dspec_explicit			((DECL_SPEC) 8192UL)
1129 
#define dspec_friend			( ( DECL_SPEC ) 16384UL )
 1113 
#define dspec_friend			((DECL_SPEC) 16384UL)
1130 
#define dspec_typedef			( ( DECL_SPEC ) 32768UL )
 1114 
#define dspec_typedef			((DECL_SPEC) 32768UL)
1131 
#define dspec_public			( ( DECL_SPEC ) 65536UL )
 1115 
#define dspec_public			((DECL_SPEC) 65536UL)
1132 
#define dspec_protected			( ( DECL_SPEC ) 131072UL )
 1116 
#define dspec_protected			((DECL_SPEC) 131072UL)
1133 
#define dspec_private			( ( DECL_SPEC ) 196608UL )
 1117 
#define dspec_private			((DECL_SPEC) 196608UL)
1134 
#define dspec_public2			( ( DECL_SPEC ) 262144UL )
 1118 
#define dspec_public2			((DECL_SPEC) 262144UL)
1135 
#define dspec_protected2		( ( DECL_SPEC ) 524288UL )
 1119 
#define dspec_protected2		((DECL_SPEC) 524288UL)
1136 
#define dspec_private2			( ( DECL_SPEC ) 786432UL )
 1120 
#define dspec_private2			((DECL_SPEC) 786432UL)
1137 
#define dspec_c				( ( DECL_SPEC ) 1048576UL )
 1121 
#define dspec_c				((DECL_SPEC) 1048576UL)
1138 
#define dspec_cpp			( ( DECL_SPEC ) 2097152UL )
 1122 
#define dspec_cpp			((DECL_SPEC) 2097152UL)
1139 
#define dspec_ignore			( ( DECL_SPEC ) 4194304UL )
 1123 
#define dspec_ignore			((DECL_SPEC) 4194304UL)
1140 
#define dspec_implicit			( ( DECL_SPEC ) 8388608UL )
 1124 
#define dspec_implicit			((DECL_SPEC) 8388608UL)
1141 
#define dspec_instance			( ( DECL_SPEC ) 16777216UL )
 1125 
#define dspec_instance			((DECL_SPEC) 16777216UL)
1142 
#define dspec_main			( ( DECL_SPEC ) 33554432UL )
 1126 
#define dspec_main			((DECL_SPEC) 33554432UL)
1143 
#define dspec_pure			( ( DECL_SPEC ) 67108864UL )
 1127 
#define dspec_pure			((DECL_SPEC) 67108864UL)
1144 
#define dspec_reserve			( ( DECL_SPEC ) 134217728UL )
 1128 
#define dspec_reserve			((DECL_SPEC) 134217728UL)
1145 
#define dspec_temp			( ( DECL_SPEC ) 268435456UL )
 1129 
#define dspec_temp			((DECL_SPEC) 268435456UL)
1146 
#define dspec_template			( ( DECL_SPEC ) 536870912UL )
 1130 
#define dspec_template			((DECL_SPEC) 536870912UL)
1147 
#define dspec_token			( ( DECL_SPEC ) 1073741824UL )
 1131 
#define dspec_token			((DECL_SPEC) 1073741824UL)
1148 
#define dspec_trivial			( ( DECL_SPEC ) 2147483648UL )
 1132 
#define dspec_trivial			((DECL_SPEC) 2147483648UL)
1149 
#define dspec_linkage			( ( DECL_SPEC ) 192UL )
 1133 
#define dspec_linkage			((DECL_SPEC) 192UL)
1150 
#define dspec_storage			( ( DECL_SPEC ) 1984UL )
 1134 
#define dspec_storage			((DECL_SPEC) 1984UL)
1151 
#define dspec_function			( ( DECL_SPEC ) 14336UL )
 1135 
#define dspec_function			((DECL_SPEC) 14336UL)
1152 
#define dspec_keyword			( ( DECL_SPEC ) 65472UL )
 1136 
#define dspec_keyword			((DECL_SPEC) 65472UL)
1153 
#define dspec_duplicate			( ( DECL_SPEC ) 65472UL )
 1137 
#define dspec_duplicate			((DECL_SPEC) 65472UL)
1154 
#define dspec_access			( ( DECL_SPEC ) 196608UL )
 1138 
#define dspec_access			((DECL_SPEC) 196608UL)
1155 
#define dspec_access2			( ( DECL_SPEC ) 786432UL )
 1139 
#define dspec_access2			((DECL_SPEC) 786432UL)
1156 
#define dspec_language			( ( DECL_SPEC ) 3145728UL )
 1140 
#define dspec_language			((DECL_SPEC) 3145728UL)
1157 
#define dspec_other			( ( DECL_SPEC ) 4290772992UL )
 1141 
#define dspec_other			((DECL_SPEC) 4290772992UL)
1158 
#define ORDER_dspec			( 4290772993UL )
 1142 
#define ORDER_dspec			(4290772993UL)
1159 
#else
 1143 
#else
1160 
#define dspec_none			( ( DECL_SPEC ) 0 )
 1144 
#define dspec_none			((DECL_SPEC) 0)
1161 
#define dspec_used			( ( DECL_SPEC ) 1 )
 1145 
#define dspec_used			((DECL_SPEC) 1)
1162 
#define dspec_called			( ( DECL_SPEC ) 2 )
 1146 
#define dspec_called			((DECL_SPEC) 2)
1163 
#define dspec_defn			( ( DECL_SPEC ) 4 )
 1147 
#define dspec_defn			((DECL_SPEC) 4)
1164 
#define dspec_inherit			( ( DECL_SPEC ) 8 )
 1148 
#define dspec_inherit			((DECL_SPEC) 8)
1165 
#define dspec_alias			( ( DECL_SPEC ) 16 )
 1149 
#define dspec_alias			((DECL_SPEC) 16)
1166 
#define dspec_done			( ( DECL_SPEC ) 32 )
 1150 
#define dspec_done			((DECL_SPEC) 32)
1167 
#define dspec_static			( ( DECL_SPEC ) 64 )
 1151 
#define dspec_static			((DECL_SPEC) 64)
1168 
#define dspec_extern			( ( DECL_SPEC ) 128 )
 1152 
#define dspec_extern			((DECL_SPEC) 128)
1169 
#define dspec_auto			( ( DECL_SPEC ) 256 )
 1153 
#define dspec_auto			((DECL_SPEC) 256)
1170 
#define dspec_register			( ( DECL_SPEC ) 512 )
 1154 
#define dspec_register			((DECL_SPEC) 512)
1171 
#define dspec_mutable			( ( DECL_SPEC ) 1024 )
 1155 
#define dspec_mutable			((DECL_SPEC) 1024)
1172 
#define dspec_inline			( ( DECL_SPEC ) 2048 )
 1156 
#define dspec_inline			((DECL_SPEC) 2048)
1173 
#define dspec_virtual			( ( DECL_SPEC ) 4096 )
 1157 
#define dspec_virtual			((DECL_SPEC) 4096)
1174 
#define dspec_explicit			( ( DECL_SPEC ) 8192 )
 1158 
#define dspec_explicit			((DECL_SPEC) 8192)
1175 
#define dspec_friend			( ( DECL_SPEC ) 16384 )
 1159 
#define dspec_friend			((DECL_SPEC) 16384)
1176 
#define dspec_typedef			( ( DECL_SPEC ) 32768 )
 1160 
#define dspec_typedef			((DECL_SPEC) 32768)
1177 
#define dspec_public			( ( DECL_SPEC ) 65536 )
 1161 
#define dspec_public			((DECL_SPEC) 65536)
1178 
#define dspec_protected			( ( DECL_SPEC ) 131072 )
 1162 
#define dspec_protected			((DECL_SPEC) 131072)
1179 
#define dspec_private			( ( DECL_SPEC ) 196608 )
 1163 
#define dspec_private			((DECL_SPEC) 196608)
1180 
#define dspec_public2			( ( DECL_SPEC ) 262144 )
 1164 
#define dspec_public2			((DECL_SPEC) 262144)
1181 
#define dspec_protected2		( ( DECL_SPEC ) 524288 )
 1165 
#define dspec_protected2		((DECL_SPEC) 524288)
1182 
#define dspec_private2			( ( DECL_SPEC ) 786432 )
 1166 
#define dspec_private2			((DECL_SPEC) 786432)
1183 
#define dspec_c				( ( DECL_SPEC ) 1048576 )
 1167 
#define dspec_c				((DECL_SPEC) 1048576)
1184 
#define dspec_cpp			( ( DECL_SPEC ) 2097152 )
 1168 
#define dspec_cpp			((DECL_SPEC) 2097152)
1185 
#define dspec_ignore			( ( DECL_SPEC ) 4194304 )
 1169 
#define dspec_ignore			((DECL_SPEC) 4194304)
1186 
#define dspec_implicit			( ( DECL_SPEC ) 8388608 )
 1170 
#define dspec_implicit			((DECL_SPEC) 8388608)
1187 
#define dspec_instance			( ( DECL_SPEC ) 16777216 )
 1171 
#define dspec_instance			((DECL_SPEC) 16777216)
1188 
#define dspec_main			( ( DECL_SPEC ) 33554432 )
 1172 
#define dspec_main			((DECL_SPEC) 33554432)
1189 
#define dspec_pure			( ( DECL_SPEC ) 67108864 )
 1173 
#define dspec_pure			((DECL_SPEC) 67108864)
1190 
#define dspec_reserve			( ( DECL_SPEC ) 134217728 )
 1174 
#define dspec_reserve			((DECL_SPEC) 134217728)
1191 
#define dspec_temp			( ( DECL_SPEC ) 268435456 )
 1175 
#define dspec_temp			((DECL_SPEC) 268435456)
1192 
#define dspec_template			( ( DECL_SPEC ) 536870912 )
 1176 
#define dspec_template			((DECL_SPEC) 536870912)
1193 
#define dspec_token			( ( DECL_SPEC ) 1073741824 )
 1177 
#define dspec_token			((DECL_SPEC) 1073741824)
1194 
#define dspec_trivial			( ( DECL_SPEC ) 2147483648 )
 1178 
#define dspec_trivial			((DECL_SPEC) 2147483648)
1195 
#define dspec_linkage			( ( DECL_SPEC ) 192 )
 1179 
#define dspec_linkage			((DECL_SPEC) 192)
1196 
#define dspec_storage			( ( DECL_SPEC ) 1984 )
 1180 
#define dspec_storage			((DECL_SPEC) 1984)
1197 
#define dspec_function			( ( DECL_SPEC ) 14336 )
 1181 
#define dspec_function			((DECL_SPEC) 14336)
1198 
#define dspec_keyword			( ( DECL_SPEC ) 65472 )
 1182 
#define dspec_keyword			((DECL_SPEC) 65472)
1199 
#define dspec_duplicate			( ( DECL_SPEC ) 65472 )
 1183 
#define dspec_duplicate			((DECL_SPEC) 65472)
1200 
#define dspec_access			( ( DECL_SPEC ) 196608 )
 1184 
#define dspec_access			((DECL_SPEC) 196608)
1201 
#define dspec_access2			( ( DECL_SPEC ) 786432 )
 1185 
#define dspec_access2			((DECL_SPEC) 786432)
1202 
#define dspec_language			( ( DECL_SPEC ) 3145728 )
 1186 
#define dspec_language			((DECL_SPEC) 3145728)
1203 
#define dspec_other			( ( DECL_SPEC ) 4290772992 )
 1187 
#define dspec_other			((DECL_SPEC) 4290772992)
1204 
#define ORDER_dspec			( ( unsigned long ) 4290772993 )
 1188 
#define ORDER_dspec			((unsigned long) 4290772993)
1205 
#endif
 1189 
#endif
1206 
#pragma token EXP const : SIZE ( DECL_SPEC ) : SIZE_dspec #
 1190 
#pragma token EXP const : SIZE(DECL_SPEC) : SIZE_dspec #
1207 
 
 1191 
 
1208 
#pragma token PROC (\
 1192 
#pragma token PROC(\
1209 
	EXP : PTR ( DECL_SPEC ) :,\
 1193 
	EXP : PTR(DECL_SPEC) :,\
1210 
	EXP : DECL_SPEC :\
 1194 
	EXP : DECL_SPEC :\
1211 
    ) EXP : void : COPY_dspec #
 1195 
    ) EXP : void : COPY_dspec #
1212 
 
 1196 
 
1213 
#pragma token PROC (\
 1197 
#pragma token PROC(\
1214 
	EXP : PTR ( DECL_SPEC ) :\
 1198 
	EXP : PTR(DECL_SPEC) :\
1215 
    ) EXP : DECL_SPEC : DEREF_dspec #
 1199 
    ) EXP : DECL_SPEC : DEREF_dspec #
1216 
 
 1200 
 
1217 
#pragma token PROC (\
 1201 
#pragma token PROC(\
1218 
	EXP : DECL_SPEC :,\
 1202 
	EXP : DECL_SPEC :,\
1219 
	EXP : LIST ( DECL_SPEC ) :,\
 1203 
	EXP : LIST(DECL_SPEC) :,\
1220 
	EXP lvalue : LIST ( DECL_SPEC ) :\
 1204 
	EXP lvalue : LIST(DECL_SPEC) :\
1221 
    ) STATEMENT CONS_dspec #
 1205 
    ) STATEMENT CONS_dspec #
1222 
 
 1206 
 
1223 
#pragma token PROC (\
 1207 
#pragma token PROC(\
1224 
	EXP lvalue : DECL_SPEC :,\
 1208 
	EXP lvalue : DECL_SPEC :,\
1225 
	EXP lvalue : LIST ( DECL_SPEC ) :,\
 1209 
	EXP lvalue : LIST(DECL_SPEC) :,\
1226 
	EXP : LIST ( DECL_SPEC ) :\
 1210 
	EXP : LIST(DECL_SPEC) :\
1227 
    ) STATEMENT UN_CONS_dspec #
 1211 
    ) STATEMENT UN_CONS_dspec #
1228 
 
 1212 
 
1229 
#pragma token PROC (\
 1213 
#pragma token PROC(\
1230 
	EXP : DESTROYER :,\
 1214 
	EXP : DESTROYER :,\
1231 
	EXP lvalue : DECL_SPEC :,\
 1215 
	EXP lvalue : DECL_SPEC :,\
1232 
	EXP lvalue : LIST ( DECL_SPEC ) :,\
 1216 
	EXP lvalue : LIST(DECL_SPEC) :,\
1233 
	EXP : LIST ( DECL_SPEC ) :\
 1217 
	EXP : LIST(DECL_SPEC) :\
1234 
    ) STATEMENT DESTROY_CONS_dspec #
 1218 
    ) STATEMENT DESTROY_CONS_dspec #
1235 
 
 1219 
 
1236 
#pragma token PROC (\
 1220 
#pragma token PROC(\
1237 
	EXP : DECL_SPEC :,\
 1221 
	EXP : DECL_SPEC :,\
1238 
	EXP lvalue : STACK ( DECL_SPEC ) :\
 1222 
	EXP lvalue : STACK(DECL_SPEC) :\
1239 
    ) STATEMENT PUSH_dspec #
 1223 
    ) STATEMENT PUSH_dspec #
1240 
 
 1224 
 
1241 
#pragma token PROC (\
 1225 
#pragma token PROC(\
1242 
	EXP lvalue : DECL_SPEC :,\
 1226 
	EXP lvalue : DECL_SPEC :,\
1243 
	EXP lvalue : STACK ( DECL_SPEC ) :\
 1227 
	EXP lvalue : STACK(DECL_SPEC) :\
1244 
    ) STATEMENT POP_dspec #
 1228 
    ) STATEMENT POP_dspec #
1245 
 
 1229 
 
1246 
#pragma interface SIZE_dspec COPY_dspec DEREF_dspec
 1230 
#pragma interface SIZE_dspec COPY_dspec DEREF_dspec
1247 
#pragma interface CONS_dspec UN_CONS_dspec DESTROY_CONS_dspec
 1231 
#pragma interface CONS_dspec UN_CONS_dspec DESTROY_CONS_dspec
1248 
#pragma interface PUSH_dspec POP_dspec
 1232 
#pragma interface PUSH_dspec POP_dspec
1249 
 
 1233 
 
1250 
 
 1234 
 
1251 
/* Definitions for enumeration QUALIFIER */
 1235 
/* Definitions for enumeration QUALIFIER */
1252 
 
 1236 
 
1253 
#define qual_none			( ( QUALIFIER ) 0 )
 1237 
#define qual_none			((QUALIFIER) 0)
1254 
#define qual_nested			( ( QUALIFIER ) 1 )
 1238 
#define qual_nested			((QUALIFIER) 1)
1255 
#define qual_full			( ( QUALIFIER ) 2 )
 1239 
#define qual_full			((QUALIFIER) 2)
1256 
#define qual_top			( ( QUALIFIER ) 3 )
 1240 
#define qual_top			((QUALIFIER) 3)
1257 
#define qual_mark			( ( QUALIFIER ) 4 )
 1241 
#define qual_mark			((QUALIFIER) 4)
1258 
#define qual_explicit			( ( QUALIFIER ) 3 )
 1242 
#define qual_explicit			((QUALIFIER) 3)
1259 
#define ORDER_qual			( ( unsigned long ) 5 )
 1243 
#define ORDER_qual			((unsigned long) 5)
1260 
#pragma token EXP const : SIZE ( QUALIFIER ) : SIZE_qual #
 1244 
#pragma token EXP const : SIZE(QUALIFIER) : SIZE_qual #
1261 
 
 1245 
 
1262 
#pragma token PROC (\
 1246 
#pragma token PROC(\
1263 
	EXP : PTR ( QUALIFIER ) :,\
 1247 
	EXP : PTR(QUALIFIER) :,\
1264 
	EXP : QUALIFIER :\
 1248 
	EXP : QUALIFIER :\
1265 
    ) EXP : void : COPY_qual #
 1249 
    ) EXP : void : COPY_qual #
1266 
 
 1250 
 
1267 
#pragma token PROC (\
 1251 
#pragma token PROC(\
1268 
	EXP : PTR ( QUALIFIER ) :\
 1252 
	EXP : PTR(QUALIFIER) :\
1269 
    ) EXP : QUALIFIER : DEREF_qual #
 1253 
    ) EXP : QUALIFIER : DEREF_qual #
1270 
 
 1254 
 
1271 
#pragma interface SIZE_qual COPY_qual DEREF_qual
 1255 
#pragma interface SIZE_qual COPY_qual DEREF_qual
1272 
 
 1256 
 
1273 
 
 1257 
 
1274 
/* Definitions for enumeration NTEST */
 1258 
/* Definitions for enumeration NTEST */
1275 
 
 1259 
 
1276 
#define ntest_eq			( ( NTEST ) 0 )
 1260 
#define ntest_eq			((NTEST) 0)
1277 
#define ntest_greater			( ( NTEST ) 1 )
 1261 
#define ntest_greater			((NTEST) 1)
1278 
#define ntest_greater_eq		( ( NTEST ) 2 )
 1262 
#define ntest_greater_eq		((NTEST) 2)
1279 
#define ntest_less			( ( NTEST ) 3 )
 1263 
#define ntest_less			((NTEST) 3)
1280 
#define ntest_less_eq			( ( NTEST ) 4 )
 1264 
#define ntest_less_eq			((NTEST) 4)
1281 
#define ntest_not_eq			( ( NTEST ) 5 )
 1265 
#define ntest_not_eq			((NTEST) 5)
1282 
#define ntest_not_greater		( ( NTEST ) 6 )
 1266 
#define ntest_not_greater		((NTEST) 6)
1283 
#define ntest_not_greater_eq		( ( NTEST ) 7 )
 1267 
#define ntest_not_greater_eq		((NTEST) 7)
1284 
#define ntest_not_less			( ( NTEST ) 8 )
 1268 
#define ntest_not_less			((NTEST) 8)
1285 
#define ntest_not_less_eq		( ( NTEST ) 9 )
 1269 
#define ntest_not_less_eq		((NTEST) 9)
1286 
#define ntest_not_not_eq		( ( NTEST ) 10 )
 1270 
#define ntest_not_not_eq		((NTEST) 10)
1287 
#define ntest_none			( ( NTEST ) 11 )
 1271 
#define ntest_none			((NTEST) 11)
1288 
#define ntest_negate			( ( NTEST ) 5 )
 1272 
#define ntest_negate			((NTEST) 5)
1289 
#define ntest_not			( ( NTEST ) 5 )
 1273 
#define ntest_not			((NTEST) 5)
1290 
#define ntest_not_not			( ( NTEST ) 10 )
 1274 
#define ntest_not_not			((NTEST) 10)
1291 
#define ORDER_ntest			( ( unsigned long ) 12 )
 1275 
#define ORDER_ntest			((unsigned long) 12)
1292 
#pragma token EXP const : SIZE ( NTEST ) : SIZE_ntest #
 1276 
#pragma token EXP const : SIZE(NTEST) : SIZE_ntest #
1293 
 
 1277 
 
1294 
#pragma token PROC (\
 1278 
#pragma token PROC(\
1295 
	EXP : PTR ( NTEST ) :,\
 1279 
	EXP : PTR(NTEST) :,\
1296 
	EXP : NTEST :\
 1280 
	EXP : NTEST :\
1297 
    ) EXP : void : COPY_ntest #
 1281 
    ) EXP : void : COPY_ntest #
1298 
 
 1282 
 
1299 
#pragma token PROC (\
 1283 
#pragma token PROC(\
1300 
	EXP : PTR ( NTEST ) :\
 1284 
	EXP : PTR(NTEST) :\
1301 
    ) EXP : NTEST : DEREF_ntest #
 1285 
    ) EXP : NTEST : DEREF_ntest #
1302 
 
 1286 
 
1303 
#pragma interface SIZE_ntest COPY_ntest DEREF_ntest
 1287 
#pragma interface SIZE_ntest COPY_ntest DEREF_ntest
1304 
 
 1288 
 
1305 
 
 1289 
 
1306 
/* Definitions for enumeration RMODE */
 1290 
/* Definitions for enumeration RMODE */
1307 
 
 1291 
 
1308 
#define rmode_as_state			( ( RMODE ) 0 )
 1292 
#define rmode_as_state			((RMODE) 0)
1309 
#define rmode_to_nearest		( ( RMODE ) 1 )
 1293 
#define rmode_to_nearest		((RMODE) 1)
1310 
#define rmode_to_larger			( ( RMODE ) 2 )
 1294 
#define rmode_to_larger			((RMODE) 2)
1311 
#define rmode_to_smaller		( ( RMODE ) 3 )
 1295 
#define rmode_to_smaller		((RMODE) 3)
1312 
#define rmode_to_zero			( ( RMODE ) 4 )
 1296 
#define rmode_to_zero			((RMODE) 4)
1313 
#define ORDER_rmode			( ( unsigned long ) 5 )
 1297 
#define ORDER_rmode			((unsigned long) 5)
1314 
#pragma token EXP const : SIZE ( RMODE ) : SIZE_rmode #
 1298 
#pragma token EXP const : SIZE(RMODE) : SIZE_rmode #
1315 
 
 1299 
 
1316 
#pragma token PROC (\
 1300 
#pragma token PROC(\
1317 
	EXP : PTR ( RMODE ) :,\
 1301 
	EXP : PTR(RMODE) :,\
1318 
	EXP : RMODE :\
 1302 
	EXP : RMODE :\
1319 
    ) EXP : void : COPY_rmode #
 1303 
    ) EXP : void : COPY_rmode #
1320 
 
 1304 
 
1321 
#pragma token PROC (\
 1305 
#pragma token PROC(\
1322 
	EXP : PTR ( RMODE ) :\
 1306 
	EXP : PTR(RMODE) :\
1323 
    ) EXP : RMODE : DEREF_rmode #
 1307 
    ) EXP : RMODE : DEREF_rmode #
1324 
 
 1308 
 
1325 
#pragma interface SIZE_rmode COPY_rmode DEREF_rmode
 1309 
#pragma interface SIZE_rmode COPY_rmode DEREF_rmode
1326 
 
 1310 
 
1327 
 
 1311 
 
1328 
/* Definitions for structure VARIABLE */
 1312 
/* Definitions for structure VARIABLE */
1329 
 
 1313 
 
1330 
#pragma token PROC ( EXP : PTR ( VARIABLE ) : ) EXP : PTR ( IDENTIFIER ) : var_id #
 1314 
#pragma token PROC(EXP : PTR(VARIABLE) :) EXP : PTR(IDENTIFIER) : var_id #
1331 
#pragma interface var_id
 1315 
#pragma interface var_id
1332 
 
 1316 
 
1333 
#pragma token PROC ( EXP : PTR ( VARIABLE ) : ) EXP : PTR ( DECL_SPEC ) : var_info #
 1317 
#pragma token PROC(EXP : PTR(VARIABLE) :) EXP : PTR(DECL_SPEC) : var_info #
1334 
#pragma interface var_info
 1318 
#pragma interface var_info
1335 
 
 1319 
 
1336 
#pragma token PROC (\
 1320 
#pragma token PROC(\
1337 
	EXP : IDENTIFIER :,\
 1321 
	EXP : IDENTIFIER :,\
1338 
	EXP : DECL_SPEC :,\
 1322 
	EXP : DECL_SPEC :,\
1339 
	EXP : PTR ( VARIABLE ) :\
 1323 
	EXP : PTR(VARIABLE) :\
1340 
    ) STATEMENT MAKE_var #
 1324 
    ) STATEMENT MAKE_var #
1341 
#pragma interface MAKE_var
 1325 
#pragma interface MAKE_var
1342 
 
 1326 
 
1343 
#pragma token EXP const : SIZE ( VARIABLE ) : SIZE_var #
 1327 
#pragma token EXP const : SIZE(VARIABLE) : SIZE_var #
1344 
 
 1328 
 
1345 
#pragma token PROC (\
 1329 
#pragma token PROC(\
1346 
	EXP : PTR ( VARIABLE ) :,\
 1330 
	EXP : PTR(VARIABLE) :,\
1347 
	EXP : VARIABLE :\
 1331 
	EXP : VARIABLE :\
1348 
    ) STATEMENT COPY_var #
 1332 
    ) STATEMENT COPY_var #
1349 
 
 1333 
 
1350 
#pragma token PROC (\
 1334 
#pragma token PROC(\
1351 
	EXP : PTR ( VARIABLE ) :,\
 1335 
	EXP : PTR(VARIABLE) :,\
1352 
	EXP lvalue : VARIABLE :\
 1336 
	EXP lvalue : VARIABLE :\
1353 
    ) STATEMENT DEREF_var #
 1337 
    ) STATEMENT DEREF_var #
1354 
 
 1338 
 
1355 
#pragma token PROC (\
 1339 
#pragma token PROC(\
1356 
	EXP : VARIABLE :,\
 1340 
	EXP : VARIABLE :,\
1357 
	EXP : LIST ( VARIABLE ) :,\
 1341 
	EXP : LIST(VARIABLE) :,\
1358 
	EXP lvalue : LIST ( VARIABLE ) :\
 1342 
	EXP lvalue : LIST(VARIABLE) :\
1359 
    ) STATEMENT CONS_var #
 1343 
    ) STATEMENT CONS_var #
1360 
 
 1344 
 
1361 
#pragma token PROC (\
 1345 
#pragma token PROC(\
1362 
	EXP lvalue : VARIABLE :,\
 1346 
	EXP lvalue : VARIABLE :,\
1363 
	EXP lvalue : LIST ( VARIABLE ) :,\
 1347 
	EXP lvalue : LIST(VARIABLE) :,\
1364 
	EXP : LIST ( VARIABLE ) :\
 1348 
	EXP : LIST(VARIABLE) :\
1365 
    ) STATEMENT UN_CONS_var #
 1349 
    ) STATEMENT UN_CONS_var #
1366 
 
 1350 
 
1367 
#pragma token PROC (\
 1351 
#pragma token PROC(\
1368 
	EXP : DESTROYER :,\
 1352 
	EXP : DESTROYER :,\
1369 
	EXP lvalue : VARIABLE :,\
 1353 
	EXP lvalue : VARIABLE :,\
1370 
	EXP lvalue : LIST ( VARIABLE ) :,\
 1354 
	EXP lvalue : LIST(VARIABLE) :,\
1371 
	EXP : LIST ( VARIABLE ) :\
 1355 
	EXP : LIST(VARIABLE) :\
1372 
    ) STATEMENT DESTROY_CONS_var #
 1356 
    ) STATEMENT DESTROY_CONS_var #
1373 
 
 1357 
 
1374 
#pragma token PROC (\
 1358 
#pragma token PROC(\
1375 
	EXP : VARIABLE :,\
 1359 
	EXP : VARIABLE :,\
1376 
	EXP lvalue : STACK ( VARIABLE ) :\
 1360 
	EXP lvalue : STACK(VARIABLE) :\
1377 
    ) STATEMENT PUSH_var #
 1361 
    ) STATEMENT PUSH_var #
1378 
 
 1362 
 
1379 
#pragma token PROC (\
 1363 
#pragma token PROC(\
1380 
	EXP lvalue : VARIABLE :,\
 1364 
	EXP lvalue : VARIABLE :,\
1381 
	EXP lvalue : STACK ( VARIABLE ) :\
 1365 
	EXP lvalue : STACK(VARIABLE) :\
1382 
    ) STATEMENT POP_var #
 1366 
    ) STATEMENT POP_var #
1383 
 
 1367 
 
1384 
#pragma interface SIZE_var COPY_var DEREF_var
 1368 
#pragma interface SIZE_var COPY_var DEREF_var
1385 
#pragma interface CONS_var UN_CONS_var DESTROY_CONS_var
 1369 
#pragma interface CONS_var UN_CONS_var DESTROY_CONS_var
1386 
#pragma interface PUSH_var POP_var
 1370 
#pragma interface PUSH_var POP_var
1387 
 
 1371 
 
1388 
 
 1372 
 
1389 
/* Definitions for structure LOCATION */
 1373 
/* Definitions for structure LOCATION */
1390 
 
 1374 
 
1391 
#pragma token PROC ( EXP : PTR ( LOCATION ) : ) EXP : PTR ( ulong_type ) : loc_line #
 1375 
#pragma token PROC(EXP : PTR(LOCATION) :) EXP : PTR(ulong_type) : loc_line #
1392 
#pragma interface loc_line
 1376 
#pragma interface loc_line
1393 
 
 1377 
 
1394 
#pragma token PROC ( EXP : PTR ( LOCATION ) : ) EXP : PTR ( ulong_type ) : loc_column #
 1378 
#pragma token PROC(EXP : PTR(LOCATION) :) EXP : PTR(ulong_type) : loc_column #
1395 
#pragma interface loc_column
 1379 
#pragma interface loc_column
1396 
 
 1380 
 
1397 
#pragma token PROC ( EXP : PTR ( LOCATION ) : ) EXP : PTR ( PTR ( POSITION ) ) : loc_posn #
 1381 
#pragma token PROC(EXP : PTR(LOCATION) :) EXP : PTR(PTR(POSITION)) : loc_posn #
1398 
#pragma interface loc_posn
 1382 
#pragma interface loc_posn
1399 
 
 1383 
 
1400 
#pragma token PROC (\
 1384 
#pragma token PROC(\
1401 
	EXP : ulong_type :,\
 1385 
	EXP : ulong_type :,\
1402 
	EXP : ulong_type :,\
 1386 
	EXP : ulong_type :,\
1403 
	EXP : PTR ( POSITION ) :,\
 1387 
	EXP : PTR(POSITION) :,\
1404 
	EXP : PTR ( LOCATION ) :\
 1388 
	EXP : PTR(LOCATION) :\
1405 
    ) STATEMENT MAKE_loc #
 1389 
    ) STATEMENT MAKE_loc #
1406 
#pragma interface MAKE_loc
 1390 
#pragma interface MAKE_loc
1407 
 
 1391 
 
1408 
#pragma token EXP const : SIZE ( LOCATION ) : SIZE_loc #
 1392 
#pragma token EXP const : SIZE(LOCATION) : SIZE_loc #
1409 
 
 1393 
 
1410 
#pragma token PROC (\
 1394 
#pragma token PROC(\
1411 
	EXP : PTR ( LOCATION ) :,\
 1395 
	EXP : PTR(LOCATION) :,\
1412 
	EXP : LOCATION :\
 1396 
	EXP : LOCATION :\
1413 
    ) STATEMENT COPY_loc #
 1397 
    ) STATEMENT COPY_loc #
1414 
 
 1398 
 
1415 
#pragma token PROC (\
 1399 
#pragma token PROC(\
1416 
	EXP : PTR ( LOCATION ) :,\
 1400 
	EXP : PTR(LOCATION) :,\
1417 
	EXP lvalue : LOCATION :\
 1401 
	EXP lvalue : LOCATION :\
1418 
    ) STATEMENT DEREF_loc #
 1402 
    ) STATEMENT DEREF_loc #
1419 
 
 1403 
 
1420 
#pragma token PROC (\
 1404 
#pragma token PROC(\
1421 
	EXP : LOCATION :,\
 1405 
	EXP : LOCATION :,\
1422 
	EXP : LIST ( LOCATION ) :,\
 1406 
	EXP : LIST(LOCATION) :,\
1423 
	EXP lvalue : LIST ( LOCATION ) :\
 1407 
	EXP lvalue : LIST(LOCATION) :\
1424 
    ) STATEMENT CONS_loc #
 1408 
    ) STATEMENT CONS_loc #
1425 
 
 1409 
 
1426 
#pragma token PROC (\
 1410 
#pragma token PROC(\
1427 
	EXP lvalue : LOCATION :,\
 1411 
	EXP lvalue : LOCATION :,\
1428 
	EXP lvalue : LIST ( LOCATION ) :,\
 1412 
	EXP lvalue : LIST(LOCATION) :,\
1429 
	EXP : LIST ( LOCATION ) :\
 1413 
	EXP : LIST(LOCATION) :\
1430 
    ) STATEMENT UN_CONS_loc #
 1414 
    ) STATEMENT UN_CONS_loc #
1431 
 
 1415 
 
1432 
#pragma token PROC (\
 1416 
#pragma token PROC(\
1433 
	EXP : DESTROYER :,\
 1417 
	EXP : DESTROYER :,\
1434 
	EXP lvalue : LOCATION :,\
 1418 
	EXP lvalue : LOCATION :,\
1435 
	EXP lvalue : LIST ( LOCATION ) :,\
 1419 
	EXP lvalue : LIST(LOCATION) :,\
1436 
	EXP : LIST ( LOCATION ) :\
 1420 
	EXP : LIST(LOCATION) :\
1437 
    ) STATEMENT DESTROY_CONS_loc #
 1421 
    ) STATEMENT DESTROY_CONS_loc #
1438 
 
 1422 
 
1439 
#pragma token PROC (\
 1423 
#pragma token PROC(\
1440 
	EXP : LOCATION :,\
 1424 
	EXP : LOCATION :,\
1441 
	EXP lvalue : STACK ( LOCATION ) :\
 1425 
	EXP lvalue : STACK(LOCATION) :\
1442 
    ) STATEMENT PUSH_loc #
 1426 
    ) STATEMENT PUSH_loc #
1443 
 
 1427 
 
1444 
#pragma token PROC (\
 1428 
#pragma token PROC(\
1445 
	EXP lvalue : LOCATION :,\
 1429 
	EXP lvalue : LOCATION :,\
1446 
	EXP lvalue : STACK ( LOCATION ) :\
 1430 
	EXP lvalue : STACK(LOCATION) :\
1447 
    ) STATEMENT POP_loc #
 1431 
    ) STATEMENT POP_loc #
1448 
 
 1432 
 
1449 
#pragma interface SIZE_loc COPY_loc DEREF_loc
 1433 
#pragma interface SIZE_loc COPY_loc DEREF_loc
1450 
#pragma interface CONS_loc UN_CONS_loc DESTROY_CONS_loc
 1434 
#pragma interface CONS_loc UN_CONS_loc DESTROY_CONS_loc
1451 
#pragma interface PUSH_loc POP_loc
 1435 
#pragma interface PUSH_loc POP_loc
1452 
 
 1436 
 
1453 
 
 1437 
 
1454 
/* Definitions for structure POSITION */
 1438 
/* Definitions for structure POSITION */
1455 
 
 1439 
 
1456 
#pragma token PROC ( EXP : PTR ( POSITION ) : ) EXP : PTR ( string ) : posn_file #
 1440 
#pragma token PROC(EXP : PTR(POSITION) :) EXP : PTR(string) : posn_file #
1457 
#pragma interface posn_file
 1441 
#pragma interface posn_file
1458 
 
 1442 
 
1459 
#pragma token PROC ( EXP : PTR ( POSITION ) : ) EXP : PTR ( string ) : posn_input #
 1443 
#pragma token PROC(EXP : PTR(POSITION) :) EXP : PTR(string) : posn_input #
1460 
#pragma interface posn_input
 1444 
#pragma interface posn_input
1461 
 
 1445 
 
1462 
#pragma token PROC ( EXP : PTR ( POSITION ) : ) EXP : PTR ( string ) : posn_base #
 1446 
#pragma token PROC(EXP : PTR(POSITION) :) EXP : PTR(string) : posn_base #
1463 
#pragma interface posn_base
 1447 
#pragma interface posn_base
1464 
 
 1448 
 
1465 
#pragma token PROC ( EXP : PTR ( POSITION ) : ) EXP : PTR ( string ) : posn_dir #
 1449 
#pragma token PROC(EXP : PTR(POSITION) :) EXP : PTR(string) : posn_dir #
1466 
#pragma interface posn_dir
 1450 
#pragma interface posn_dir
1467 
 
 1451 
 
1468 
#pragma token PROC ( EXP : PTR ( POSITION ) : ) EXP : PTR ( ulong_type ) : posn_offset #
 1452 
#pragma token PROC(EXP : PTR(POSITION) :) EXP : PTR(ulong_type) : posn_offset #
1469 
#pragma interface posn_offset
 1453 
#pragma interface posn_offset
1470 
 
 1454 
 
1471 
#pragma token PROC ( EXP : PTR ( POSITION ) : ) EXP : PTR ( PTR ( LOCATION ) ) : posn_from #
 1455 
#pragma token PROC(EXP : PTR(POSITION) :) EXP : PTR(PTR(LOCATION)) : posn_from #
1472 
#pragma interface posn_from
 1456 
#pragma interface posn_from
1473 
 
 1457 
 
1474 
#pragma token PROC ( EXP : PTR ( POSITION ) : ) EXP : PTR ( ulong_type ) : posn_datestamp #
 1458 
#pragma token PROC(EXP : PTR(POSITION) :) EXP : PTR(ulong_type) : posn_datestamp #
1475 
#pragma interface posn_datestamp
 1459 
#pragma interface posn_datestamp
1476 
 
 1460 
 
1477 
#pragma token PROC ( EXP : PTR ( POSITION ) : ) EXP : PTR ( ulong_type ) : posn_tok #
 1461 
#pragma token PROC(EXP : PTR(POSITION) :) EXP : PTR(ulong_type) : posn_tok #
1478 
#pragma interface posn_tok
 1462 
#pragma interface posn_tok
1479 
 
 1463 
 
1480 
#pragma token PROC (\
 1464 
#pragma token PROC(\
1481 
	EXP : string :,\
 1465 
	EXP : string :,\
1482 
	EXP : string :,\
 1466 
	EXP : string :,\
1483 
	EXP : string :,\
 1467 
	EXP : string :,\
1484 
	EXP : string :,\
 1468 
	EXP : string :,\
1485 
	EXP : ulong_type :,\
 1469 
	EXP : ulong_type :,\
1486 
	EXP : PTR ( LOCATION ) :,\
 1470 
	EXP : PTR(LOCATION) :,\
1487 
	EXP : ulong_type :,\
 1471 
	EXP : ulong_type :,\
1488 
	EXP : PTR ( POSITION ) :\
 1472 
	EXP : PTR(POSITION) :\
1489 
    ) STATEMENT MAKE_posn #
 1473 
    ) STATEMENT MAKE_posn #
1490 
#pragma interface MAKE_posn
 1474 
#pragma interface MAKE_posn
1491 
 
 1475 
 
1492 
#pragma token EXP const : SIZE ( POSITION ) : SIZE_posn #
 1476 
#pragma token EXP const : SIZE(POSITION) : SIZE_posn #
1493 
 
 1477 
 
1494 
#pragma token PROC (\
 1478 
#pragma token PROC(\
1495 
	EXP : PTR ( POSITION ) :,\
 1479 
	EXP : PTR(POSITION) :,\
1496 
	EXP : POSITION :\
 1480 
	EXP : POSITION :\
1497 
    ) STATEMENT COPY_posn #
 1481 
    ) STATEMENT COPY_posn #
1498 
 
 1482 
 
1499 
#pragma token PROC (\
 1483 
#pragma token PROC(\
1500 
	EXP : PTR ( POSITION ) :,\
 1484 
	EXP : PTR(POSITION) :,\
1501 
	EXP lvalue : POSITION :\
 1485 
	EXP lvalue : POSITION :\
1502 
    ) STATEMENT DEREF_posn #
 1486 
    ) STATEMENT DEREF_posn #
1503 
 
 1487 
 
1504 
#pragma token PROC (\
 1488 
#pragma token PROC(\
1505 
	EXP : POSITION :,\
 1489 
	EXP : POSITION :,\
1506 
	EXP : LIST ( POSITION ) :,\
 1490 
	EXP : LIST(POSITION) :,\
1507 
	EXP lvalue : LIST ( POSITION ) :\
 1491 
	EXP lvalue : LIST(POSITION) :\
1508 
    ) STATEMENT CONS_posn #
 1492 
    ) STATEMENT CONS_posn #
1509 
 
 1493 
 
1510 
#pragma token PROC (\
 1494 
#pragma token PROC(\
1511 
	EXP lvalue : POSITION :,\
 1495 
	EXP lvalue : POSITION :,\
1512 
	EXP lvalue : LIST ( POSITION ) :,\
 1496 
	EXP lvalue : LIST(POSITION) :,\
1513 
	EXP : LIST ( POSITION ) :\
 1497 
	EXP : LIST(POSITION) :\
1514 
    ) STATEMENT UN_CONS_posn #
 1498 
    ) STATEMENT UN_CONS_posn #
1515 
 
 1499 
 
1516 
#pragma token PROC (\
 1500 
#pragma token PROC(\
1517 
	EXP : DESTROYER :,\
 1501 
	EXP : DESTROYER :,\
1518 
	EXP lvalue : POSITION :,\
 1502 
	EXP lvalue : POSITION :,\
1519 
	EXP lvalue : LIST ( POSITION ) :,\
 1503 
	EXP lvalue : LIST(POSITION) :,\
1520 
	EXP : LIST ( POSITION ) :\
 1504 
	EXP : LIST(POSITION) :\
1521 
    ) STATEMENT DESTROY_CONS_posn #
 1505 
    ) STATEMENT DESTROY_CONS_posn #
1522 
 
 1506 
 
1523 
#pragma token PROC (\
 1507 
#pragma token PROC(\
1524 
	EXP : POSITION :,\
 1508 
	EXP : POSITION :,\
1525 
	EXP lvalue : STACK ( POSITION ) :\
 1509 
	EXP lvalue : STACK(POSITION) :\
1526 
    ) STATEMENT PUSH_posn #
 1510 
    ) STATEMENT PUSH_posn #
1527 
 
 1511 
 
1528 
#pragma token PROC (\
 1512 
#pragma token PROC(\
1529 
	EXP lvalue : POSITION :,\
 1513 
	EXP lvalue : POSITION :,\
1530 
	EXP lvalue : STACK ( POSITION ) :\
 1514 
	EXP lvalue : STACK(POSITION) :\
1531 
    ) STATEMENT POP_posn #
 1515 
    ) STATEMENT POP_posn #
1532 
 
 1516 
 
1533 
#pragma interface SIZE_posn COPY_posn DEREF_posn
 1517 
#pragma interface SIZE_posn COPY_posn DEREF_posn
1534 
#pragma interface CONS_posn UN_CONS_posn DESTROY_CONS_posn
 1518 
#pragma interface CONS_posn UN_CONS_posn DESTROY_CONS_posn
1535 
#pragma interface PUSH_posn POP_posn
 1519 
#pragma interface PUSH_posn POP_posn
1536 
 
 1520 
 
1537 
 
 1521 
 
1538 
/* Definitions for union INT_TYPE */
 1522 
/* Definitions for union INT_TYPE */
1539 
 
 1523 
 
1540 
#define ORDER_itype ( ( unsigned ) 6 )
 1524 
#define ORDER_itype ((unsigned)6)
1541 
#pragma token EXP const : INT_TYPE : NULL_itype #
 1525 
#pragma token EXP const : INT_TYPE : NULL_itype #
1542 
#pragma token PROC ( EXP : INT_TYPE : ) EXP : int : IS_NULL_itype #
 1526 
#pragma token PROC(EXP : INT_TYPE :) EXP : int : IS_NULL_itype #
1543 
#pragma token PROC ( EXP : INT_TYPE :, EXP : INT_TYPE : ) EXP : int : EQ_itype #
 1527 
#pragma token PROC(EXP : INT_TYPE :, EXP : INT_TYPE :) EXP : int : EQ_itype #
1544 
#pragma interface NULL_itype IS_NULL_itype EQ_itype
 1528 
#pragma interface NULL_itype IS_NULL_itype EQ_itype
1545 
 
 1529 
 
1546 
#pragma token EXP const : SIZE ( INT_TYPE ) : SIZE_itype #
 1530 
#pragma token EXP const : SIZE(INT_TYPE) : SIZE_itype #
1547 
 
 1531 
 
1548 
#pragma token PROC (\
 1532 
#pragma token PROC(\
1549 
	EXP : PTR ( INT_TYPE ) :,\
 1533 
	EXP : PTR(INT_TYPE) :,\
1550 
	EXP : INT_TYPE :\
 1534 
	EXP : INT_TYPE :\
1551 
    ) EXP : void : COPY_itype #
 1535 
    ) EXP : void : COPY_itype #
1552 
 
 1536 
 
1553 
#pragma token PROC (\
 1537 
#pragma token PROC(\
1554 
	EXP : PTR ( INT_TYPE ) :\
 1538 
	EXP : PTR(INT_TYPE) :\
1555 
    ) EXP : INT_TYPE : DEREF_itype #
 1539 
    ) EXP : INT_TYPE : DEREF_itype #
1556 
 
 1540 
 
1557 
#pragma token PROC (\
 1541 
#pragma token PROC(\
1558 
	EXP : INT_TYPE :,\
 1542 
	EXP : INT_TYPE :,\
1559 
	EXP : LIST ( INT_TYPE ) :,\
 1543 
	EXP : LIST(INT_TYPE) :,\
1560 
	EXP lvalue : LIST ( INT_TYPE ) :\
 1544 
	EXP lvalue : LIST(INT_TYPE) :\
1561 
    ) STATEMENT CONS_itype #
 1545 
    ) STATEMENT CONS_itype #
1562 
 
 1546 
 
1563 
#pragma token PROC (\
 1547 
#pragma token PROC(\
1564 
	EXP lvalue : INT_TYPE :,\
 1548 
	EXP lvalue : INT_TYPE :,\
1565 
	EXP lvalue : LIST ( INT_TYPE ) :,\
 1549 
	EXP lvalue : LIST(INT_TYPE) :,\
1566 
	EXP : LIST ( INT_TYPE ) :\
 1550 
	EXP : LIST(INT_TYPE) :\
1567 
    ) STATEMENT UN_CONS_itype #
 1551 
    ) STATEMENT UN_CONS_itype #
1568 
 
 1552 
 
1569 
#pragma token PROC (\
 1553 
#pragma token PROC(\
1570 
	EXP : DESTROYER :,\
 1554 
	EXP : DESTROYER :,\
1571 
	EXP lvalue : INT_TYPE :,\
 1555 
	EXP lvalue : INT_TYPE :,\
1572 
	EXP lvalue : LIST ( INT_TYPE ) :,\
 1556 
	EXP lvalue : LIST(INT_TYPE) :,\
1573 
	EXP : LIST ( INT_TYPE ) :\
 1557 
	EXP : LIST(INT_TYPE) :\
1574 
    ) STATEMENT DESTROY_CONS_itype #
 1558 
    ) STATEMENT DESTROY_CONS_itype #
1575 
 
 1559 
 
1576 
#pragma token PROC (\
 1560 
#pragma token PROC(\
1577 
	EXP : INT_TYPE :,\
 1561 
	EXP : INT_TYPE :,\
1578 
	EXP lvalue : STACK ( INT_TYPE ) :\
 1562 
	EXP lvalue : STACK(INT_TYPE) :\
1579 
    ) STATEMENT PUSH_itype #
 1563 
    ) STATEMENT PUSH_itype #
1580 
 
 1564 
 
1581 
#pragma token PROC (\
 1565 
#pragma token PROC(\
1582 
	EXP lvalue : INT_TYPE :,\
 1566 
	EXP lvalue : INT_TYPE :,\
1583 
	EXP lvalue : STACK ( INT_TYPE ) :\
 1567 
	EXP lvalue : STACK(INT_TYPE) :\
1584 
    ) STATEMENT POP_itype #
 1568 
    ) STATEMENT POP_itype #
1585 
 
 1569 
 
1586 
#pragma interface SIZE_itype COPY_itype DEREF_itype
 1570 
#pragma interface SIZE_itype COPY_itype DEREF_itype
1587 
#pragma interface CONS_itype UN_CONS_itype DESTROY_CONS_itype
 1571 
#pragma interface CONS_itype UN_CONS_itype DESTROY_CONS_itype
1588 
#pragma interface PUSH_itype POP_itype
 1572 
#pragma interface PUSH_itype POP_itype
1589 
 
 1573 
 
1590 
 
 1574 
 
1591 
/* Definitions for union FLOAT_TYPE */
 1575 
/* Definitions for union FLOAT_TYPE */
1592 
 
 1576 
 
1593 
#define ORDER_ftype ( ( unsigned ) 4 )
 1577 
#define ORDER_ftype ((unsigned)4)
1594 
#pragma token EXP const : FLOAT_TYPE : NULL_ftype #
 1578 
#pragma token EXP const : FLOAT_TYPE : NULL_ftype #
1595 
#pragma token PROC ( EXP : FLOAT_TYPE : ) EXP : int : IS_NULL_ftype #
 1579 
#pragma token PROC(EXP : FLOAT_TYPE :) EXP : int : IS_NULL_ftype #
1596 
#pragma token PROC ( EXP : FLOAT_TYPE :, EXP : FLOAT_TYPE : ) EXP : int : EQ_ftype #
 1580 
#pragma token PROC(EXP : FLOAT_TYPE :, EXP : FLOAT_TYPE :) EXP : int : EQ_ftype #
1597 
#pragma interface NULL_ftype IS_NULL_ftype EQ_ftype
 1581 
#pragma interface NULL_ftype IS_NULL_ftype EQ_ftype
1598 
 
 1582 
 
1599 
#pragma token EXP const : SIZE ( FLOAT_TYPE ) : SIZE_ftype #
 1583 
#pragma token EXP const : SIZE(FLOAT_TYPE) : SIZE_ftype #
1600 
 
 1584 
 
1601 
#pragma token PROC (\
 1585 
#pragma token PROC(\
1602 
	EXP : PTR ( FLOAT_TYPE ) :,\
 1586 
	EXP : PTR(FLOAT_TYPE) :,\
1603 
	EXP : FLOAT_TYPE :\
 1587 
	EXP : FLOAT_TYPE :\
1604 
    ) EXP : void : COPY_ftype #
 1588 
    ) EXP : void : COPY_ftype #
1605 
 
 1589 
 
1606 
#pragma token PROC (\
 1590 
#pragma token PROC(\
1607 
	EXP : PTR ( FLOAT_TYPE ) :\
 1591 
	EXP : PTR(FLOAT_TYPE) :\
1608 
    ) EXP : FLOAT_TYPE : DEREF_ftype #
 1592 
    ) EXP : FLOAT_TYPE : DEREF_ftype #
1609 
 
 1593 
 
1610 
#pragma token PROC (\
 1594 
#pragma token PROC(\
1611 
	EXP : FLOAT_TYPE :,\
 1595 
	EXP : FLOAT_TYPE :,\
1612 
	EXP : LIST ( FLOAT_TYPE ) :,\
 1596 
	EXP : LIST(FLOAT_TYPE) :,\
1613 
	EXP lvalue : LIST ( FLOAT_TYPE ) :\
 1597 
	EXP lvalue : LIST(FLOAT_TYPE) :\
1614 
    ) STATEMENT CONS_ftype #
 1598 
    ) STATEMENT CONS_ftype #
1615 
 
 1599 
 
1616 
#pragma token PROC (\
 1600 
#pragma token PROC(\
1617 
	EXP lvalue : FLOAT_TYPE :,\
 1601 
	EXP lvalue : FLOAT_TYPE :,\
1618 
	EXP lvalue : LIST ( FLOAT_TYPE ) :,\
 1602 
	EXP lvalue : LIST(FLOAT_TYPE) :,\
1619 
	EXP : LIST ( FLOAT_TYPE ) :\
 1603 
	EXP : LIST(FLOAT_TYPE) :\
1620 
    ) STATEMENT UN_CONS_ftype #
 1604 
    ) STATEMENT UN_CONS_ftype #
1621 
 
 1605 
 
1622 
#pragma token PROC (\
 1606 
#pragma token PROC(\
1623 
	EXP : DESTROYER :,\
 1607 
	EXP : DESTROYER :,\
1624 
	EXP lvalue : FLOAT_TYPE :,\
 1608 
	EXP lvalue : FLOAT_TYPE :,\
1625 
	EXP lvalue : LIST ( FLOAT_TYPE ) :,\
 1609 
	EXP lvalue : LIST(FLOAT_TYPE) :,\
1626 
	EXP : LIST ( FLOAT_TYPE ) :\
 1610 
	EXP : LIST(FLOAT_TYPE) :\
1627 
    ) STATEMENT DESTROY_CONS_ftype #
 1611 
    ) STATEMENT DESTROY_CONS_ftype #
1628 
 
 1612 
 
1629 
#pragma token PROC (\
 1613 
#pragma token PROC(\
1630 
	EXP : FLOAT_TYPE :,\
 1614 
	EXP : FLOAT_TYPE :,\
1631 
	EXP lvalue : STACK ( FLOAT_TYPE ) :\
 1615 
	EXP lvalue : STACK(FLOAT_TYPE) :\
1632 
    ) STATEMENT PUSH_ftype #
 1616 
    ) STATEMENT PUSH_ftype #
1633 
 
 1617 
 
1634 
#pragma token PROC (\
 1618 
#pragma token PROC(\
1635 
	EXP lvalue : FLOAT_TYPE :,\
 1619 
	EXP lvalue : FLOAT_TYPE :,\
1636 
	EXP lvalue : STACK ( FLOAT_TYPE ) :\
 1620 
	EXP lvalue : STACK(FLOAT_TYPE) :\
1637 
    ) STATEMENT POP_ftype #
 1621 
    ) STATEMENT POP_ftype #
1638 
 
 1622 
 
1639 
#pragma interface SIZE_ftype COPY_ftype DEREF_ftype
 1623 
#pragma interface SIZE_ftype COPY_ftype DEREF_ftype
1640 
#pragma interface CONS_ftype UN_CONS_ftype DESTROY_CONS_ftype
 1624 
#pragma interface CONS_ftype UN_CONS_ftype DESTROY_CONS_ftype
1641 
#pragma interface PUSH_ftype POP_ftype
 1625 
#pragma interface PUSH_ftype POP_ftype
1642 
 
 1626 
 
1643 
 
 1627 
 
1644 
/* Definitions for union CLASS_TYPE */
 1628 
/* Definitions for union CLASS_TYPE */
1645 
 
 1629 
 
1646 
#define ORDER_ctype ( ( unsigned ) 1 )
 1630 
#define ORDER_ctype ((unsigned)1)
1647 
#pragma token EXP const : CLASS_TYPE : NULL_ctype #
 1631 
#pragma token EXP const : CLASS_TYPE : NULL_ctype #
1648 
#pragma token PROC ( EXP : CLASS_TYPE : ) EXP : int : IS_NULL_ctype #
 1632 
#pragma token PROC(EXP : CLASS_TYPE :) EXP : int : IS_NULL_ctype #
1649 
#pragma token PROC ( EXP : CLASS_TYPE :, EXP : CLASS_TYPE : ) EXP : int : EQ_ctype #
 1633 
#pragma token PROC(EXP : CLASS_TYPE :, EXP : CLASS_TYPE :) EXP : int : EQ_ctype #
1650 
#pragma interface NULL_ctype IS_NULL_ctype EQ_ctype
 1634 
#pragma interface NULL_ctype IS_NULL_ctype EQ_ctype
1651 
 
 1635 
 
1652 
#pragma token EXP const : SIZE ( CLASS_TYPE ) : SIZE_ctype #
 1636 
#pragma token EXP const : SIZE(CLASS_TYPE) : SIZE_ctype #
1653 
 
 1637 
 
1654 
#pragma token PROC (\
 1638 
#pragma token PROC(\
1655 
	EXP : PTR ( CLASS_TYPE ) :,\
 1639 
	EXP : PTR(CLASS_TYPE) :,\
1656 
	EXP : CLASS_TYPE :\
 1640 
	EXP : CLASS_TYPE :\
1657 
    ) EXP : void : COPY_ctype #
 1641 
    ) EXP : void : COPY_ctype #
1658 
 
 1642 
 
1659 
#pragma token PROC (\
 1643 
#pragma token PROC(\
1660 
	EXP : PTR ( CLASS_TYPE ) :\
 1644 
	EXP : PTR(CLASS_TYPE) :\
1661 
    ) EXP : CLASS_TYPE : DEREF_ctype #
 1645 
    ) EXP : CLASS_TYPE : DEREF_ctype #
1662 
 
 1646 
 
1663 
#pragma token PROC (\
 1647 
#pragma token PROC(\
1664 
	EXP : CLASS_TYPE :,\
 1648 
	EXP : CLASS_TYPE :,\
1665 
	EXP : LIST ( CLASS_TYPE ) :,\
 1649 
	EXP : LIST(CLASS_TYPE) :,\
1666 
	EXP lvalue : LIST ( CLASS_TYPE ) :\
 1650 
	EXP lvalue : LIST(CLASS_TYPE) :\
1667 
    ) STATEMENT CONS_ctype #
 1651 
    ) STATEMENT CONS_ctype #
1668 
 
 1652 
 
1669 
#pragma token PROC (\
 1653 
#pragma token PROC(\
1670 
	EXP lvalue : CLASS_TYPE :,\
 1654 
	EXP lvalue : CLASS_TYPE :,\
1671 
	EXP lvalue : LIST ( CLASS_TYPE ) :,\
 1655 
	EXP lvalue : LIST(CLASS_TYPE) :,\
1672 
	EXP : LIST ( CLASS_TYPE ) :\
 1656 
	EXP : LIST(CLASS_TYPE) :\
1673 
    ) STATEMENT UN_CONS_ctype #
 1657 
    ) STATEMENT UN_CONS_ctype #
1674 
 
 1658 
 
1675 
#pragma token PROC (\
 1659 
#pragma token PROC(\
1676 
	EXP : DESTROYER :,\
 1660 
	EXP : DESTROYER :,\
1677 
	EXP lvalue : CLASS_TYPE :,\
 1661 
	EXP lvalue : CLASS_TYPE :,\
1678 
	EXP lvalue : LIST ( CLASS_TYPE ) :,\
 1662 
	EXP lvalue : LIST(CLASS_TYPE) :,\
1679 
	EXP : LIST ( CLASS_TYPE ) :\
 1663 
	EXP : LIST(CLASS_TYPE) :\
1680 
    ) STATEMENT DESTROY_CONS_ctype #
 1664 
    ) STATEMENT DESTROY_CONS_ctype #
1681 
 
 1665 
 
1682 
#pragma token PROC (\
 1666 
#pragma token PROC(\
1683 
	EXP : CLASS_TYPE :,\
 1667 
	EXP : CLASS_TYPE :,\
1684 
	EXP lvalue : STACK ( CLASS_TYPE ) :\
 1668 
	EXP lvalue : STACK(CLASS_TYPE) :\
1685 
    ) STATEMENT PUSH_ctype #
 1669 
    ) STATEMENT PUSH_ctype #
1686 
 
 1670 
 
1687 
#pragma token PROC (\
 1671 
#pragma token PROC(\
1688 
	EXP lvalue : CLASS_TYPE :,\
 1672 
	EXP lvalue : CLASS_TYPE :,\
1689 
	EXP lvalue : STACK ( CLASS_TYPE ) :\
 1673 
	EXP lvalue : STACK(CLASS_TYPE) :\
1690 
    ) STATEMENT POP_ctype #
 1674 
    ) STATEMENT POP_ctype #
1691 
 
 1675 
 
1692 
#pragma interface SIZE_ctype COPY_ctype DEREF_ctype
 1676 
#pragma interface SIZE_ctype COPY_ctype DEREF_ctype
1693 
#pragma interface CONS_ctype UN_CONS_ctype DESTROY_CONS_ctype
 1677 
#pragma interface CONS_ctype UN_CONS_ctype DESTROY_CONS_ctype
1694 
#pragma interface PUSH_ctype POP_ctype
 1678 
#pragma interface PUSH_ctype POP_ctype
1695 
 
 1679 
 
1696 
 
 1680 
 
1697 
/* Definitions for union GRAPH */
 1681 
/* Definitions for union GRAPH */
1698 
 
 1682 
 
1699 
#define ORDER_graph ( ( unsigned ) 1 )
 1683 
#define ORDER_graph ((unsigned)1)
1700 
#pragma token EXP const : GRAPH : NULL_graph #
 1684 
#pragma token EXP const : GRAPH : NULL_graph #
1701 
#pragma token PROC ( EXP : GRAPH : ) EXP : int : IS_NULL_graph #
 1685 
#pragma token PROC(EXP : GRAPH :) EXP : int : IS_NULL_graph #
1702 
#pragma token PROC ( EXP : GRAPH :, EXP : GRAPH : ) EXP : int : EQ_graph #
 1686 
#pragma token PROC(EXP : GRAPH :, EXP : GRAPH :) EXP : int : EQ_graph #
1703 
#pragma interface NULL_graph IS_NULL_graph EQ_graph
 1687 
#pragma interface NULL_graph IS_NULL_graph EQ_graph
1704 
 
 1688 
 
1705 
#pragma token EXP const : SIZE ( GRAPH ) : SIZE_graph #
 1689 
#pragma token EXP const : SIZE(GRAPH) : SIZE_graph #
1706 
 
 1690 
 
1707 
#pragma token PROC (\
 1691 
#pragma token PROC(\
1708 
	EXP : PTR ( GRAPH ) :,\
 1692 
	EXP : PTR(GRAPH) :,\
1709 
	EXP : GRAPH :\
 1693 
	EXP : GRAPH :\
1710 
    ) EXP : void : COPY_graph #
 1694 
    ) EXP : void : COPY_graph #
1711 
 
 1695 
 
1712 
#pragma token PROC (\
 1696 
#pragma token PROC(\
1713 
	EXP : PTR ( GRAPH ) :\
 1697 
	EXP : PTR(GRAPH) :\
1714 
    ) EXP : GRAPH : DEREF_graph #
 1698 
    ) EXP : GRAPH : DEREF_graph #
1715 
 
 1699 
 
1716 
#pragma token PROC (\
 1700 
#pragma token PROC(\
1717 
	EXP : GRAPH :,\
 1701 
	EXP : GRAPH :,\
1718 
	EXP : LIST ( GRAPH ) :,\
 1702 
	EXP : LIST(GRAPH) :,\
1719 
	EXP lvalue : LIST ( GRAPH ) :\
 1703 
	EXP lvalue : LIST(GRAPH) :\
1720 
    ) STATEMENT CONS_graph #
 1704 
    ) STATEMENT CONS_graph #
1721 
 
 1705 
 
1722 
#pragma token PROC (\
 1706 
#pragma token PROC(\
1723 
	EXP lvalue : GRAPH :,\
 1707 
	EXP lvalue : GRAPH :,\
1724 
	EXP lvalue : LIST ( GRAPH ) :,\
 1708 
	EXP lvalue : LIST(GRAPH) :,\
1725 
	EXP : LIST ( GRAPH ) :\
 1709 
	EXP : LIST(GRAPH) :\
1726 
    ) STATEMENT UN_CONS_graph #
 1710 
    ) STATEMENT UN_CONS_graph #
1727 
 
 1711 
 
1728 
#pragma token PROC (\
 1712 
#pragma token PROC(\
1729 
	EXP : DESTROYER :,\
 1713 
	EXP : DESTROYER :,\
1730 
	EXP lvalue : GRAPH :,\
 1714 
	EXP lvalue : GRAPH :,\
1731 
	EXP lvalue : LIST ( GRAPH ) :,\
 1715 
	EXP lvalue : LIST(GRAPH) :,\
1732 
	EXP : LIST ( GRAPH ) :\
 1716 
	EXP : LIST(GRAPH) :\
1733 
    ) STATEMENT DESTROY_CONS_graph #
 1717 
    ) STATEMENT DESTROY_CONS_graph #
1734 
 
 1718 
 
1735 
#pragma token PROC (\
 1719 
#pragma token PROC(\
1736 
	EXP : GRAPH :,\
 1720 
	EXP : GRAPH :,\
1737 
	EXP lvalue : STACK ( GRAPH ) :\
 1721 
	EXP lvalue : STACK(GRAPH) :\
1738 
    ) STATEMENT PUSH_graph #
 1722 
    ) STATEMENT PUSH_graph #
1739 
 
 1723 
 
1740 
#pragma token PROC (\
 1724 
#pragma token PROC(\
1741 
	EXP lvalue : GRAPH :,\
 1725 
	EXP lvalue : GRAPH :,\
1742 
	EXP lvalue : STACK ( GRAPH ) :\
 1726 
	EXP lvalue : STACK(GRAPH) :\
1743 
    ) STATEMENT POP_graph #
 1727 
    ) STATEMENT POP_graph #
1744 
 
 1728 
 
1745 
#pragma interface SIZE_graph COPY_graph DEREF_graph
 1729 
#pragma interface SIZE_graph COPY_graph DEREF_graph
1746 
#pragma interface CONS_graph UN_CONS_graph DESTROY_CONS_graph
 1730 
#pragma interface CONS_graph UN_CONS_graph DESTROY_CONS_graph
1747 
#pragma interface PUSH_graph POP_graph
 1731 
#pragma interface PUSH_graph POP_graph
1748 
 
 1732 
 
1749 
 
 1733 
 
1750 
/* Definitions for union VIRTUAL */
 1734 
/* Definitions for union VIRTUAL */
1751 
 
 1735 
 
1752 
#define ORDER_virt ( ( unsigned ) 6 )
 1736 
#define ORDER_virt ((unsigned)6)
1753 
#pragma token EXP const : VIRTUAL : NULL_virt #
 1737 
#pragma token EXP const : VIRTUAL : NULL_virt #
1754 
#pragma token PROC ( EXP : VIRTUAL : ) EXP : int : IS_NULL_virt #
 1738 
#pragma token PROC(EXP : VIRTUAL :) EXP : int : IS_NULL_virt #
1755 
#pragma token PROC ( EXP : VIRTUAL :, EXP : VIRTUAL : ) EXP : int : EQ_virt #
 1739 
#pragma token PROC(EXP : VIRTUAL :, EXP : VIRTUAL :) EXP : int : EQ_virt #
1756 
#pragma interface NULL_virt IS_NULL_virt EQ_virt
 1740 
#pragma interface NULL_virt IS_NULL_virt EQ_virt
1757 
 
 1741 
 
1758 
#pragma token EXP const : SIZE ( VIRTUAL ) : SIZE_virt #
 1742 
#pragma token EXP const : SIZE(VIRTUAL) : SIZE_virt #
1759 
 
 1743 
 
1760 
#pragma token PROC (\
 1744 
#pragma token PROC(\
1761 
	EXP : PTR ( VIRTUAL ) :,\
 1745 
	EXP : PTR(VIRTUAL) :,\
1762 
	EXP : VIRTUAL :\
 1746 
	EXP : VIRTUAL :\
1763 
    ) EXP : void : COPY_virt #
 1747 
    ) EXP : void : COPY_virt #
1764 
 
 1748 
 
1765 
#pragma token PROC (\
 1749 
#pragma token PROC(\
1766 
	EXP : PTR ( VIRTUAL ) :\
 1750 
	EXP : PTR(VIRTUAL) :\
1767 
    ) EXP : VIRTUAL : DEREF_virt #
 1751 
    ) EXP : VIRTUAL : DEREF_virt #
1768 
 
 1752 
 
1769 
#pragma token PROC (\
 1753 
#pragma token PROC(\
1770 
	EXP : VIRTUAL :,\
 1754 
	EXP : VIRTUAL :,\
1771 
	EXP : LIST ( VIRTUAL ) :,\
 1755 
	EXP : LIST(VIRTUAL) :,\
1772 
	EXP lvalue : LIST ( VIRTUAL ) :\
 1756 
	EXP lvalue : LIST(VIRTUAL) :\
1773 
    ) STATEMENT CONS_virt #
 1757 
    ) STATEMENT CONS_virt #
1774 
 
 1758 
 
1775 
#pragma token PROC (\
 1759 
#pragma token PROC(\
1776 
	EXP lvalue : VIRTUAL :,\
 1760 
	EXP lvalue : VIRTUAL :,\
1777 
	EXP lvalue : LIST ( VIRTUAL ) :,\
 1761 
	EXP lvalue : LIST(VIRTUAL) :,\
1778 
	EXP : LIST ( VIRTUAL ) :\
 1762 
	EXP : LIST(VIRTUAL) :\
1779 
    ) STATEMENT UN_CONS_virt #
 1763 
    ) STATEMENT UN_CONS_virt #
1780 
 
 1764 
 
1781 
#pragma token PROC (\
 1765 
#pragma token PROC(\
1782 
	EXP : DESTROYER :,\
 1766 
	EXP : DESTROYER :,\
1783 
	EXP lvalue : VIRTUAL :,\
 1767 
	EXP lvalue : VIRTUAL :,\
1784 
	EXP lvalue : LIST ( VIRTUAL ) :,\
 1768 
	EXP lvalue : LIST(VIRTUAL) :,\
1785 
	EXP : LIST ( VIRTUAL ) :\
 1769 
	EXP : LIST(VIRTUAL) :\
1786 
    ) STATEMENT DESTROY_CONS_virt #
 1770 
    ) STATEMENT DESTROY_CONS_virt #
1787 
 
 1771 
 
1788 
#pragma token PROC (\
 1772 
#pragma token PROC(\
1789 
	EXP : VIRTUAL :,\
 1773 
	EXP : VIRTUAL :,\
1790 
	EXP lvalue : STACK ( VIRTUAL ) :\
 1774 
	EXP lvalue : STACK(VIRTUAL) :\
1791 
    ) STATEMENT PUSH_virt #
 1775 
    ) STATEMENT PUSH_virt #
1792 
 
 1776 
 
1793 
#pragma token PROC (\
 1777 
#pragma token PROC(\
1794 
	EXP lvalue : VIRTUAL :,\
 1778 
	EXP lvalue : VIRTUAL :,\
1795 
	EXP lvalue : STACK ( VIRTUAL ) :\
 1779 
	EXP lvalue : STACK(VIRTUAL) :\
1796 
    ) STATEMENT POP_virt #
 1780 
    ) STATEMENT POP_virt #
1797 
 
 1781 
 
1798 
#pragma interface SIZE_virt COPY_virt DEREF_virt
 1782 
#pragma interface SIZE_virt COPY_virt DEREF_virt
1799 
#pragma interface CONS_virt UN_CONS_virt DESTROY_CONS_virt
 1783 
#pragma interface CONS_virt UN_CONS_virt DESTROY_CONS_virt
1800 
#pragma interface PUSH_virt POP_virt
 1784 
#pragma interface PUSH_virt POP_virt
1801 
 
 1785 
 
1802 
 
 1786 
 
1803 
/* Definitions for union ENUM_TYPE */
 1787 
/* Definitions for union ENUM_TYPE */
1804 
 
 1788 
 
1805 
#define ORDER_etype ( ( unsigned ) 1 )
 1789 
#define ORDER_etype ((unsigned)1)
1806 
#pragma token EXP const : ENUM_TYPE : NULL_etype #
 1790 
#pragma token EXP const : ENUM_TYPE : NULL_etype #
1807 
#pragma token PROC ( EXP : ENUM_TYPE : ) EXP : int : IS_NULL_etype #
 1791 
#pragma token PROC(EXP : ENUM_TYPE :) EXP : int : IS_NULL_etype #
1808 
#pragma token PROC ( EXP : ENUM_TYPE :, EXP : ENUM_TYPE : ) EXP : int : EQ_etype #
 1792 
#pragma token PROC(EXP : ENUM_TYPE :, EXP : ENUM_TYPE :) EXP : int : EQ_etype #
1809 
#pragma interface NULL_etype IS_NULL_etype EQ_etype
 1793 
#pragma interface NULL_etype IS_NULL_etype EQ_etype
1810 
 
 1794 
 
1811 
#pragma token EXP const : SIZE ( ENUM_TYPE ) : SIZE_etype #
 1795 
#pragma token EXP const : SIZE(ENUM_TYPE) : SIZE_etype #
1812 
 
 1796 
 
1813 
#pragma token PROC (\
 1797 
#pragma token PROC(\
1814 
	EXP : PTR ( ENUM_TYPE ) :,\
 1798 
	EXP : PTR(ENUM_TYPE) :,\
1815 
	EXP : ENUM_TYPE :\
 1799 
	EXP : ENUM_TYPE :\
1816 
    ) EXP : void : COPY_etype #
 1800 
    ) EXP : void : COPY_etype #
1817 
 
 1801 
 
1818 
#pragma token PROC (\
 1802 
#pragma token PROC(\
1819 
	EXP : PTR ( ENUM_TYPE ) :\
 1803 
	EXP : PTR(ENUM_TYPE) :\
1820 
    ) EXP : ENUM_TYPE : DEREF_etype #
 1804 
    ) EXP : ENUM_TYPE : DEREF_etype #
1821 
 
 1805 
 
1822 
#pragma token PROC (\
 1806 
#pragma token PROC(\
1823 
	EXP : ENUM_TYPE :,\
 1807 
	EXP : ENUM_TYPE :,\
1824 
	EXP : LIST ( ENUM_TYPE ) :,\
 1808 
	EXP : LIST(ENUM_TYPE) :,\
1825 
	EXP lvalue : LIST ( ENUM_TYPE ) :\
 1809 
	EXP lvalue : LIST(ENUM_TYPE) :\
1826 
    ) STATEMENT CONS_etype #
 1810 
    ) STATEMENT CONS_etype #
1827 
 
 1811 
 
1828 
#pragma token PROC (\
 1812 
#pragma token PROC(\
1829 
	EXP lvalue : ENUM_TYPE :,\
 1813 
	EXP lvalue : ENUM_TYPE :,\
1830 
	EXP lvalue : LIST ( ENUM_TYPE ) :,\
 1814 
	EXP lvalue : LIST(ENUM_TYPE) :,\
1831 
	EXP : LIST ( ENUM_TYPE ) :\
 1815 
	EXP : LIST(ENUM_TYPE) :\
1832 
    ) STATEMENT UN_CONS_etype #
 1816 
    ) STATEMENT UN_CONS_etype #
1833 
 
 1817 
 
1834 
#pragma token PROC (\
 1818 
#pragma token PROC(\
1835 
	EXP : DESTROYER :,\
 1819 
	EXP : DESTROYER :,\
1836 
	EXP lvalue : ENUM_TYPE :,\
 1820 
	EXP lvalue : ENUM_TYPE :,\
1837 
	EXP lvalue : LIST ( ENUM_TYPE ) :,\
 1821 
	EXP lvalue : LIST(ENUM_TYPE) :,\
1838 
	EXP : LIST ( ENUM_TYPE ) :\
 1822 
	EXP : LIST(ENUM_TYPE) :\
1839 
    ) STATEMENT DESTROY_CONS_etype #
 1823 
    ) STATEMENT DESTROY_CONS_etype #
1840 
 
 1824 
 
1841 
#pragma token PROC (\
 1825 
#pragma token PROC(\
1842 
	EXP : ENUM_TYPE :,\
 1826 
	EXP : ENUM_TYPE :,\
1843 
	EXP lvalue : STACK ( ENUM_TYPE ) :\
 1827 
	EXP lvalue : STACK(ENUM_TYPE) :\
1844 
    ) STATEMENT PUSH_etype #
 1828 
    ) STATEMENT PUSH_etype #
1845 
 
 1829 
 
1846 
#pragma token PROC (\
 1830 
#pragma token PROC(\
1847 
	EXP lvalue : ENUM_TYPE :,\
 1831 
	EXP lvalue : ENUM_TYPE :,\
1848 
	EXP lvalue : STACK ( ENUM_TYPE ) :\
 1832 
	EXP lvalue : STACK(ENUM_TYPE) :\
1849 
    ) STATEMENT POP_etype #
 1833 
    ) STATEMENT POP_etype #
1850 
 
 1834 
 
1851 
#pragma interface SIZE_etype COPY_etype DEREF_etype
 1835 
#pragma interface SIZE_etype COPY_etype DEREF_etype
1852 
#pragma interface CONS_etype UN_CONS_etype DESTROY_CONS_etype
 1836 
#pragma interface CONS_etype UN_CONS_etype DESTROY_CONS_etype
1853 
#pragma interface PUSH_etype POP_etype
 1837 
#pragma interface PUSH_etype POP_etype
1854 
 
 1838 
 
1855 
 
 1839 
 
1856 
/* Definitions for union TYPE */
 1840 
/* Definitions for union TYPE */
1857 
 
 1841 
 
1858 
#define ORDER_type ( ( unsigned ) 18 )
 1842 
#define ORDER_type ((unsigned)18)
1859 
#pragma token EXP const : TYPE : NULL_type #
 1843 
#pragma token EXP const : TYPE : NULL_type #
1860 
#pragma token PROC ( EXP : TYPE : ) EXP : int : IS_NULL_type #
 1844 
#pragma token PROC(EXP : TYPE :) EXP : int : IS_NULL_type #
1861 
#pragma token PROC ( EXP : TYPE :, EXP : TYPE : ) EXP : int : EQ_type #
 1845 
#pragma token PROC(EXP : TYPE :, EXP : TYPE :) EXP : int : EQ_type #
1862 
#pragma interface NULL_type IS_NULL_type EQ_type
 1846 
#pragma interface NULL_type IS_NULL_type EQ_type
1863 
 
 1847 
 
1864 
#pragma token EXP const : SIZE ( TYPE ) : SIZE_type #
 1848 
#pragma token EXP const : SIZE(TYPE) : SIZE_type #
1865 
 
 1849 
 
1866 
#pragma token PROC (\
 1850 
#pragma token PROC(\
1867 
	EXP : PTR ( TYPE ) :,\
 1851 
	EXP : PTR(TYPE) :,\
1868 
	EXP : TYPE :\
 1852 
	EXP : TYPE :\
1869 
    ) EXP : void : COPY_type #
 1853 
    ) EXP : void : COPY_type #
1870 
 
 1854 
 
1871 
#pragma token PROC (\
 1855 
#pragma token PROC(\
1872 
	EXP : PTR ( TYPE ) :\
 1856 
	EXP : PTR(TYPE) :\
1873 
    ) EXP : TYPE : DEREF_type #
 1857 
    ) EXP : TYPE : DEREF_type #
1874 
 
 1858 
 
1875 
#pragma token PROC (\
 1859 
#pragma token PROC(\
1876 
	EXP : TYPE :,\
 1860 
	EXP : TYPE :,\
1877 
	EXP : LIST ( TYPE ) :,\
 1861 
	EXP : LIST(TYPE) :,\
1878 
	EXP lvalue : LIST ( TYPE ) :\
 1862 
	EXP lvalue : LIST(TYPE) :\
1879 
    ) STATEMENT CONS_type #
 1863 
    ) STATEMENT CONS_type #
1880 
 
 1864 
 
1881 
#pragma token PROC (\
 1865 
#pragma token PROC(\
1882 
	EXP lvalue : TYPE :,\
 1866 
	EXP lvalue : TYPE :,\
1883 
	EXP lvalue : LIST ( TYPE ) :,\
 1867 
	EXP lvalue : LIST(TYPE) :,\
1884 
	EXP : LIST ( TYPE ) :\
 1868 
	EXP : LIST(TYPE) :\
1885 
    ) STATEMENT UN_CONS_type #
 1869 
    ) STATEMENT UN_CONS_type #
1886 
 
 1870 
 
1887 
#pragma token PROC (\
 1871 
#pragma token PROC(\
1888 
	EXP : DESTROYER :,\
 1872 
	EXP : DESTROYER :,\
1889 
	EXP lvalue : TYPE :,\
 1873 
	EXP lvalue : TYPE :,\
1890 
	EXP lvalue : LIST ( TYPE ) :,\
 1874 
	EXP lvalue : LIST(TYPE) :,\
1891 
	EXP : LIST ( TYPE ) :\
 1875 
	EXP : LIST(TYPE) :\
1892 
    ) STATEMENT DESTROY_CONS_type #
 1876 
    ) STATEMENT DESTROY_CONS_type #
1893 
 
 1877 
 
1894 
#pragma token PROC (\
 1878 
#pragma token PROC(\
1895 
	EXP : TYPE :,\
 1879 
	EXP : TYPE :,\
1896 
	EXP lvalue : STACK ( TYPE ) :\
 1880 
	EXP lvalue : STACK(TYPE) :\
1897 
    ) STATEMENT PUSH_type #
 1881 
    ) STATEMENT PUSH_type #
1898 
 
 1882 
 
1899 
#pragma token PROC (\
 1883 
#pragma token PROC(\
1900 
	EXP lvalue : TYPE :,\
 1884 
	EXP lvalue : TYPE :,\
1901 
	EXP lvalue : STACK ( TYPE ) :\
 1885 
	EXP lvalue : STACK(TYPE) :\
1902 
    ) STATEMENT POP_type #
 1886 
    ) STATEMENT POP_type #
1903 
 
 1887 
 
1904 
#pragma interface SIZE_type COPY_type DEREF_type
 1888 
#pragma interface SIZE_type COPY_type DEREF_type
1905 
#pragma interface CONS_type UN_CONS_type DESTROY_CONS_type
 1889 
#pragma interface CONS_type UN_CONS_type DESTROY_CONS_type
1906 
#pragma interface PUSH_type POP_type
 1890 
#pragma interface PUSH_type POP_type
1907 
 
 1891 
 
1908 
 
 1892 
 
1909 
/* Definitions for union HASHID */
 1893 
/* Definitions for union HASHID */
1910 
 
 1894 
 
1911 
#define ORDER_hashid ( ( unsigned ) 7 )
 1895 
#define ORDER_hashid ((unsigned)7)
1912 
#pragma token EXP const : HASHID : NULL_hashid #
 1896 
#pragma token EXP const : HASHID : NULL_hashid #
1913 
#pragma token PROC ( EXP : HASHID : ) EXP : int : IS_NULL_hashid #
 1897 
#pragma token PROC(EXP : HASHID :) EXP : int : IS_NULL_hashid #
1914 
#pragma token PROC ( EXP : HASHID :, EXP : HASHID : ) EXP : int : EQ_hashid #
 1898 
#pragma token PROC(EXP : HASHID :, EXP : HASHID :) EXP : int : EQ_hashid #
1915 
#pragma interface NULL_hashid IS_NULL_hashid EQ_hashid
 1899 
#pragma interface NULL_hashid IS_NULL_hashid EQ_hashid
1916 
 
 1900 
 
1917 
#pragma token EXP const : SIZE ( HASHID ) : SIZE_hashid #
 1901 
#pragma token EXP const : SIZE(HASHID) : SIZE_hashid #
1918 
 
 1902 
 
1919 
#pragma token PROC (\
 1903 
#pragma token PROC(\
1920 
	EXP : PTR ( HASHID ) :,\
 1904 
	EXP : PTR(HASHID) :,\
1921 
	EXP : HASHID :\
 1905 
	EXP : HASHID :\
1922 
    ) EXP : void : COPY_hashid #
 1906 
    ) EXP : void : COPY_hashid #
1923 
 
 1907 
 
1924 
#pragma token PROC (\
 1908 
#pragma token PROC(\
1925 
	EXP : PTR ( HASHID ) :\
 1909 
	EXP : PTR(HASHID) :\
1926 
    ) EXP : HASHID : DEREF_hashid #
 1910 
    ) EXP : HASHID : DEREF_hashid #
1927 
 
 1911 
 
1928 
#pragma token PROC (\
 1912 
#pragma token PROC(\
1929 
	EXP : HASHID :,\
 1913 
	EXP : HASHID :,\
1930 
	EXP : LIST ( HASHID ) :,\
 1914 
	EXP : LIST(HASHID) :,\
1931 
	EXP lvalue : LIST ( HASHID ) :\
 1915 
	EXP lvalue : LIST(HASHID) :\
1932 
    ) STATEMENT CONS_hashid #
 1916 
    ) STATEMENT CONS_hashid #
1933 
 
 1917 
 
1934 
#pragma token PROC (\
 1918 
#pragma token PROC(\
1935 
	EXP lvalue : HASHID :,\
 1919 
	EXP lvalue : HASHID :,\
1936 
	EXP lvalue : LIST ( HASHID ) :,\
 1920 
	EXP lvalue : LIST(HASHID) :,\
1937 
	EXP : LIST ( HASHID ) :\
 1921 
	EXP : LIST(HASHID) :\
1938 
    ) STATEMENT UN_CONS_hashid #
 1922 
    ) STATEMENT UN_CONS_hashid #
1939 
 
 1923 
 
1940 
#pragma token PROC (\
 1924 
#pragma token PROC(\
1941 
	EXP : DESTROYER :,\
 1925 
	EXP : DESTROYER :,\
1942 
	EXP lvalue : HASHID :,\
 1926 
	EXP lvalue : HASHID :,\
1943 
	EXP lvalue : LIST ( HASHID ) :,\
 1927 
	EXP lvalue : LIST(HASHID) :,\
1944 
	EXP : LIST ( HASHID ) :\
 1928 
	EXP : LIST(HASHID) :\
1945 
    ) STATEMENT DESTROY_CONS_hashid #
 1929 
    ) STATEMENT DESTROY_CONS_hashid #
1946 
 
 1930 
 
1947 
#pragma token PROC (\
 1931 
#pragma token PROC(\
1948 
	EXP : HASHID :,\
 1932 
	EXP : HASHID :,\
1949 
	EXP lvalue : STACK ( HASHID ) :\
 1933 
	EXP lvalue : STACK(HASHID) :\
1950 
    ) STATEMENT PUSH_hashid #
 1934 
    ) STATEMENT PUSH_hashid #
1951 
 
 1935 
 
1952 
#pragma token PROC (\
 1936 
#pragma token PROC(\
1953 
	EXP lvalue : HASHID :,\
 1937 
	EXP lvalue : HASHID :,\
1954 
	EXP lvalue : STACK ( HASHID ) :\
 1938 
	EXP lvalue : STACK(HASHID) :\
1955 
    ) STATEMENT POP_hashid #
 1939 
    ) STATEMENT POP_hashid #
1956 
 
 1940 
 
1957 
#pragma interface SIZE_hashid COPY_hashid DEREF_hashid
 1941 
#pragma interface SIZE_hashid COPY_hashid DEREF_hashid
1958 
#pragma interface CONS_hashid UN_CONS_hashid DESTROY_CONS_hashid
 1942 
#pragma interface CONS_hashid UN_CONS_hashid DESTROY_CONS_hashid
1959 
#pragma interface PUSH_hashid POP_hashid
 1943 
#pragma interface PUSH_hashid POP_hashid
1960 
 
 1944 
 
1961 
 
 1945 
 
1962 
/* Definitions for union IDENTIFIER */
 1946 
/* Definitions for union IDENTIFIER */
1963 
 
 1947 
 
1964 
#define ORDER_id ( ( unsigned ) 29 )
 1948 
#define ORDER_id ((unsigned)29)
1965 
#pragma token EXP const : IDENTIFIER : NULL_id #
 1949 
#pragma token EXP const : IDENTIFIER : NULL_id #
1966 
#pragma token PROC ( EXP : IDENTIFIER : ) EXP : int : IS_NULL_id #
 1950 
#pragma token PROC(EXP : IDENTIFIER :) EXP : int : IS_NULL_id #
1967 
#pragma token PROC ( EXP : IDENTIFIER :, EXP : IDENTIFIER : ) EXP : int : EQ_id #
 1951 
#pragma token PROC(EXP : IDENTIFIER :, EXP : IDENTIFIER :) EXP : int : EQ_id #
1968 
#pragma interface NULL_id IS_NULL_id EQ_id
 1952 
#pragma interface NULL_id IS_NULL_id EQ_id
1969 
 
 1953 
 
1970 
#pragma token EXP const : SIZE ( IDENTIFIER ) : SIZE_id #
 1954 
#pragma token EXP const : SIZE(IDENTIFIER) : SIZE_id #
1971 
 
 1955 
 
1972 
#pragma token PROC (\
 1956 
#pragma token PROC(\
1973 
	EXP : PTR ( IDENTIFIER ) :,\
 1957 
	EXP : PTR(IDENTIFIER) :,\
1974 
	EXP : IDENTIFIER :\
 1958 
	EXP : IDENTIFIER :\
1975 
    ) EXP : void : COPY_id #
 1959 
    ) EXP : void : COPY_id #
1976 
 
 1960 
 
1977 
#pragma token PROC (\
 1961 
#pragma token PROC(\
1978 
	EXP : PTR ( IDENTIFIER ) :\
 1962 
	EXP : PTR(IDENTIFIER) :\
1979 
    ) EXP : IDENTIFIER : DEREF_id #
 1963 
    ) EXP : IDENTIFIER : DEREF_id #
1980 
 
 1964 
 
1981 
#pragma token PROC (\
 1965 
#pragma token PROC(\
1982 
	EXP : IDENTIFIER :,\
 1966 
	EXP : IDENTIFIER :,\
1983 
	EXP : LIST ( IDENTIFIER ) :,\
 1967 
	EXP : LIST(IDENTIFIER) :,\
1984 
	EXP lvalue : LIST ( IDENTIFIER ) :\
 1968 
	EXP lvalue : LIST(IDENTIFIER) :\
1985 
    ) STATEMENT CONS_id #
 1969 
    ) STATEMENT CONS_id #
1986 
 
 1970 
 
1987 
#pragma token PROC (\
 1971 
#pragma token PROC(\
1988 
	EXP lvalue : IDENTIFIER :,\
 1972 
	EXP lvalue : IDENTIFIER :,\
1989 
	EXP lvalue : LIST ( IDENTIFIER ) :,\
 1973 
	EXP lvalue : LIST(IDENTIFIER) :,\
1990 
	EXP : LIST ( IDENTIFIER ) :\
 1974 
	EXP : LIST(IDENTIFIER) :\
1991 
    ) STATEMENT UN_CONS_id #
 1975 
    ) STATEMENT UN_CONS_id #
1992 
 
 1976 
 
1993 
#pragma token PROC (\
 1977 
#pragma token PROC(\
1994 
	EXP : DESTROYER :,\
 1978 
	EXP : DESTROYER :,\
1995 
	EXP lvalue : IDENTIFIER :,\
 1979 
	EXP lvalue : IDENTIFIER :,\
1996 
	EXP lvalue : LIST ( IDENTIFIER ) :,\
 1980 
	EXP lvalue : LIST(IDENTIFIER) :,\
1997 
	EXP : LIST ( IDENTIFIER ) :\
 1981 
	EXP : LIST(IDENTIFIER) :\
1998 
    ) STATEMENT DESTROY_CONS_id #
 1982 
    ) STATEMENT DESTROY_CONS_id #
1999 
 
 1983 
 
2000 
#pragma token PROC (\
 1984 
#pragma token PROC(\
2001 
	EXP : IDENTIFIER :,\
 1985 
	EXP : IDENTIFIER :,\
2002 
	EXP lvalue : STACK ( IDENTIFIER ) :\
 1986 
	EXP lvalue : STACK(IDENTIFIER) :\
2003 
    ) STATEMENT PUSH_id #
 1987 
    ) STATEMENT PUSH_id #
2004 
 
 1988 
 
2005 
#pragma token PROC (\
 1989 
#pragma token PROC(\
2006 
	EXP lvalue : IDENTIFIER :,\
 1990 
	EXP lvalue : IDENTIFIER :,\
2007 
	EXP lvalue : STACK ( IDENTIFIER ) :\
 1991 
	EXP lvalue : STACK(IDENTIFIER) :\
2008 
    ) STATEMENT POP_id #
 1992 
    ) STATEMENT POP_id #
2009 
 
 1993 
 
2010 
#pragma interface SIZE_id COPY_id DEREF_id
 1994 
#pragma interface SIZE_id COPY_id DEREF_id
2011 
#pragma interface CONS_id UN_CONS_id DESTROY_CONS_id
 1995 
#pragma interface CONS_id UN_CONS_id DESTROY_CONS_id
2012 
#pragma interface PUSH_id POP_id
 1996 
#pragma interface PUSH_id POP_id
2013 
 
 1997 
 
2014 
 
 1998 
 
2015 
/* Definitions for union MEMBER */
 1999 
/* Definitions for union MEMBER */
2016 
 
 2000 
 
2017 
#define ORDER_member ( ( unsigned ) 2 )
 2001 
#define ORDER_member ((unsigned)2)
2018 
#pragma token EXP const : MEMBER : NULL_member #
 2002 
#pragma token EXP const : MEMBER : NULL_member #
2019 
#pragma token PROC ( EXP : MEMBER : ) EXP : int : IS_NULL_member #
 2003 
#pragma token PROC(EXP : MEMBER :) EXP : int : IS_NULL_member #
2020 
#pragma token PROC ( EXP : MEMBER :, EXP : MEMBER : ) EXP : int : EQ_member #
 2004 
#pragma token PROC(EXP : MEMBER :, EXP : MEMBER :) EXP : int : EQ_member #
2021 
#pragma interface NULL_member IS_NULL_member EQ_member
 2005 
#pragma interface NULL_member IS_NULL_member EQ_member
2022 
 
 2006 
 
2023 
#pragma token EXP const : SIZE ( MEMBER ) : SIZE_member #
 2007 
#pragma token EXP const : SIZE(MEMBER) : SIZE_member #
2024 
 
 2008 
 
2025 
#pragma token PROC (\
 2009 
#pragma token PROC(\
2026 
	EXP : PTR ( MEMBER ) :,\
 2010 
	EXP : PTR(MEMBER) :,\
2027 
	EXP : MEMBER :\
 2011 
	EXP : MEMBER :\
2028 
    ) EXP : void : COPY_member #
 2012 
    ) EXP : void : COPY_member #
2029 
 
 2013 
 
2030 
#pragma token PROC (\
 2014 
#pragma token PROC(\
2031 
	EXP : PTR ( MEMBER ) :\
 2015 
	EXP : PTR(MEMBER) :\
2032 
    ) EXP : MEMBER : DEREF_member #
 2016 
    ) EXP : MEMBER : DEREF_member #
2033 
 
 2017 
 
2034 
#pragma token PROC (\
 2018 
#pragma token PROC(\
2035 
	EXP : MEMBER :,\
 2019 
	EXP : MEMBER :,\
2036 
	EXP : LIST ( MEMBER ) :,\
 2020 
	EXP : LIST(MEMBER) :,\
2037 
	EXP lvalue : LIST ( MEMBER ) :\
 2021 
	EXP lvalue : LIST(MEMBER) :\
2038 
    ) STATEMENT CONS_member #
 2022 
    ) STATEMENT CONS_member #
2039 
 
 2023 
 
2040 
#pragma token PROC (\
 2024 
#pragma token PROC(\
2041 
	EXP lvalue : MEMBER :,\
 2025 
	EXP lvalue : MEMBER :,\
2042 
	EXP lvalue : LIST ( MEMBER ) :,\
 2026 
	EXP lvalue : LIST(MEMBER) :,\
2043 
	EXP : LIST ( MEMBER ) :\
 2027 
	EXP : LIST(MEMBER) :\
2044 
    ) STATEMENT UN_CONS_member #
 2028 
    ) STATEMENT UN_CONS_member #
2045 
 
 2029 
 
2046 
#pragma token PROC (\
 2030 
#pragma token PROC(\
2047 
	EXP : DESTROYER :,\
 2031 
	EXP : DESTROYER :,\
2048 
	EXP lvalue : MEMBER :,\
 2032 
	EXP lvalue : MEMBER :,\
2049 
	EXP lvalue : LIST ( MEMBER ) :,\
 2033 
	EXP lvalue : LIST(MEMBER) :,\
2050 
	EXP : LIST ( MEMBER ) :\
 2034 
	EXP : LIST(MEMBER) :\
2051 
    ) STATEMENT DESTROY_CONS_member #
 2035 
    ) STATEMENT DESTROY_CONS_member #
2052 
 
 2036 
 
2053 
#pragma token PROC (\
 2037 
#pragma token PROC(\
2054 
	EXP : MEMBER :,\
 2038 
	EXP : MEMBER :,\
2055 
	EXP lvalue : STACK ( MEMBER ) :\
 2039 
	EXP lvalue : STACK(MEMBER) :\
2056 
    ) STATEMENT PUSH_member #
 2040 
    ) STATEMENT PUSH_member #
2057 
 
 2041 
 
2058 
#pragma token PROC (\
 2042 
#pragma token PROC(\
2059 
	EXP lvalue : MEMBER :,\
 2043 
	EXP lvalue : MEMBER :,\
2060 
	EXP lvalue : STACK ( MEMBER ) :\
 2044 
	EXP lvalue : STACK(MEMBER) :\
2061 
    ) STATEMENT POP_member #
 2045 
    ) STATEMENT POP_member #
2062 
 
 2046 
 
2063 
#pragma interface SIZE_member COPY_member DEREF_member
 2047 
#pragma interface SIZE_member COPY_member DEREF_member
2064 
#pragma interface CONS_member UN_CONS_member DESTROY_CONS_member
 2048 
#pragma interface CONS_member UN_CONS_member DESTROY_CONS_member
2065 
#pragma interface PUSH_member POP_member
 2049 
#pragma interface PUSH_member POP_member
2066 
 
 2050 
 
2067 
 
 2051 
 
2068 
/* Definitions for union NAMESPACE */
 2052 
/* Definitions for union NAMESPACE */
2069 
 
 2053 
 
2070 
#define ORDER_nspace ( ( unsigned ) 9 )
 2054 
#define ORDER_nspace ((unsigned)9)
2071 
#pragma token EXP const : NAMESPACE : NULL_nspace #
 2055 
#pragma token EXP const : NAMESPACE : NULL_nspace #
2072 
#pragma token PROC ( EXP : NAMESPACE : ) EXP : int : IS_NULL_nspace #
 2056 
#pragma token PROC(EXP : NAMESPACE :) EXP : int : IS_NULL_nspace #
2073 
#pragma token PROC ( EXP : NAMESPACE :, EXP : NAMESPACE : ) EXP : int : EQ_nspace #
 2057 
#pragma token PROC(EXP : NAMESPACE :, EXP : NAMESPACE :) EXP : int : EQ_nspace #
2074 
#pragma interface NULL_nspace IS_NULL_nspace EQ_nspace
 2058 
#pragma interface NULL_nspace IS_NULL_nspace EQ_nspace
2075 
 
 2059 
 
2076 
#pragma token EXP const : SIZE ( NAMESPACE ) : SIZE_nspace #
 2060 
#pragma token EXP const : SIZE(NAMESPACE) : SIZE_nspace #
2077 
 
 2061 
 
2078 
#pragma token PROC (\
 2062 
#pragma token PROC(\
2079 
	EXP : PTR ( NAMESPACE ) :,\
 2063 
	EXP : PTR(NAMESPACE) :,\
2080 
	EXP : NAMESPACE :\
 2064 
	EXP : NAMESPACE :\
2081 
    ) EXP : void : COPY_nspace #
 2065 
    ) EXP : void : COPY_nspace #
2082 
 
 2066 
 
2083 
#pragma token PROC (\
 2067 
#pragma token PROC(\
2084 
	EXP : PTR ( NAMESPACE ) :\
 2068 
	EXP : PTR(NAMESPACE) :\
2085 
    ) EXP : NAMESPACE : DEREF_nspace #
 2069 
    ) EXP : NAMESPACE : DEREF_nspace #
2086 
 
 2070 
 
2087 
#pragma token PROC (\
 2071 
#pragma token PROC(\
2088 
	EXP : NAMESPACE :,\
 2072 
	EXP : NAMESPACE :,\
2089 
	EXP : LIST ( NAMESPACE ) :,\
 2073 
	EXP : LIST(NAMESPACE) :,\
2090 
	EXP lvalue : LIST ( NAMESPACE ) :\
 2074 
	EXP lvalue : LIST(NAMESPACE) :\
2091 
    ) STATEMENT CONS_nspace #
 2075 
    ) STATEMENT CONS_nspace #
2092 
 
 2076 
 
2093 
#pragma token PROC (\
 2077 
#pragma token PROC(\
2094 
	EXP lvalue : NAMESPACE :,\
 2078 
	EXP lvalue : NAMESPACE :,\
2095 
	EXP lvalue : LIST ( NAMESPACE ) :,\
 2079 
	EXP lvalue : LIST(NAMESPACE) :,\
2096 
	EXP : LIST ( NAMESPACE ) :\
 2080 
	EXP : LIST(NAMESPACE) :\
2097 
    ) STATEMENT UN_CONS_nspace #
 2081 
    ) STATEMENT UN_CONS_nspace #
2098 
 
 2082 
 
2099 
#pragma token PROC (\
 2083 
#pragma token PROC(\
2100 
	EXP : DESTROYER :,\
 2084 
	EXP : DESTROYER :,\
2101 
	EXP lvalue : NAMESPACE :,\
 2085 
	EXP lvalue : NAMESPACE :,\
2102 
	EXP lvalue : LIST ( NAMESPACE ) :,\
 2086 
	EXP lvalue : LIST(NAMESPACE) :,\
2103 
	EXP : LIST ( NAMESPACE ) :\
 2087 
	EXP : LIST(NAMESPACE) :\
2104 
    ) STATEMENT DESTROY_CONS_nspace #
 2088 
    ) STATEMENT DESTROY_CONS_nspace #
2105 
 
 2089 
 
2106 
#pragma token PROC (\
 2090 
#pragma token PROC(\
2107 
	EXP : NAMESPACE :,\
 2091 
	EXP : NAMESPACE :,\
2108 
	EXP lvalue : STACK ( NAMESPACE ) :\
 2092 
	EXP lvalue : STACK(NAMESPACE) :\
2109 
    ) STATEMENT PUSH_nspace #
 2093 
    ) STATEMENT PUSH_nspace #
2110 
 
 2094 
 
2111 
#pragma token PROC (\
 2095 
#pragma token PROC(\
2112 
	EXP lvalue : NAMESPACE :,\
 2096 
	EXP lvalue : NAMESPACE :,\
2113 
	EXP lvalue : STACK ( NAMESPACE ) :\
 2097 
	EXP lvalue : STACK(NAMESPACE) :\
2114 
    ) STATEMENT POP_nspace #
 2098 
    ) STATEMENT POP_nspace #
2115 
 
 2099 
 
2116 
#pragma interface SIZE_nspace COPY_nspace DEREF_nspace
 2100 
#pragma interface SIZE_nspace COPY_nspace DEREF_nspace
2117 
#pragma interface CONS_nspace UN_CONS_nspace DESTROY_CONS_nspace
 2101 
#pragma interface CONS_nspace UN_CONS_nspace DESTROY_CONS_nspace
2118 
#pragma interface PUSH_nspace POP_nspace
 2102 
#pragma interface PUSH_nspace POP_nspace
2119 
 
 2103 
 
2120 
 
 2104 
 
2121 
/* Definitions for union NAT */
 2105 
/* Definitions for union NAT */
2122 
 
 2106 
 
2123 
#define ORDER_nat ( ( unsigned ) 5 )
 2107 
#define ORDER_nat ((unsigned)5)
2124 
#pragma token EXP const : NAT : NULL_nat #
 2108 
#pragma token EXP const : NAT : NULL_nat #
2125 
#pragma token PROC ( EXP : NAT : ) EXP : int : IS_NULL_nat #
 2109 
#pragma token PROC(EXP : NAT :) EXP : int : IS_NULL_nat #
2126 
#pragma token PROC ( EXP : NAT :, EXP : NAT : ) EXP : int : EQ_nat #
 2110 
#pragma token PROC(EXP : NAT :, EXP : NAT :) EXP : int : EQ_nat #
2127 
#pragma interface NULL_nat IS_NULL_nat EQ_nat
 2111 
#pragma interface NULL_nat IS_NULL_nat EQ_nat
2128 
 
 2112 
 
2129 
#pragma token EXP const : SIZE ( NAT ) : SIZE_nat #
 2113 
#pragma token EXP const : SIZE(NAT) : SIZE_nat #
2130 
 
 2114 
 
2131 
#pragma token PROC (\
 2115 
#pragma token PROC(\
2132 
	EXP : PTR ( NAT ) :,\
 2116 
	EXP : PTR(NAT) :,\
2133 
	EXP : NAT :\
 2117 
	EXP : NAT :\
2134 
    ) EXP : void : COPY_nat #
 2118 
    ) EXP : void : COPY_nat #
2135 
 
 2119 
 
2136 
#pragma token PROC (\
 2120 
#pragma token PROC(\
2137 
	EXP : PTR ( NAT ) :\
 2121 
	EXP : PTR(NAT) :\
2138 
    ) EXP : NAT : DEREF_nat #
 2122 
    ) EXP : NAT : DEREF_nat #
2139 
 
 2123 
 
2140 
#pragma token PROC (\
 2124 
#pragma token PROC(\
2141 
	EXP : NAT :,\
 2125 
	EXP : NAT :,\
2142 
	EXP : LIST ( NAT ) :,\
 2126 
	EXP : LIST(NAT) :,\
2143 
	EXP lvalue : LIST ( NAT ) :\
 2127 
	EXP lvalue : LIST(NAT) :\
2144 
    ) STATEMENT CONS_nat #
 2128 
    ) STATEMENT CONS_nat #
2145 
 
 2129 
 
2146 
#pragma token PROC (\
 2130 
#pragma token PROC(\
2147 
	EXP lvalue : NAT :,\
 2131 
	EXP lvalue : NAT :,\
2148 
	EXP lvalue : LIST ( NAT ) :,\
 2132 
	EXP lvalue : LIST(NAT) :,\
2149 
	EXP : LIST ( NAT ) :\
 2133 
	EXP : LIST(NAT) :\
2150 
    ) STATEMENT UN_CONS_nat #
 2134 
    ) STATEMENT UN_CONS_nat #
2151 
 
 2135 
 
2152 
#pragma token PROC (\
 2136 
#pragma token PROC(\
2153 
	EXP : DESTROYER :,\
 2137 
	EXP : DESTROYER :,\
2154 
	EXP lvalue : NAT :,\
 2138 
	EXP lvalue : NAT :,\
2155 
	EXP lvalue : LIST ( NAT ) :,\
 2139 
	EXP lvalue : LIST(NAT) :,\
2156 
	EXP : LIST ( NAT ) :\
 2140 
	EXP : LIST(NAT) :\
2157 
    ) STATEMENT DESTROY_CONS_nat #
 2141 
    ) STATEMENT DESTROY_CONS_nat #
2158 
 
 2142 
 
2159 
#pragma token PROC (\
 2143 
#pragma token PROC(\
2160 
	EXP : NAT :,\
 2144 
	EXP : NAT :,\
2161 
	EXP lvalue : STACK ( NAT ) :\
 2145 
	EXP lvalue : STACK(NAT) :\
2162 
    ) STATEMENT PUSH_nat #
 2146 
    ) STATEMENT PUSH_nat #
2163 
 
 2147 
 
2164 
#pragma token PROC (\
 2148 
#pragma token PROC(\
2165 
	EXP lvalue : NAT :,\
 2149 
	EXP lvalue : NAT :,\
2166 
	EXP lvalue : STACK ( NAT ) :\
 2150 
	EXP lvalue : STACK(NAT) :\
2167 
    ) STATEMENT POP_nat #
 2151 
    ) STATEMENT POP_nat #
2168 
 
 2152 
 
2169 
#pragma interface SIZE_nat COPY_nat DEREF_nat
 2153 
#pragma interface SIZE_nat COPY_nat DEREF_nat
2170 
#pragma interface CONS_nat UN_CONS_nat DESTROY_CONS_nat
 2154 
#pragma interface CONS_nat UN_CONS_nat DESTROY_CONS_nat
2171 
#pragma interface PUSH_nat POP_nat
 2155 
#pragma interface PUSH_nat POP_nat
2172 
 
 2156 
 
2173 
 
 2157 
 
2174 
/* Definitions for union FLOAT */
 2158 
/* Definitions for union FLOAT */
2175 
 
 2159 
 
2176 
#define ORDER_flt ( ( unsigned ) 1 )
 2160 
#define ORDER_flt ((unsigned)1)
2177 
#pragma token EXP const : FLOAT : NULL_flt #
 2161 
#pragma token EXP const : FLOAT : NULL_flt #
2178 
#pragma token PROC ( EXP : FLOAT : ) EXP : int : IS_NULL_flt #
 2162 
#pragma token PROC(EXP : FLOAT :) EXP : int : IS_NULL_flt #
2179 
#pragma token PROC ( EXP : FLOAT :, EXP : FLOAT : ) EXP : int : EQ_flt #
 2163 
#pragma token PROC(EXP : FLOAT :, EXP : FLOAT :) EXP : int : EQ_flt #
2180 
#pragma interface NULL_flt IS_NULL_flt EQ_flt
 2164 
#pragma interface NULL_flt IS_NULL_flt EQ_flt
2181 
 
 2165 
 
2182 
#pragma token EXP const : SIZE ( FLOAT ) : SIZE_flt #
 2166 
#pragma token EXP const : SIZE(FLOAT) : SIZE_flt #
2183 
 
 2167 
 
2184 
#pragma token PROC (\
 2168 
#pragma token PROC(\
2185 
	EXP : PTR ( FLOAT ) :,\
 2169 
	EXP : PTR(FLOAT) :,\
2186 
	EXP : FLOAT :\
 2170 
	EXP : FLOAT :\
2187 
    ) EXP : void : COPY_flt #
 2171 
    ) EXP : void : COPY_flt #
2188 
 
 2172 
 
2189 
#pragma token PROC (\
 2173 
#pragma token PROC(\
2190 
	EXP : PTR ( FLOAT ) :\
 2174 
	EXP : PTR(FLOAT) :\
2191 
    ) EXP : FLOAT : DEREF_flt #
 2175 
    ) EXP : FLOAT : DEREF_flt #
2192 
 
 2176 
 
2193 
#pragma token PROC (\
 2177 
#pragma token PROC(\
2194 
	EXP : FLOAT :,\
 2178 
	EXP : FLOAT :,\
2195 
	EXP : LIST ( FLOAT ) :,\
 2179 
	EXP : LIST(FLOAT) :,\
2196 
	EXP lvalue : LIST ( FLOAT ) :\
 2180 
	EXP lvalue : LIST(FLOAT) :\
2197 
    ) STATEMENT CONS_flt #
 2181 
    ) STATEMENT CONS_flt #
2198 
 
 2182 
 
2199 
#pragma token PROC (\
 2183 
#pragma token PROC(\
2200 
	EXP lvalue : FLOAT :,\
 2184 
	EXP lvalue : FLOAT :,\
2201 
	EXP lvalue : LIST ( FLOAT ) :,\
 2185 
	EXP lvalue : LIST(FLOAT) :,\
2202 
	EXP : LIST ( FLOAT ) :\
 2186 
	EXP : LIST(FLOAT) :\
2203 
    ) STATEMENT UN_CONS_flt #
 2187 
    ) STATEMENT UN_CONS_flt #
2204 
 
 2188 
 
2205 
#pragma token PROC (\
 2189 
#pragma token PROC(\
2206 
	EXP : DESTROYER :,\
 2190 
	EXP : DESTROYER :,\
2207 
	EXP lvalue : FLOAT :,\
 2191 
	EXP lvalue : FLOAT :,\
2208 
	EXP lvalue : LIST ( FLOAT ) :,\
 2192 
	EXP lvalue : LIST(FLOAT) :,\
2209 
	EXP : LIST ( FLOAT ) :\
 2193 
	EXP : LIST(FLOAT) :\
2210 
    ) STATEMENT DESTROY_CONS_flt #
 2194 
    ) STATEMENT DESTROY_CONS_flt #
2211 
 
 2195 
 
2212 
#pragma token PROC (\
 2196 
#pragma token PROC(\
2213 
	EXP : FLOAT :,\
 2197 
	EXP : FLOAT :,\
2214 
	EXP lvalue : STACK ( FLOAT ) :\
 2198 
	EXP lvalue : STACK(FLOAT) :\
2215 
    ) STATEMENT PUSH_flt #
 2199 
    ) STATEMENT PUSH_flt #
2216 
 
 2200 
 
2217 
#pragma token PROC (\
 2201 
#pragma token PROC(\
2218 
	EXP lvalue : FLOAT :,\
 2202 
	EXP lvalue : FLOAT :,\
2219 
	EXP lvalue : STACK ( FLOAT ) :\
 2203 
	EXP lvalue : STACK(FLOAT) :\
2220 
    ) STATEMENT POP_flt #
 2204 
    ) STATEMENT POP_flt #
2221 
 
 2205 
 
2222 
#pragma interface SIZE_flt COPY_flt DEREF_flt
 2206 
#pragma interface SIZE_flt COPY_flt DEREF_flt
2223 
#pragma interface CONS_flt UN_CONS_flt DESTROY_CONS_flt
 2207 
#pragma interface CONS_flt UN_CONS_flt DESTROY_CONS_flt
2224 
#pragma interface PUSH_flt POP_flt
 2208 
#pragma interface PUSH_flt POP_flt
2225 
 
 2209 
 
2226 
 
 2210 
 
2227 
/* Definitions for union STRING */
 2211 
/* Definitions for union STRING */
2228 
 
 2212 
 
2229 
#define ORDER_str ( ( unsigned ) 1 )
 2213 
#define ORDER_str ((unsigned)1)
2230 
#pragma token EXP const : STRING : NULL_str #
 2214 
#pragma token EXP const : STRING : NULL_str #
2231 
#pragma token PROC ( EXP : STRING : ) EXP : int : IS_NULL_str #
 2215 
#pragma token PROC(EXP : STRING :) EXP : int : IS_NULL_str #
2232 
#pragma token PROC ( EXP : STRING :, EXP : STRING : ) EXP : int : EQ_str #
 2216 
#pragma token PROC(EXP : STRING :, EXP : STRING :) EXP : int : EQ_str #
2233 
#pragma interface NULL_str IS_NULL_str EQ_str
 2217 
#pragma interface NULL_str IS_NULL_str EQ_str
2234 
 
 2218 
 
2235 
#pragma token EXP const : SIZE ( STRING ) : SIZE_str #
 2219 
#pragma token EXP const : SIZE(STRING) : SIZE_str #
2236 
 
 2220 
 
2237 
#pragma token PROC (\
 2221 
#pragma token PROC(\
2238 
	EXP : PTR ( STRING ) :,\
 2222 
	EXP : PTR(STRING) :,\
2239 
	EXP : STRING :\
 2223 
	EXP : STRING :\
2240 
    ) EXP : void : COPY_str #
 2224 
    ) EXP : void : COPY_str #
2241 
 
 2225 
 
2242 
#pragma token PROC (\
 2226 
#pragma token PROC(\
2243 
	EXP : PTR ( STRING ) :\
 2227 
	EXP : PTR(STRING) :\
2244 
    ) EXP : STRING : DEREF_str #
 2228 
    ) EXP : STRING : DEREF_str #
2245 
 
 2229 
 
2246 
#pragma token PROC (\
 2230 
#pragma token PROC(\
2247 
	EXP : STRING :,\
 2231 
	EXP : STRING :,\
2248 
	EXP : LIST ( STRING ) :,\
 2232 
	EXP : LIST(STRING) :,\
2249 
	EXP lvalue : LIST ( STRING ) :\
 2233 
	EXP lvalue : LIST(STRING) :\
2250 
    ) STATEMENT CONS_str #
 2234 
    ) STATEMENT CONS_str #
2251 
 
 2235 
 
2252 
#pragma token PROC (\
 2236 
#pragma token PROC(\
2253 
	EXP lvalue : STRING :,\
 2237 
	EXP lvalue : STRING :,\
2254 
	EXP lvalue : LIST ( STRING ) :,\
 2238 
	EXP lvalue : LIST(STRING) :,\
2255 
	EXP : LIST ( STRING ) :\
 2239 
	EXP : LIST(STRING) :\
2256 
    ) STATEMENT UN_CONS_str #
 2240 
    ) STATEMENT UN_CONS_str #
2257 
 
 2241 
 
2258 
#pragma token PROC (\
 2242 
#pragma token PROC(\
2259 
	EXP : DESTROYER :,\
 2243 
	EXP : DESTROYER :,\
2260 
	EXP lvalue : STRING :,\
 2244 
	EXP lvalue : STRING :,\
2261 
	EXP lvalue : LIST ( STRING ) :,\
 2245 
	EXP lvalue : LIST(STRING) :,\
2262 
	EXP : LIST ( STRING ) :\
 2246 
	EXP : LIST(STRING) :\
2263 
    ) STATEMENT DESTROY_CONS_str #
 2247 
    ) STATEMENT DESTROY_CONS_str #
2264 
 
 2248 
 
2265 
#pragma token PROC (\
 2249 
#pragma token PROC(\
2266 
	EXP : STRING :,\
 2250 
	EXP : STRING :,\
2267 
	EXP lvalue : STACK ( STRING ) :\
 2251 
	EXP lvalue : STACK(STRING) :\
2268 
    ) STATEMENT PUSH_str #
 2252 
    ) STATEMENT PUSH_str #
2269 
 
 2253 
 
2270 
#pragma token PROC (\
 2254 
#pragma token PROC(\
2271 
	EXP lvalue : STRING :,\
 2255 
	EXP lvalue : STRING :,\
2272 
	EXP lvalue : STACK ( STRING ) :\
 2256 
	EXP lvalue : STACK(STRING) :\
2273 
    ) STATEMENT POP_str #
 2257 
    ) STATEMENT POP_str #
2274 
 
 2258 
 
2275 
#pragma interface SIZE_str COPY_str DEREF_str
 2259 
#pragma interface SIZE_str COPY_str DEREF_str
2276 
#pragma interface CONS_str UN_CONS_str DESTROY_CONS_str
 2260 
#pragma interface CONS_str UN_CONS_str DESTROY_CONS_str
2277 
#pragma interface PUSH_str POP_str
 2261 
#pragma interface PUSH_str POP_str
2278 
 
 2262 
 
2279 
 
 2263 
 
2280 
/* Definitions for union EXP */
 2264 
/* Definitions for union EXP */
2281 
 
 2265 
 
2282 
#define ORDER_exp ( ( unsigned ) 88 )
 2266 
#define ORDER_exp ((unsigned)88)
2283 
#pragma token EXP const : EXP : NULL_exp #
 2267 
#pragma token EXP const : EXP : NULL_exp #
2284 
#pragma token PROC ( EXP : EXP : ) EXP : int : IS_NULL_exp #
 2268 
#pragma token PROC(EXP : EXP :) EXP : int : IS_NULL_exp #
2285 
#pragma token PROC ( EXP : EXP :, EXP : EXP : ) EXP : int : EQ_exp #
 2269 
#pragma token PROC(EXP : EXP :, EXP : EXP :) EXP : int : EQ_exp #
2286 
#pragma interface NULL_exp IS_NULL_exp EQ_exp
 2270 
#pragma interface NULL_exp IS_NULL_exp EQ_exp
2287 
 
 2271 
 
2288 
#pragma token EXP const : SIZE ( EXP ) : SIZE_exp #
 2272 
#pragma token EXP const : SIZE(EXP) : SIZE_exp #
2289 
 
 2273 
 
2290 
#pragma token PROC (\
 2274 
#pragma token PROC(\
2291 
	EXP : PTR ( EXP ) :,\
 2275 
	EXP : PTR(EXP) :,\
2292 
	EXP : EXP :\
 2276 
	EXP : EXP :\
2293 
    ) EXP : void : COPY_exp #
 2277 
    ) EXP : void : COPY_exp #
2294 
 
 2278 
 
2295 
#pragma token PROC (\
 2279 
#pragma token PROC(\
2296 
	EXP : PTR ( EXP ) :\
 2280 
	EXP : PTR(EXP) :\
2297 
    ) EXP : EXP : DEREF_exp #
 2281 
    ) EXP : EXP : DEREF_exp #
2298 
 
 2282 
 
2299 
#pragma token PROC (\
 2283 
#pragma token PROC(\
2300 
	EXP : EXP :,\
 2284 
	EXP : EXP :,\
2301 
	EXP : LIST ( EXP ) :,\
 2285 
	EXP : LIST(EXP) :,\
2302 
	EXP lvalue : LIST ( EXP ) :\
 2286 
	EXP lvalue : LIST(EXP) :\
2303 
    ) STATEMENT CONS_exp #
 2287 
    ) STATEMENT CONS_exp #
2304 
 
 2288 
 
2305 
#pragma token PROC (\
 2289 
#pragma token PROC(\
2306 
	EXP lvalue : EXP :,\
 2290 
	EXP lvalue : EXP :,\
2307 
	EXP lvalue : LIST ( EXP ) :,\
 2291 
	EXP lvalue : LIST(EXP) :,\
2308 
	EXP : LIST ( EXP ) :\
 2292 
	EXP : LIST(EXP) :\
2309 
    ) STATEMENT UN_CONS_exp #
 2293 
    ) STATEMENT UN_CONS_exp #
2310 
 
 2294 
 
2311 
#pragma token PROC (\
 2295 
#pragma token PROC(\
2312 
	EXP : DESTROYER :,\
 2296 
	EXP : DESTROYER :,\
2313 
	EXP lvalue : EXP :,\
 2297 
	EXP lvalue : EXP :,\
2314 
	EXP lvalue : LIST ( EXP ) :,\
 2298 
	EXP lvalue : LIST(EXP) :,\
2315 
	EXP : LIST ( EXP ) :\
 2299 
	EXP : LIST(EXP) :\
2316 
    ) STATEMENT DESTROY_CONS_exp #
 2300 
    ) STATEMENT DESTROY_CONS_exp #
2317 
 
 2301 
 
2318 
#pragma token PROC (\
 2302 
#pragma token PROC(\
2319 
	EXP : EXP :,\
 2303 
	EXP : EXP :,\
2320 
	EXP lvalue : STACK ( EXP ) :\
 2304 
	EXP lvalue : STACK(EXP) :\
2321 
    ) STATEMENT PUSH_exp #
 2305 
    ) STATEMENT PUSH_exp #
2322 
 
 2306 
 
2323 
#pragma token PROC (\
 2307 
#pragma token PROC(\
2324 
	EXP lvalue : EXP :,\
 2308 
	EXP lvalue : EXP :,\
2325 
	EXP lvalue : STACK ( EXP ) :\
 2309 
	EXP lvalue : STACK(EXP) :\
2326 
    ) STATEMENT POP_exp #
 2310 
    ) STATEMENT POP_exp #
2327 
 
 2311 
 
2328 
#pragma interface SIZE_exp COPY_exp DEREF_exp
 2312 
#pragma interface SIZE_exp COPY_exp DEREF_exp
2329 
#pragma interface CONS_exp UN_CONS_exp DESTROY_CONS_exp
 2313 
#pragma interface CONS_exp UN_CONS_exp DESTROY_CONS_exp
2330 
#pragma interface PUSH_exp POP_exp
 2314 
#pragma interface PUSH_exp POP_exp
2331 
 
 2315 
 
2332 
 
 2316 
 
2333 
/* Definitions for union OFFSET */
 2317 
/* Definitions for union OFFSET */
2334 
 
 2318 
 
2335 
#define ORDER_off ( ( unsigned ) 13 )
 2319 
#define ORDER_off ((unsigned)13)
2336 
#pragma token EXP const : OFFSET : NULL_off #
 2320 
#pragma token EXP const : OFFSET : NULL_off #
2337 
#pragma token PROC ( EXP : OFFSET : ) EXP : int : IS_NULL_off #
 2321 
#pragma token PROC(EXP : OFFSET :) EXP : int : IS_NULL_off #
2338 
#pragma token PROC ( EXP : OFFSET :, EXP : OFFSET : ) EXP : int : EQ_off #
 2322 
#pragma token PROC(EXP : OFFSET :, EXP : OFFSET :) EXP : int : EQ_off #
2339 
#pragma interface NULL_off IS_NULL_off EQ_off
 2323 
#pragma interface NULL_off IS_NULL_off EQ_off
2340 
 
 2324 
 
2341 
#pragma token EXP const : SIZE ( OFFSET ) : SIZE_off #
 2325 
#pragma token EXP const : SIZE(OFFSET) : SIZE_off #
2342 
 
 2326 
 
2343 
#pragma token PROC (\
 2327 
#pragma token PROC(\
2344 
	EXP : PTR ( OFFSET ) :,\
 2328 
	EXP : PTR(OFFSET) :,\
2345 
	EXP : OFFSET :\
 2329 
	EXP : OFFSET :\
2346 
    ) EXP : void : COPY_off #
 2330 
    ) EXP : void : COPY_off #
2347 
 
 2331 
 
2348 
#pragma token PROC (\
 2332 
#pragma token PROC(\
2349 
	EXP : PTR ( OFFSET ) :\
 2333 
	EXP : PTR(OFFSET) :\
2350 
    ) EXP : OFFSET : DEREF_off #
 2334 
    ) EXP : OFFSET : DEREF_off #
2351 
 
 2335 
 
2352 
#pragma token PROC (\
 2336 
#pragma token PROC(\
2353 
	EXP : OFFSET :,\
 2337 
	EXP : OFFSET :,\
2354 
	EXP : LIST ( OFFSET ) :,\
 2338 
	EXP : LIST(OFFSET) :,\
2355 
	EXP lvalue : LIST ( OFFSET ) :\
 2339 
	EXP lvalue : LIST(OFFSET) :\
2356 
    ) STATEMENT CONS_off #
 2340 
    ) STATEMENT CONS_off #
2357 
 
 2341 
 
2358 
#pragma token PROC (\
 2342 
#pragma token PROC(\
2359 
	EXP lvalue : OFFSET :,\
 2343 
	EXP lvalue : OFFSET :,\
2360 
	EXP lvalue : LIST ( OFFSET ) :,\
 2344 
	EXP lvalue : LIST(OFFSET) :,\
2361 
	EXP : LIST ( OFFSET ) :\
 2345 
	EXP : LIST(OFFSET) :\
2362 
    ) STATEMENT UN_CONS_off #
 2346 
    ) STATEMENT UN_CONS_off #
2363 
 
 2347 
 
2364 
#pragma token PROC (\
 2348 
#pragma token PROC(\
2365 
	EXP : DESTROYER :,\
 2349 
	EXP : DESTROYER :,\
2366 
	EXP lvalue : OFFSET :,\
 2350 
	EXP lvalue : OFFSET :,\
2367 
	EXP lvalue : LIST ( OFFSET ) :,\
 2351 
	EXP lvalue : LIST(OFFSET) :,\
2368 
	EXP : LIST ( OFFSET ) :\
 2352 
	EXP : LIST(OFFSET) :\
2369 
    ) STATEMENT DESTROY_CONS_off #
 2353 
    ) STATEMENT DESTROY_CONS_off #
2370 
 
 2354 
 
2371 
#pragma token PROC (\
 2355 
#pragma token PROC(\
2372 
	EXP : OFFSET :,\
 2356 
	EXP : OFFSET :,\
2373 
	EXP lvalue : STACK ( OFFSET ) :\
 2357 
	EXP lvalue : STACK(OFFSET) :\
2374 
    ) STATEMENT PUSH_off #
 2358 
    ) STATEMENT PUSH_off #
2375 
 
 2359 
 
2376 
#pragma token PROC (\
 2360 
#pragma token PROC(\
2377 
	EXP lvalue : OFFSET :,\
 2361 
	EXP lvalue : OFFSET :,\
2378 
	EXP lvalue : STACK ( OFFSET ) :\
 2362 
	EXP lvalue : STACK(OFFSET) :\
2379 
    ) STATEMENT POP_off #
 2363 
    ) STATEMENT POP_off #
2380 
 
 2364 
 
2381 
#pragma interface SIZE_off COPY_off DEREF_off
 2365 
#pragma interface SIZE_off COPY_off DEREF_off
2382 
#pragma interface CONS_off UN_CONS_off DESTROY_CONS_off
 2366 
#pragma interface CONS_off UN_CONS_off DESTROY_CONS_off
2383 
#pragma interface PUSH_off POP_off
 2367 
#pragma interface PUSH_off POP_off
2384 
 
 2368 
 
2385 
 
 2369 
 
2386 
/* Definitions for union TOKEN */
 2370 
/* Definitions for union TOKEN */
2387 
 
 2371 
 
2388 
#define ORDER_tok ( ( unsigned ) 10 )
 2372 
#define ORDER_tok ((unsigned)10)
2389 
#pragma token EXP const : TOKEN : NULL_tok #
 2373 
#pragma token EXP const : TOKEN : NULL_tok #
2390 
#pragma token PROC ( EXP : TOKEN : ) EXP : int : IS_NULL_tok #
 2374 
#pragma token PROC(EXP : TOKEN :) EXP : int : IS_NULL_tok #
2391 
#pragma token PROC ( EXP : TOKEN :, EXP : TOKEN : ) EXP : int : EQ_tok #
 2375 
#pragma token PROC(EXP : TOKEN :, EXP : TOKEN :) EXP : int : EQ_tok #
2392 
#pragma interface NULL_tok IS_NULL_tok EQ_tok
 2376 
#pragma interface NULL_tok IS_NULL_tok EQ_tok
2393 
 
 2377 
 
2394 
#pragma token EXP const : SIZE ( TOKEN ) : SIZE_tok #
 2378 
#pragma token EXP const : SIZE(TOKEN) : SIZE_tok #
2395 
 
 2379 
 
2396 
#pragma token PROC (\
 2380 
#pragma token PROC(\
2397 
	EXP : PTR ( TOKEN ) :,\
 2381 
	EXP : PTR(TOKEN) :,\
2398 
	EXP : TOKEN :\
 2382 
	EXP : TOKEN :\
2399 
    ) EXP : void : COPY_tok #
 2383 
    ) EXP : void : COPY_tok #
2400 
 
 2384 
 
2401 
#pragma token PROC (\
 2385 
#pragma token PROC(\
2402 
	EXP : PTR ( TOKEN ) :\
 2386 
	EXP : PTR(TOKEN) :\
2403 
    ) EXP : TOKEN : DEREF_tok #
 2387 
    ) EXP : TOKEN : DEREF_tok #
2404 
 
 2388 
 
2405 
#pragma token PROC (\
 2389 
#pragma token PROC(\
2406 
	EXP : TOKEN :,\
 2390 
	EXP : TOKEN :,\
2407 
	EXP : LIST ( TOKEN ) :,\
 2391 
	EXP : LIST(TOKEN) :,\
2408 
	EXP lvalue : LIST ( TOKEN ) :\
 2392 
	EXP lvalue : LIST(TOKEN) :\
2409 
    ) STATEMENT CONS_tok #
 2393 
    ) STATEMENT CONS_tok #
2410 
 
 2394 
 
2411 
#pragma token PROC (\
 2395 
#pragma token PROC(\
2412 
	EXP lvalue : TOKEN :,\
 2396 
	EXP lvalue : TOKEN :,\
2413 
	EXP lvalue : LIST ( TOKEN ) :,\
 2397 
	EXP lvalue : LIST(TOKEN) :,\
2414 
	EXP : LIST ( TOKEN ) :\
 2398 
	EXP : LIST(TOKEN) :\
2415 
    ) STATEMENT UN_CONS_tok #
 2399 
    ) STATEMENT UN_CONS_tok #
2416 
 
 2400 
 
2417 
#pragma token PROC (\
 2401 
#pragma token PROC(\
2418 
	EXP : DESTROYER :,\
 2402 
	EXP : DESTROYER :,\
2419 
	EXP lvalue : TOKEN :,\
 2403 
	EXP lvalue : TOKEN :,\
2420 
	EXP lvalue : LIST ( TOKEN ) :,\
 2404 
	EXP lvalue : LIST(TOKEN) :,\
2421 
	EXP : LIST ( TOKEN ) :\
 2405 
	EXP : LIST(TOKEN) :\
2422 
    ) STATEMENT DESTROY_CONS_tok #
 2406 
    ) STATEMENT DESTROY_CONS_tok #
2423 
 
 2407 
 
2424 
#pragma token PROC (\
 2408 
#pragma token PROC(\
2425 
	EXP : TOKEN :,\
 2409 
	EXP : TOKEN :,\
2426 
	EXP lvalue : STACK ( TOKEN ) :\
 2410 
	EXP lvalue : STACK(TOKEN) :\
2427 
    ) STATEMENT PUSH_tok #
 2411 
    ) STATEMENT PUSH_tok #
2428 
 
 2412 
 
2429 
#pragma token PROC (\
 2413 
#pragma token PROC(\
2430 
	EXP lvalue : TOKEN :,\
 2414 
	EXP lvalue : TOKEN :,\
2431 
	EXP lvalue : STACK ( TOKEN ) :\
 2415 
	EXP lvalue : STACK(TOKEN) :\
2432 
    ) STATEMENT POP_tok #
 2416 
    ) STATEMENT POP_tok #
2433 
 
 2417 
 
2434 
#pragma interface SIZE_tok COPY_tok DEREF_tok
 2418 
#pragma interface SIZE_tok COPY_tok DEREF_tok
2435 
#pragma interface CONS_tok UN_CONS_tok DESTROY_CONS_tok
 2419 
#pragma interface CONS_tok UN_CONS_tok DESTROY_CONS_tok
2436 
#pragma interface PUSH_tok POP_tok
 2420 
#pragma interface PUSH_tok POP_tok
2437 
 
 2421 
 
2438 
 
 2422 
 
2439 
/* Definitions for union INSTANCE */
 2423 
/* Definitions for union INSTANCE */
2440 
 
 2424 
 
2441 
#define ORDER_inst ( ( unsigned ) 2 )
 2425 
#define ORDER_inst ((unsigned)2)
2442 
#pragma token EXP const : INSTANCE : NULL_inst #
 2426 
#pragma token EXP const : INSTANCE : NULL_inst #
2443 
#pragma token PROC ( EXP : INSTANCE : ) EXP : int : IS_NULL_inst #
 2427 
#pragma token PROC(EXP : INSTANCE :) EXP : int : IS_NULL_inst #
2444 
#pragma token PROC ( EXP : INSTANCE :, EXP : INSTANCE : ) EXP : int : EQ_inst #
 2428 
#pragma token PROC(EXP : INSTANCE :, EXP : INSTANCE :) EXP : int : EQ_inst #
2445 
#pragma interface NULL_inst IS_NULL_inst EQ_inst
 2429 
#pragma interface NULL_inst IS_NULL_inst EQ_inst
2446 
 
 2430 
 
2447 
#pragma token EXP const : SIZE ( INSTANCE ) : SIZE_inst #
 2431 
#pragma token EXP const : SIZE(INSTANCE) : SIZE_inst #
2448 
 
 2432 
 
2449 
#pragma token PROC (\
 2433 
#pragma token PROC(\
2450 
	EXP : PTR ( INSTANCE ) :,\
 2434 
	EXP : PTR(INSTANCE) :,\
2451 
	EXP : INSTANCE :\
 2435 
	EXP : INSTANCE :\
2452 
    ) EXP : void : COPY_inst #
 2436 
    ) EXP : void : COPY_inst #
2453 
 
 2437 
 
2454 
#pragma token PROC (\
 2438 
#pragma token PROC(\
2455 
	EXP : PTR ( INSTANCE ) :\
 2439 
	EXP : PTR(INSTANCE) :\
2456 
    ) EXP : INSTANCE : DEREF_inst #
 2440 
    ) EXP : INSTANCE : DEREF_inst #
2457 
 
 2441 
 
2458 
#pragma token PROC (\
 2442 
#pragma token PROC(\
2459 
	EXP : INSTANCE :,\
 2443 
	EXP : INSTANCE :,\
2460 
	EXP : LIST ( INSTANCE ) :,\
 2444 
	EXP : LIST(INSTANCE) :,\
2461 
	EXP lvalue : LIST ( INSTANCE ) :\
 2445 
	EXP lvalue : LIST(INSTANCE) :\
2462 
    ) STATEMENT CONS_inst #
 2446 
    ) STATEMENT CONS_inst #
2463 
 
 2447 
 
2464 
#pragma token PROC (\
 2448 
#pragma token PROC(\
2465 
	EXP lvalue : INSTANCE :,\
 2449 
	EXP lvalue : INSTANCE :,\
2466 
	EXP lvalue : LIST ( INSTANCE ) :,\
 2450 
	EXP lvalue : LIST(INSTANCE) :,\
2467 
	EXP : LIST ( INSTANCE ) :\
 2451 
	EXP : LIST(INSTANCE) :\
2468 
    ) STATEMENT UN_CONS_inst #
 2452 
    ) STATEMENT UN_CONS_inst #
2469 
 
 2453 
 
2470 
#pragma token PROC (\
 2454 
#pragma token PROC(\
2471 
	EXP : DESTROYER :,\
 2455 
	EXP : DESTROYER :,\
2472 
	EXP lvalue : INSTANCE :,\
 2456 
	EXP lvalue : INSTANCE :,\
2473 
	EXP lvalue : LIST ( INSTANCE ) :,\
 2457 
	EXP lvalue : LIST(INSTANCE) :,\
2474 
	EXP : LIST ( INSTANCE ) :\
 2458 
	EXP : LIST(INSTANCE) :\
2475 
    ) STATEMENT DESTROY_CONS_inst #
 2459 
    ) STATEMENT DESTROY_CONS_inst #
2476 
 
 2460 
 
2477 
#pragma token PROC (\
 2461 
#pragma token PROC(\
2478 
	EXP : INSTANCE :,\
 2462 
	EXP : INSTANCE :,\
2479 
	EXP lvalue : STACK ( INSTANCE ) :\
 2463 
	EXP lvalue : STACK(INSTANCE) :\
2480 
    ) STATEMENT PUSH_inst #
 2464 
    ) STATEMENT PUSH_inst #
2481 
 
 2465 
 
2482 
#pragma token PROC (\
 2466 
#pragma token PROC(\
2483 
	EXP lvalue : INSTANCE :,\
 2467 
	EXP lvalue : INSTANCE :,\
2484 
	EXP lvalue : STACK ( INSTANCE ) :\
 2468 
	EXP lvalue : STACK(INSTANCE) :\
2485 
    ) STATEMENT POP_inst #
 2469 
    ) STATEMENT POP_inst #
2486 
 
 2470 
 
2487 
#pragma interface SIZE_inst COPY_inst DEREF_inst
 2471 
#pragma interface SIZE_inst COPY_inst DEREF_inst
2488 
#pragma interface CONS_inst UN_CONS_inst DESTROY_CONS_inst
 2472 
#pragma interface CONS_inst UN_CONS_inst DESTROY_CONS_inst
2489 
#pragma interface PUSH_inst POP_inst
 2473 
#pragma interface PUSH_inst POP_inst
2490 
 
 2474 
 
2491 
 
 2475 
 
2492 
/* Definitions for union ERROR */
 2476 
/* Definitions for union ERROR */
2493 
 
 2477 
 
2494 
#define ORDER_err ( ( unsigned ) 2 )
 2478 
#define ORDER_err ((unsigned)2)
2495 
#pragma token EXP const : ERROR : NULL_err #
 2479 
#pragma token EXP const : ERROR : NULL_err #
2496 
#pragma token PROC ( EXP : ERROR : ) EXP : int : IS_NULL_err #
 2480 
#pragma token PROC(EXP : ERROR :) EXP : int : IS_NULL_err #
2497 
#pragma token PROC ( EXP : ERROR :, EXP : ERROR : ) EXP : int : EQ_err #
 2481 
#pragma token PROC(EXP : ERROR :, EXP : ERROR :) EXP : int : EQ_err #
2498 
#pragma interface NULL_err IS_NULL_err EQ_err
 2482 
#pragma interface NULL_err IS_NULL_err EQ_err
2499 
 
 2483 
 
2500 
#pragma token EXP const : SIZE ( ERROR ) : SIZE_err #
 2484 
#pragma token EXP const : SIZE(ERROR) : SIZE_err #
2501 
 
 2485 
 
2502 
#pragma token PROC (\
 2486 
#pragma token PROC(\
2503 
	EXP : PTR ( ERROR ) :,\
 2487 
	EXP : PTR(ERROR) :,\
2504 
	EXP : ERROR :\
 2488 
	EXP : ERROR :\
2505 
    ) EXP : void : COPY_err #
 2489 
    ) EXP : void : COPY_err #
2506 
 
 2490 
 
2507 
#pragma token PROC (\
 2491 
#pragma token PROC(\
2508 
	EXP : PTR ( ERROR ) :\
 2492 
	EXP : PTR(ERROR) :\
2509 
    ) EXP : ERROR : DEREF_err #
 2493 
    ) EXP : ERROR : DEREF_err #
2510 
 
 2494 
 
2511 
#pragma token PROC (\
 2495 
#pragma token PROC(\
2512 
	EXP : ERROR :,\
 2496 
	EXP : ERROR :,\
2513 
	EXP : LIST ( ERROR ) :,\
 2497 
	EXP : LIST(ERROR) :,\
2514 
	EXP lvalue : LIST ( ERROR ) :\
 2498 
	EXP lvalue : LIST(ERROR) :\
2515 
    ) STATEMENT CONS_err #
 2499 
    ) STATEMENT CONS_err #
2516 
 
 2500 
 
2517 
#pragma token PROC (\
 2501 
#pragma token PROC(\
2518 
	EXP lvalue : ERROR :,\
 2502 
	EXP lvalue : ERROR :,\
2519 
	EXP lvalue : LIST ( ERROR ) :,\
 2503 
	EXP lvalue : LIST(ERROR) :,\
2520 
	EXP : LIST ( ERROR ) :\
 2504 
	EXP : LIST(ERROR) :\
2521 
    ) STATEMENT UN_CONS_err #
 2505 
    ) STATEMENT UN_CONS_err #
2522 
 
 2506 
 
2523 
#pragma token PROC (\
 2507 
#pragma token PROC(\
2524 
	EXP : DESTROYER :,\
 2508 
	EXP : DESTROYER :,\
2525 
	EXP lvalue : ERROR :,\
 2509 
	EXP lvalue : ERROR :,\
2526 
	EXP lvalue : LIST ( ERROR ) :,\
 2510 
	EXP lvalue : LIST(ERROR) :,\
2527 
	EXP : LIST ( ERROR ) :\
 2511 
	EXP : LIST(ERROR) :\
2528 
    ) STATEMENT DESTROY_CONS_err #
 2512 
    ) STATEMENT DESTROY_CONS_err #
2529 
 
 2513 
 
2530 
#pragma token PROC (\
 2514 
#pragma token PROC(\
2531 
	EXP : ERROR :,\
 2515 
	EXP : ERROR :,\
2532 
	EXP lvalue : STACK ( ERROR ) :\
 2516 
	EXP lvalue : STACK(ERROR) :\
2533 
    ) STATEMENT PUSH_err #
 2517 
    ) STATEMENT PUSH_err #
2534 
 
 2518 
 
2535 
#pragma token PROC (\
 2519 
#pragma token PROC(\
2536 
	EXP lvalue : ERROR :,\
 2520 
	EXP lvalue : ERROR :,\
2537 
	EXP lvalue : STACK ( ERROR ) :\
 2521 
	EXP lvalue : STACK(ERROR) :\
2538 
    ) STATEMENT POP_err #
 2522 
    ) STATEMENT POP_err #
2539 
 
 2523 
 
2540 
#pragma interface SIZE_err COPY_err DEREF_err
 2524 
#pragma interface SIZE_err COPY_err DEREF_err
2541 
#pragma interface CONS_err UN_CONS_err DESTROY_CONS_err
 2525 
#pragma interface CONS_err UN_CONS_err DESTROY_CONS_err
2542 
#pragma interface PUSH_err POP_err
 2526 
#pragma interface PUSH_err POP_err