Subversion Repositories tendra.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 7u83 1 
/*
2 
    		 Crown Copyright (c) 1997
3 
 
4 
    This TenDRA(r) Computer Program is subject to Copyright
5 
    owned by the United Kingdom Secretary of State for Defence
6 
    acting through the Defence Evaluation and Research Agency
7 
    (DERA).  It is made available to Recipients with a
8 
    royalty-free licence for its use, reproduction, transfer
9 
    to other parties and amendment for any purpose not excluding
10 
    product development provided that any such use et cetera
11 
    shall be deemed to be acceptance of the following conditions:-
12 
 
13 
        (1) Its Recipients shall ensure that this Notice is
14 
        reproduced upon any copies or amended versions of it;
15 
 
16 
        (2) Any amended version of it shall be clearly marked to
17 
        show both the nature of and the organisation responsible
18 
        for the relevant amendment or amendments;
19 
 
20 
        (3) Its onward transfer from a recipient to another
21 
        party shall be deemed to be that party's acceptance of
22 
        these conditions;
23 
 
24 
        (4) DERA gives no warranty or assurance as to its
25 
        quality or suitability for any purpose and DERA accepts
26 
        no liability whatsoever in relation to any use to which
27 
        it may be put.
28 
*/
29 
 
30 
/*
31 
    AUTOMATICALLY GENERATED FROM ALGEBRA calculus (VERSION 1.2)
32 
    BY calculus (VERSION 1.2)
33 
*/
34 
 
35 
#ifndef CALCULUS_H_TOK_INCLUDED
36 
#define CALCULUS_H_TOK_INCLUDED
37 
 
38 
#ifndef calculus_NAME
39 
#define calculus_NAME			"calculus"
40 
#define calculus_VERSION		"1.2"
41 
#define calculus_SPECIFICATION		1
42 
#define calculus_IMPLEMENTATION		0
43 
#endif
44 
 
45 
 
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 
 
64 
#ifndef CONST_S
65 
#define CONST_S
66 
#endif
67 
 
68 
 
69 
/* Primitive types */
70 
 
71 
typedef unsigned long number ;
72 
typedef char * string ;
73 
 
74 
 
75 
/* Basic types */
76 
 
77 
#ifndef calculus_DESTR_DEFINED
78 
#define calculus_DESTR_DEFINED
79 
typedef void ( *DESTROYER ) () ;
80 
#endif
81 
 
82 
#pragma token PROC ( TYPE ) TYPE PTR #
83 
#pragma token PROC ( TYPE ) TYPE LIST #
84 
#pragma token PROC ( TYPE ) TYPE STACK #
85 
#pragma token PROC ( TYPE ) TYPE SIZE #
86 
 
87 
#pragma interface PTR LIST STACK SIZE
88 
 
89 
 
90 
/* Enumeration type definitions */
91 
 
92 
 
93 
 
94 
/* Union type definitions */
95 
 
96 
#pragma token TYPE TYPE #
97 
#pragma interface TYPE
98 
#pragma token TYPE COMMAND #
99 
#pragma interface COMMAND
100 
 
101 
 
102 
/* Structure declarations */
103 
 
104 
typedef struct alg_tag ALGEBRA_DEFN ;
105 
typedef struct cid_tag CLASS_ID ;
106 
typedef struct prim_tag PRIMITIVE ;
107 
typedef struct ec_tag ECONST ;
108 
typedef struct en_tag ENUM ;
109 
typedef struct ident_tag IDENTITY ;
110 
typedef struct cmp_tag COMPONENT ;
111 
typedef struct str_tag STRUCTURE ;
112 
typedef struct fld_tag FIELD ;
113 
typedef struct arg_tag ARGUMENT ;
114 
typedef struct map_tag MAP ;
115 
typedef struct un_tag UNION ;
116 
 
117 
 
118 
/* Identity type definitions */
119 
 
120 
typedef string name_string ;
121 
typedef int zero_int ;
122 
typedef PTR ( int ) int_P ;
123 
typedef PTR ( number ) number_P ;
124 
typedef PTR ( string ) string_P ;
125 
typedef PTR ( ARGUMENT ) ARGUMENT_P ;
126 
typedef PTR ( CLASS_ID ) CLASS_ID_P ;
127 
typedef PTR ( CLASS_ID_P ) CLASS_ID_P_P ;
128 
typedef PTR ( COMPONENT ) COMPONENT_P ;
129 
typedef PTR ( ECONST ) ECONST_P ;
130 
typedef PTR ( ENUM ) ENUM_P ;
131 
typedef PTR ( FIELD ) FIELD_P ;
132 
typedef PTR ( IDENTITY ) IDENTITY_P ;
133 
typedef PTR ( MAP ) MAP_P ;
134 
typedef PTR ( PRIMITIVE ) PRIMITIVE_P ;
135 
typedef PTR ( STRUCTURE ) STRUCTURE_P ;
136 
typedef PTR ( TYPE ) TYPE_P ;
137 
typedef PTR ( TYPE_P ) TYPE_P_P ;
138 
typedef PTR ( UNION ) UNION_P ;
139 
 
140 
 
141 
/* Structure definitions */
142 
 
143 
#ifndef calculus_STRUCT_DEFINED
144 
#define calculus_STRUCT_DEFINED
145 
 
146 
struct alg_tag {
147 
    string name ;
148 
    int major_no ;
149 
    int minor_no ;
150 
    LIST ( PRIMITIVE_P ) primitives ;
151 
    LIST ( IDENTITY_P ) identities ;
152 
    LIST ( ENUM_P ) enumerations ;
153 
    LIST ( STRUCTURE_P ) structures ;
154 
    LIST ( UNION_P ) unions ;
155 
    LIST ( TYPE_P ) types ;
156 
} ;
157 
 
158 
struct cid_tag {
159 
    string name ;
160 
    string name_aux ;
161 
    int flag ;
162 
    name_string file ;
163 
    int line ;
164 
} ;
165 
 
166 
struct prim_tag {
167 
    CLASS_ID_P id ;
168 
    string defn ;
169 
} ;
170 
 
171 
struct ec_tag {
172 
    string name ;
173 
    number value ;
174 
} ;
175 
 
176 
struct en_tag {
177 
    CLASS_ID_P id ;
178 
    LIST ( ECONST_P ) consts ;
179 
    number order ;
180 
    int lists ;
181 
} ;
182 
 
183 
struct ident_tag {
184 
    CLASS_ID_P id ;
185 
    TYPE_P defn ;
186 
} ;
187 
 
188 
struct cmp_tag {
189 
    string name ;
190 
    TYPE_P type ;
191 
    string value ;
192 
} ;
193 
 
194 
struct str_tag {
195 
    CLASS_ID_P id ;
196 
    STRUCTURE_P base ;
197 
    LIST ( COMPONENT_P ) defn ;
198 
    zero_int output ;
199 
} ;
200 
 
201 
struct fld_tag {
202 
    string name ;
203 
    int tag ;
204 
    int flag ;
205 
    int set ;
206 
    FIELD_P base ;
207 
    LIST ( COMPONENT_P ) defn ;
208 
} ;
209 
 
210 
struct arg_tag {
211 
    string name ;
212 
    TYPE_P type ;
213 
} ;
214 
 
215 
struct map_tag {
216 
    string name ;
217 
    int flag ;
218 
    TYPE_P ret_type ;
219 
    LIST ( ARGUMENT_P ) args ;
220 
} ;
221 
 
222 
struct un_tag {
223 
    CLASS_ID_P id ;
224 
    UNION_P base ;
225 
    LIST ( COMPONENT_P ) s_defn ;
226 
    LIST ( FIELD_P ) u_defn ;
227 
    LIST ( MAP_P ) map ;
228 
    int no_fields ;
229 
} ;
230 
 
231 
#endif /* calculus_STRUCT_DEFINED */
232 
 
233 
 
234 
/* Function declarations */
235 
 
236 
extern void destroy_calculus () ;
237 
extern void dummy_destroy_calculus () ;
238 
#ifdef calculus_IO_ROUTINES
239 
extern unsigned crt_calculus_alias ;
240 
extern void clear_calculus_alias PROTO_S ( ( void ) ) ;
241 
#endif
242 
 
243 
 
244 
/* Pointer token specifications */
245 
 
246 
#pragma token PROC {\
247 
	TYPE t, EXP : PTR ( t ) : e1, EXP : SIZE ( t ) : e2 |\
248 
	EXP e1, EXP e2\
249 
    } EXP : PTR ( t ) : STEP_ptr #
250 
 
251 
#pragma token PROC (\
252 
	TYPE t\
253 
    ) EXP const : PTR ( t ) : NULL_ptr #
254 
 
255 
#pragma token PROC {\
256 
	TYPE t, EXP : PTR ( t ) : e |\
257 
	EXP e\
258 
    } EXP : int : IS_NULL_ptr #
259 
 
260 
#pragma token PROC {\
261 
	TYPE t, EXP : PTR ( t ) : e1, EXP : PTR ( t ) : e2 |\
262 
	EXP e1, EXP e2\
263 
    } EXP : int : EQ_ptr #
264 
 
265 
#pragma token PROC {\
266 
	TYPE t, EXP : SIZE ( t ) : e |\
267 
	EXP e\
268 
    } EXP : PTR ( t ) : MAKE_ptr #
269 
 
270 
#pragma token PROC {\
271 
	TYPE t, EXP : PTR ( t ) : e1, EXP : SIZE ( t ) : e2 |\
272 
	EXP e1, EXP e2\
273 
    } EXP : void : DESTROY_ptr #
274 
 
275 
#pragma token PROC (\
276 
	TYPE t\
277 
    ) EXP : PTR ( t ) : UNIQ_ptr #
278 
 
279 
#pragma token PROC {\
280 
	TYPE t, EXP : PTR ( t ) : e |\
281 
	EXP e\
282 
    } EXP : void : DESTROY_UNIQ_ptr #
283 
 
284 
#pragma interface STEP_ptr NULL_ptr IS_NULL_ptr EQ_ptr
285 
#pragma interface MAKE_ptr DESTROY_ptr
286 
 
287 
#ifdef calculus_IO_ROUTINES
288 
#pragma token PROC {\
289 
	TYPE t, EXP : PTR ( t ) : e |\
290 
	EXP e\
291 
    } EXP : void * : VOIDSTAR_ptr #
292 
#pragma interface VOIDSTAR_ptr
293 
#endif
294 
 
295 
#pragma token PROC (\
296 
	TYPE t\
297 
    ) EXP const : SIZE ( PTR ( t ) ) : SIZE_ptr #
298 
 
299 
#pragma token PROC {\
300 
	TYPE t, EXP : PTR ( PTR ( t ) ) : e1,\
301 
	EXP : PTR ( t ) : e2 |\
302 
	EXP e1, EXP e2\
303 
    } EXP : void : COPY_ptr #
304 
 
305 
#pragma token PROC {\
306 
	TYPE t, EXP : PTR ( PTR ( t ) ) : e |\
307 
	EXP e\
308 
    } EXP : PTR ( t ) : DEREF_ptr #
309 
 
310 
#pragma token PROC {\
311 
	TYPE t, EXP : PTR ( t ) : e2,\
312 
	EXP : LIST ( PTR ( t ) ) : e3,\
313 
	EXP lvalue : LIST ( PTR ( t ) ) : e4 |\
314 
	EXP e2, EXP e3, EXP e4\
315 
    } STATEMENT CONS_ptr #
316 
 
317 
#pragma token PROC {\
318 
	TYPE t, EXP lvalue : PTR ( t ) : e2,\
319 
	EXP lvalue : LIST ( PTR ( t ) ) : e3,\
320 
	EXP : LIST ( PTR ( t ) ) : e4 |\
321 
	EXP e2, EXP e3, EXP e4\
322 
    } STATEMENT UN_CONS_ptr #
323 
 
324 
#pragma token PROC {\
325 
	TYPE t, EXP : DESTROYER : e1,\
326 
	EXP lvalue : PTR ( t ) : e2,\
327 
	EXP lvalue : LIST ( PTR ( t ) ) : e3,\
328 
	EXP : LIST ( PTR ( t ) ) : e4 |\
329 
	EXP e1, EXP e2, EXP e3, EXP e4\
330 
    } STATEMENT DESTROY_CONS_ptr #
331 
 
332 
#pragma token PROC {\
333 
	TYPE t, EXP : PTR ( t ) : e2,\
334 
	EXP lvalue : STACK ( PTR ( t ) ) : e3 |\
335 
	EXP e2, EXP e3\
336 
    } STATEMENT PUSH_ptr #
337 
 
338 
#pragma token PROC {\
339 
	TYPE t, EXP lvalue : PTR ( t ) : e2,\
340 
	EXP lvalue : STACK ( PTR ( t ) ) : e3 |\
341 
	EXP e2, EXP e3\
342 
    } STATEMENT POP_ptr #
343 
 
344 
#pragma interface SIZE_ptr COPY_ptr DEREF_ptr
345 
#pragma interface CONS_ptr UN_CONS_ptr DESTROY_CONS_ptr
346 
#pragma interface PUSH_ptr POP_ptr
347 
 
348 
 
349 
/* List token specifications */
350 
 
351 
#pragma token PROC {\
352 
	TYPE t, EXP : LIST ( t ) : e |\
353 
	EXP e\
354 
    } EXP : PTR ( t ) : HEAD_list #
355 
 
356 
#pragma token PROC {\
357 
	TYPE t, EXP : LIST ( t ) : e |\
358 
	EXP e\
359 
    } EXP : PTR ( LIST ( t ) ) : PTR_TAIL_list #
360 
 
361 
#pragma token PROC {\
362 
	TYPE t, EXP : LIST ( t ) : e |\
363 
	EXP e\
364 
    } EXP : LIST ( t ) : TAIL_list #
365 
 
366 
#pragma token PROC {\
367 
	TYPE t, EXP : LIST ( t ) : e1 |\
368 
	EXP e1\
369 
    } EXP : unsigned : LENGTH_list #
370 
 
371 
#pragma token PROC {\
372 
	TYPE t, EXP : LIST ( t ) : e1 |\
373 
	EXP e1\
374 
    } EXP : LIST ( t ) : END_list #
375 
 
376 
#pragma token PROC {\
377 
	TYPE t, EXP : LIST ( t ) : e1 |\
378 
	EXP e1\
379 
    } EXP : LIST ( t ) : REVERSE_list #
380 
 
381 
#pragma token PROC {\
382 
	TYPE t, EXP : LIST ( t ) : e1, EXP : LIST ( t ) : e2 |\
383 
	EXP e1, EXP e2\
384 
    } EXP : LIST ( t ) : APPEND_list #
385 
 
386 
#pragma token PROC (\
387 
	TYPE t\
388 
    ) EXP const : LIST ( t ) : NULL_list #
389 
 
390 
#pragma token PROC {\
391 
	TYPE t, EXP : LIST ( t ) : e |\
392 
	EXP e\
393 
    } EXP : int : IS_NULL_list #
394 
 
395 
#pragma token PROC {\
396 
	TYPE t, EXP : LIST ( t ) : e1, EXP : LIST ( t ) : e2 |\
397 
	EXP e1, EXP e2\
398 
    } EXP : int : EQ_list #
399 
 
400 
#pragma token PROC (\
401 
	TYPE t\
402 
    ) EXP : LIST ( t ) : UNIQ_list #
403 
 
404 
#pragma token PROC {\
405 
	TYPE t, EXP : LIST ( t ) : e |\
406 
	EXP e\
407 
    } EXP : void : DESTROY_UNIQ_list #
408 
 
409 
#pragma token PROC {\
410 
	TYPE t, EXP : LIST ( t ) : e1, EXP : SIZE ( t ) : e2 |\
411 
	EXP e1, EXP e2\
412 
    } STATEMENT DESTROY_list #
413 
 
414 
#pragma interface HEAD_list PTR_TAIL_list TAIL_list
415 
#pragma interface LENGTH_list END_list REVERSE_list APPEND_list
416 
#pragma interface NULL_list IS_NULL_list EQ_list
417 
#pragma interface UNIQ_list DESTROY_UNIQ_list DESTROY_list
418 
 
419 
#ifdef calculus_IO_ROUTINES
420 
#pragma token PROC {\
421 
	TYPE t, EXP : LIST ( t ) : e |\
422 
	EXP e\
423 
    } EXP : void * : VOIDSTAR_list #
424 
#pragma interface VOIDSTAR_list
425 
#endif
426 
 
427 
#pragma token PROC (\
428 
	TYPE t\
429 
    ) EXP const : SIZE ( LIST ( t ) ) : SIZE_list #
430 
 
431 
#pragma token PROC {\
432 
	TYPE t, EXP : PTR ( LIST ( t ) ) : e1,\
433 
	EXP : LIST ( t ) : e2 |\
434 
	EXP e1, EXP e2\
435 
    } EXP : void : COPY_list #
436 
 
437 
#pragma token PROC {\
438 
	TYPE t, EXP : PTR ( LIST ( t ) ) : e |\
439 
	EXP e\
440 
    } EXP : LIST ( t ) : DEREF_list #
441 
 
442 
#pragma token PROC {\
443 
	TYPE t, EXP : LIST ( t ) : e2,\
444 
	EXP : LIST ( LIST ( t ) ) : e3,\
445 
	EXP lvalue : LIST ( LIST ( t ) ) : e4 |\
446 
	EXP e2, EXP e3, EXP e4\
447 
    } STATEMENT CONS_list #
448 
 
449 
#pragma token PROC {\
450 
	TYPE t, EXP lvalue : LIST ( t ) : e2,\
451 
	EXP lvalue : LIST ( LIST ( t ) ) : e3,\
452 
	EXP : LIST ( LIST ( t ) ) : e4 |\
453 
	EXP e2, EXP e3, EXP e4\
454 
    } STATEMENT UN_CONS_list #
455 
 
456 
#pragma token PROC {\
457 
	TYPE t, EXP : DESTROYER : e1,\
458 
	EXP lvalue : LIST ( t ) : e2,\
459 
	EXP lvalue : LIST ( LIST ( t ) ) : e3,\
460 
	EXP : LIST ( LIST ( t ) ) : e4 |\
461 
	EXP e1, EXP e2, EXP e3, EXP e4\
462 
    } STATEMENT DESTROY_CONS_list #
463 
 
464 
#pragma token PROC {\
465 
	TYPE t, EXP : LIST ( t ) : e2,\
466 
	EXP lvalue : STACK ( LIST ( t ) ) : e3 |\
467 
	EXP e2, EXP e3\
468 
    } STATEMENT PUSH_list #
469 
 
470 
#pragma token PROC {\
471 
	TYPE t, EXP lvalue : LIST ( t ) : e2,\
472 
	EXP lvalue : STACK ( LIST ( t ) ) : e3 |\
473 
	EXP e2, EXP e3\
474 
    } STATEMENT POP_list #
475 
 
476 
#pragma interface SIZE_list COPY_list DEREF_list
477 
#pragma interface CONS_list UN_CONS_list DESTROY_CONS_list
478 
#pragma interface PUSH_list POP_list
479 
 
480 
 
481 
/* Stack token specifications */
482 
 
483 
#pragma token PROC (\
484 
	TYPE t\
485 
    ) EXP const : STACK ( t ) : NULL_stack #
486 
 
487 
#pragma token PROC {\
488 
	TYPE t, EXP : STACK ( t ) : e |\
489 
	EXP e\
490 
    } EXP : int : IS_NULL_stack #
491 
 
492 
#pragma token PROC {\
493 
	TYPE t, EXP : STACK ( t ) : e1 |\
494 
	EXP e1\
495 
    } EXP : LIST ( t ) : LIST_stack #
496 
 
497 
#pragma token PROC {\
498 
	TYPE t, EXP : LIST ( t ) : e1 |\
499 
	EXP e1\
500 
    } EXP : STACK ( t ) : STACK_list #
501 
 
502 
#pragma interface NULL_stack IS_NULL_stack LIST_stack STACK_list
503 
 
504 
#pragma token PROC (\
505 
	TYPE t\
506 
    ) EXP const : SIZE ( STACK ( t ) ) : SIZE_stack #
507 
 
508 
#pragma token PROC {\
509 
	TYPE t, EXP : PTR ( STACK ( t ) ) : e1,\
510 
	EXP : STACK ( t ) : e2 |\
511 
	EXP e1, EXP e2\
512 
    } EXP : void : COPY_stack #
513 
 
514 
#pragma token PROC {\
515 
	TYPE t, EXP : PTR ( STACK ( t ) ) : e |\
516 
	EXP e\
517 
    } EXP : STACK ( t ) : DEREF_stack #
518 
 
519 
#pragma token PROC {\
520 
	TYPE t, EXP : STACK ( t ) : e2,\
521 
	EXP : LIST ( STACK ( t ) ) : e3,\
522 
	EXP lvalue : LIST ( STACK ( t ) ) : e4 |\
523 
	EXP e2, EXP e3, EXP e4\
524 
    } STATEMENT CONS_stack #
525 
 
526 
#pragma token PROC {\
527 
	TYPE t, EXP lvalue : STACK ( t ) : e2,\
528 
	EXP lvalue : LIST ( STACK ( t ) ) : e3,\
529 
	EXP : LIST ( STACK ( t ) ) : e4 |\
530 
	EXP e2, EXP e3, EXP e4\
531 
    } STATEMENT UN_CONS_stack #
532 
 
533 
#pragma token PROC {\
534 
	TYPE t, EXP : DESTROYER : e1,\
535 
	EXP lvalue : STACK ( t ) : e2,\
536 
	EXP lvalue : LIST ( STACK ( t ) ) : e3,\
537 
	EXP : LIST ( STACK ( t ) ) : e4 |\
538 
	EXP e1, EXP e2, EXP e3, EXP e4\
539 
    } STATEMENT DESTROY_CONS_stack #
540 
 
541 
#pragma token PROC {\
542 
	TYPE t, EXP : STACK ( t ) : e2,\
543 
	EXP lvalue : STACK ( STACK ( t ) ) : e3 |\
544 
	EXP e2, EXP e3\
545 
    } STATEMENT PUSH_stack #
546 
 
547 
#pragma token PROC {\
548 
	TYPE t, EXP lvalue : STACK ( t ) : e2,\
549 
	EXP lvalue : STACK ( STACK ( t ) ) : e3 |\
550 
	EXP e2, EXP e3\
551 
    } STATEMENT POP_stack #
552 
 
553 
#pragma interface SIZE_stack COPY_stack DEREF_stack
554 
#pragma interface CONS_stack UN_CONS_stack DESTROY_CONS_stack
555 
#pragma interface PUSH_stack POP_stack
556 
 
557 
 
558 
/* Size token specifications */
559 
 
560 
#pragma token PROC {\
561 
	TYPE t, VARIETY v,\
562 
	EXP : SIZE ( t ) : e1, EXP : v : e2 |\
563 
	EXP e1, EXP e2\
564 
    } EXP : SIZE ( t ) : SCALE #
565 
 
566 
#pragma interface SCALE
567 
 
568 
 
569 
/* Definitions for primitive int */
570 
 
571 
#pragma token EXP const : SIZE ( int ) : SIZE_int #
572 
 
573 
#pragma token PROC (\
574 
	EXP : PTR ( int ) :,\
575 
	EXP : int :\
576 
    ) EXP : void : COPY_int #
577 
 
578 
#pragma token PROC (\
579 
	EXP : PTR ( int ) :\
580 
    ) EXP : int : DEREF_int #
581 
 
582 
#pragma token PROC (\
583 
	EXP : int :,\
584 
	EXP : LIST ( int ) :,\
585 
	EXP lvalue : LIST ( int ) :\
586 
    ) STATEMENT CONS_int #
587 
 
588 
#pragma token PROC (\
589 
	EXP lvalue : int :,\
590 
	EXP lvalue : LIST ( int ) :,\
591 
	EXP : LIST ( int ) :\
592 
    ) STATEMENT UN_CONS_int #
593 
 
594 
#pragma token PROC (\
595 
	EXP : DESTROYER :,\
596 
	EXP lvalue : int :,\
597 
	EXP lvalue : LIST ( int ) :,\
598 
	EXP : LIST ( int ) :\
599 
    ) STATEMENT DESTROY_CONS_int #
600 
 
601 
#pragma token PROC (\
602 
	EXP : int :,\
603 
	EXP lvalue : STACK ( int ) :\
604 
    ) STATEMENT PUSH_int #
605 
 
606 
#pragma token PROC (\
607 
	EXP lvalue : int :,\
608 
	EXP lvalue : STACK ( int ) :\
609 
    ) STATEMENT POP_int #
610 
 
611 
#pragma interface SIZE_int COPY_int DEREF_int
612 
#pragma interface CONS_int UN_CONS_int DESTROY_CONS_int
613 
#pragma interface PUSH_int POP_int
614 
 
615 
 
616 
/* Definitions for primitive number */
617 
 
618 
#pragma token EXP const : SIZE ( number ) : SIZE_number #
619 
 
620 
#pragma token PROC (\
621 
	EXP : PTR ( number ) :,\
622 
	EXP : number :\
623 
    ) EXP : void : COPY_number #
624 
 
625 
#pragma token PROC (\
626 
	EXP : PTR ( number ) :\
627 
    ) EXP : number : DEREF_number #
628 
 
629 
#pragma token PROC (\
630 
	EXP : number :,\
631 
	EXP : LIST ( number ) :,\
632 
	EXP lvalue : LIST ( number ) :\
633 
    ) STATEMENT CONS_number #
634 
 
635 
#pragma token PROC (\
636 
	EXP lvalue : number :,\
637 
	EXP lvalue : LIST ( number ) :,\
638 
	EXP : LIST ( number ) :\
639 
    ) STATEMENT UN_CONS_number #
640 
 
641 
#pragma token PROC (\
642 
	EXP : DESTROYER :,\
643 
	EXP lvalue : number :,\
644 
	EXP lvalue : LIST ( number ) :,\
645 
	EXP : LIST ( number ) :\
646 
    ) STATEMENT DESTROY_CONS_number #
647 
 
648 
#pragma token PROC (\
649 
	EXP : number :,\
650 
	EXP lvalue : STACK ( number ) :\
651 
    ) STATEMENT PUSH_number #
652 
 
653 
#pragma token PROC (\
654 
	EXP lvalue : number :,\
655 
	EXP lvalue : STACK ( number ) :\
656 
    ) STATEMENT POP_number #
657 
 
658 
#pragma interface SIZE_number COPY_number DEREF_number
659 
#pragma interface CONS_number UN_CONS_number DESTROY_CONS_number
660 
#pragma interface PUSH_number POP_number
661 
 
662 
 
663 
/* Definitions for primitive string */
664 
 
665 
#pragma token EXP const : SIZE ( string ) : SIZE_string #
666 
 
667 
#pragma token PROC (\
668 
	EXP : PTR ( string ) :,\
669 
	EXP : string :\
670 
    ) EXP : void : COPY_string #
671 
 
672 
#pragma token PROC (\
673 
	EXP : PTR ( string ) :\
674 
    ) EXP : string : DEREF_string #
675 
 
676 
#pragma token PROC (\
677 
	EXP : string :,\
678 
	EXP : LIST ( string ) :,\
679 
	EXP lvalue : LIST ( string ) :\
680 
    ) STATEMENT CONS_string #
681 
 
682 
#pragma token PROC (\
683 
	EXP lvalue : string :,\
684 
	EXP lvalue : LIST ( string ) :,\
685 
	EXP : LIST ( string ) :\
686 
    ) STATEMENT UN_CONS_string #
687 
 
688 
#pragma token PROC (\
689 
	EXP : DESTROYER :,\
690 
	EXP lvalue : string :,\
691 
	EXP lvalue : LIST ( string ) :,\
692 
	EXP : LIST ( string ) :\
693 
    ) STATEMENT DESTROY_CONS_string #
694 
 
695 
#pragma token PROC (\
696 
	EXP : string :,\
697 
	EXP lvalue : STACK ( string ) :\
698 
    ) STATEMENT PUSH_string #
699 
 
700 
#pragma token PROC (\
701 
	EXP lvalue : string :,\
702 
	EXP lvalue : STACK ( string ) :\
703 
    ) STATEMENT POP_string #
704 
 
705 
#pragma interface SIZE_string COPY_string DEREF_string
706 
#pragma interface CONS_string UN_CONS_string DESTROY_CONS_string
707 
#pragma interface PUSH_string POP_string
708 
 
709 
 
710 
/* Definitions for structure ALGEBRA_DEFN */
711 
 
712 
#pragma token PROC ( EXP : PTR ( ALGEBRA_DEFN ) : ) EXP : PTR ( string ) : alg_name #
713 
#pragma interface alg_name
714 
 
715 
#pragma token PROC ( EXP : PTR ( ALGEBRA_DEFN ) : ) EXP : PTR ( int ) : alg_major_no #
716 
#pragma interface alg_major_no
717 
 
718 
#pragma token PROC ( EXP : PTR ( ALGEBRA_DEFN ) : ) EXP : PTR ( int ) : alg_minor_no #
719 
#pragma interface alg_minor_no
720 
 
721 
#pragma token PROC ( EXP : PTR ( ALGEBRA_DEFN ) : ) EXP : PTR ( LIST ( PRIMITIVE_P ) ) : alg_primitives #
722 
#pragma interface alg_primitives
723 
 
724 
#pragma token PROC ( EXP : PTR ( ALGEBRA_DEFN ) : ) EXP : PTR ( LIST ( IDENTITY_P ) ) : alg_identities #
725 
#pragma interface alg_identities
726 
 
727 
#pragma token PROC ( EXP : PTR ( ALGEBRA_DEFN ) : ) EXP : PTR ( LIST ( ENUM_P ) ) : alg_enumerations #
728 
#pragma interface alg_enumerations
729 
 
730 
#pragma token PROC ( EXP : PTR ( ALGEBRA_DEFN ) : ) EXP : PTR ( LIST ( STRUCTURE_P ) ) : alg_structures #
731 
#pragma interface alg_structures
732 
 
733 
#pragma token PROC ( EXP : PTR ( ALGEBRA_DEFN ) : ) EXP : PTR ( LIST ( UNION_P ) ) : alg_unions #
734 
#pragma interface alg_unions
735 
 
736 
#pragma token PROC ( EXP : PTR ( ALGEBRA_DEFN ) : ) EXP : PTR ( LIST ( TYPE_P ) ) : alg_types #
737 
#pragma interface alg_types
738 
 
739 
#pragma token PROC (\
740 
	EXP : string :,\
741 
	EXP : int :,\
742 
	EXP : int :,\
743 
	EXP : LIST ( PRIMITIVE_P ) :,\
744 
	EXP : LIST ( IDENTITY_P ) :,\
745 
	EXP : LIST ( ENUM_P ) :,\
746 
	EXP : LIST ( STRUCTURE_P ) :,\
747 
	EXP : LIST ( UNION_P ) :,\
748 
	EXP : LIST ( TYPE_P ) :,\
749 
	EXP : PTR ( ALGEBRA_DEFN ) :\
750 
    ) STATEMENT MAKE_alg #
751 
#pragma interface MAKE_alg
752 
 
753 
#pragma token EXP const : SIZE ( ALGEBRA_DEFN ) : SIZE_alg #
754 
 
755 
#pragma token PROC (\
756 
	EXP : PTR ( ALGEBRA_DEFN ) :,\
757 
	EXP : ALGEBRA_DEFN :\
758 
    ) STATEMENT COPY_alg #
759 
 
760 
#pragma token PROC (\
761 
	EXP : PTR ( ALGEBRA_DEFN ) :,\
762 
	EXP lvalue : ALGEBRA_DEFN :\
763 
    ) STATEMENT DEREF_alg #
764 
 
765 
#pragma token PROC (\
766 
	EXP : ALGEBRA_DEFN :,\
767 
	EXP : LIST ( ALGEBRA_DEFN ) :,\
768 
	EXP lvalue : LIST ( ALGEBRA_DEFN ) :\
769 
    ) STATEMENT CONS_alg #
770 
 
771 
#pragma token PROC (\
772 
	EXP lvalue : ALGEBRA_DEFN :,\
773 
	EXP lvalue : LIST ( ALGEBRA_DEFN ) :,\
774 
	EXP : LIST ( ALGEBRA_DEFN ) :\
775 
    ) STATEMENT UN_CONS_alg #
776 
 
777 
#pragma token PROC (\
778 
	EXP : DESTROYER :,\
779 
	EXP lvalue : ALGEBRA_DEFN :,\
780 
	EXP lvalue : LIST ( ALGEBRA_DEFN ) :,\
781 
	EXP : LIST ( ALGEBRA_DEFN ) :\
782 
    ) STATEMENT DESTROY_CONS_alg #
783 
 
784 
#pragma token PROC (\
785 
	EXP : ALGEBRA_DEFN :,\
786 
	EXP lvalue : STACK ( ALGEBRA_DEFN ) :\
787 
    ) STATEMENT PUSH_alg #
788 
 
789 
#pragma token PROC (\
790 
	EXP lvalue : ALGEBRA_DEFN :,\
791 
	EXP lvalue : STACK ( ALGEBRA_DEFN ) :\
792 
    ) STATEMENT POP_alg #
793 
 
794 
#pragma interface SIZE_alg COPY_alg DEREF_alg
795 
#pragma interface CONS_alg UN_CONS_alg DESTROY_CONS_alg
796 
#pragma interface PUSH_alg POP_alg
797 
 
798 
 
799 
/* Definitions for structure CLASS_ID */
800 
 
801 
#pragma token PROC ( EXP : PTR ( CLASS_ID ) : ) EXP : PTR ( string ) : cid_name #
802 
#pragma interface cid_name
803 
 
804 
#pragma token PROC ( EXP : PTR ( CLASS_ID ) : ) EXP : PTR ( string ) : cid_name_aux #
805 
#pragma interface cid_name_aux
806 
 
807 
#pragma token PROC ( EXP : PTR ( CLASS_ID ) : ) EXP : PTR ( int ) : cid_flag #
808 
#pragma interface cid_flag
809 
 
810 
#pragma token PROC ( EXP : PTR ( CLASS_ID ) : ) EXP : PTR ( name_string ) : cid_file #
811 
#pragma interface cid_file
812 
 
813 
#pragma token PROC ( EXP : PTR ( CLASS_ID ) : ) EXP : PTR ( int ) : cid_line #
814 
#pragma interface cid_line
815 
 
816 
#pragma token PROC (\
817 
	EXP : string :,\
818 
	EXP : string :,\
819 
	EXP : int :,\
820 
	EXP : name_string :,\
821 
	EXP : int :,\
822 
	EXP : PTR ( CLASS_ID ) :\
823 
    ) STATEMENT MAKE_cid #
824 
#pragma interface MAKE_cid
825 
 
826 
#pragma token EXP const : SIZE ( CLASS_ID ) : SIZE_cid #
827 
 
828 
#pragma token PROC (\
829 
	EXP : PTR ( CLASS_ID ) :,\
830 
	EXP : CLASS_ID :\
831 
    ) STATEMENT COPY_cid #
832 
 
833 
#pragma token PROC (\
834 
	EXP : PTR ( CLASS_ID ) :,\
835 
	EXP lvalue : CLASS_ID :\
836 
    ) STATEMENT DEREF_cid #
837 
 
838 
#pragma token PROC (\
839 
	EXP : CLASS_ID :,\
840 
	EXP : LIST ( CLASS_ID ) :,\
841 
	EXP lvalue : LIST ( CLASS_ID ) :\
842 
    ) STATEMENT CONS_cid #
843 
 
844 
#pragma token PROC (\
845 
	EXP lvalue : CLASS_ID :,\
846 
	EXP lvalue : LIST ( CLASS_ID ) :,\
847 
	EXP : LIST ( CLASS_ID ) :\
848 
    ) STATEMENT UN_CONS_cid #
849 
 
850 
#pragma token PROC (\
851 
	EXP : DESTROYER :,\
852 
	EXP lvalue : CLASS_ID :,\
853 
	EXP lvalue : LIST ( CLASS_ID ) :,\
854 
	EXP : LIST ( CLASS_ID ) :\
855 
    ) STATEMENT DESTROY_CONS_cid #
856 
 
857 
#pragma token PROC (\
858 
	EXP : CLASS_ID :,\
859 
	EXP lvalue : STACK ( CLASS_ID ) :\
860 
    ) STATEMENT PUSH_cid #
861 
 
862 
#pragma token PROC (\
863 
	EXP lvalue : CLASS_ID :,\
864 
	EXP lvalue : STACK ( CLASS_ID ) :\
865 
    ) STATEMENT POP_cid #
866 
 
867 
#pragma interface SIZE_cid COPY_cid DEREF_cid
868 
#pragma interface CONS_cid UN_CONS_cid DESTROY_CONS_cid
869 
#pragma interface PUSH_cid POP_cid
870 
 
871 
 
872 
/* Definitions for structure PRIMITIVE */
873 
 
874 
#pragma token PROC ( EXP : PTR ( PRIMITIVE ) : ) EXP : PTR ( CLASS_ID_P ) : prim_id #
875 
#pragma interface prim_id
876 
 
877 
#pragma token PROC ( EXP : PTR ( PRIMITIVE ) : ) EXP : PTR ( string ) : prim_defn #
878 
#pragma interface prim_defn
879 
 
880 
#pragma token PROC (\
881 
	EXP : CLASS_ID_P :,\
882 
	EXP : string :,\
883 
	EXP : PTR ( PRIMITIVE ) :\
884 
    ) STATEMENT MAKE_prim #
885 
#pragma interface MAKE_prim
886 
 
887 
#pragma token EXP const : SIZE ( PRIMITIVE ) : SIZE_prim #
888 
 
889 
#pragma token PROC (\
890 
	EXP : PTR ( PRIMITIVE ) :,\
891 
	EXP : PRIMITIVE :\
892 
    ) STATEMENT COPY_prim #
893 
 
894 
#pragma token PROC (\
895 
	EXP : PTR ( PRIMITIVE ) :,\
896 
	EXP lvalue : PRIMITIVE :\
897 
    ) STATEMENT DEREF_prim #
898 
 
899 
#pragma token PROC (\
900 
	EXP : PRIMITIVE :,\
901 
	EXP : LIST ( PRIMITIVE ) :,\
902 
	EXP lvalue : LIST ( PRIMITIVE ) :\
903 
    ) STATEMENT CONS_prim #
904 
 
905 
#pragma token PROC (\
906 
	EXP lvalue : PRIMITIVE :,\
907 
	EXP lvalue : LIST ( PRIMITIVE ) :,\
908 
	EXP : LIST ( PRIMITIVE ) :\
909 
    ) STATEMENT UN_CONS_prim #
910 
 
911 
#pragma token PROC (\
912 
	EXP : DESTROYER :,\
913 
	EXP lvalue : PRIMITIVE :,\
914 
	EXP lvalue : LIST ( PRIMITIVE ) :,\
915 
	EXP : LIST ( PRIMITIVE ) :\
916 
    ) STATEMENT DESTROY_CONS_prim #
917 
 
918 
#pragma token PROC (\
919 
	EXP : PRIMITIVE :,\
920 
	EXP lvalue : STACK ( PRIMITIVE ) :\
921 
    ) STATEMENT PUSH_prim #
922 
 
923 
#pragma token PROC (\
924 
	EXP lvalue : PRIMITIVE :,\
925 
	EXP lvalue : STACK ( PRIMITIVE ) :\
926 
    ) STATEMENT POP_prim #
927 
 
928 
#pragma interface SIZE_prim COPY_prim DEREF_prim
929 
#pragma interface CONS_prim UN_CONS_prim DESTROY_CONS_prim
930 
#pragma interface PUSH_prim POP_prim
931 
 
932 
 
933 
/* Definitions for structure ECONST */
934 
 
935 
#pragma token PROC ( EXP : PTR ( ECONST ) : ) EXP : PTR ( string ) : ec_name #
936 
#pragma interface ec_name
937 
 
938 
#pragma token PROC ( EXP : PTR ( ECONST ) : ) EXP : PTR ( number ) : ec_value #
939 
#pragma interface ec_value
940 
 
941 
#pragma token PROC (\
942 
	EXP : string :,\
943 
	EXP : number :,\
944 
	EXP : PTR ( ECONST ) :\
945 
    ) STATEMENT MAKE_ec #
946 
#pragma interface MAKE_ec
947 
 
948 
#pragma token EXP const : SIZE ( ECONST ) : SIZE_ec #
949 
 
950 
#pragma token PROC (\
951 
	EXP : PTR ( ECONST ) :,\
952 
	EXP : ECONST :\
953 
    ) STATEMENT COPY_ec #
954 
 
955 
#pragma token PROC (\
956 
	EXP : PTR ( ECONST ) :,\
957 
	EXP lvalue : ECONST :\
958 
    ) STATEMENT DEREF_ec #
959 
 
960 
#pragma token PROC (\
961 
	EXP : ECONST :,\
962 
	EXP : LIST ( ECONST ) :,\
963 
	EXP lvalue : LIST ( ECONST ) :\
964 
    ) STATEMENT CONS_ec #
965 
 
966 
#pragma token PROC (\
967 
	EXP lvalue : ECONST :,\
968 
	EXP lvalue : LIST ( ECONST ) :,\
969 
	EXP : LIST ( ECONST ) :\
970 
    ) STATEMENT UN_CONS_ec #
971 
 
972 
#pragma token PROC (\
973 
	EXP : DESTROYER :,\
974 
	EXP lvalue : ECONST :,\
975 
	EXP lvalue : LIST ( ECONST ) :,\
976 
	EXP : LIST ( ECONST ) :\
977 
    ) STATEMENT DESTROY_CONS_ec #
978 
 
979 
#pragma token PROC (\
980 
	EXP : ECONST :,\
981 
	EXP lvalue : STACK ( ECONST ) :\
982 
    ) STATEMENT PUSH_ec #
983 
 
984 
#pragma token PROC (\
985 
	EXP lvalue : ECONST :,\
986 
	EXP lvalue : STACK ( ECONST ) :\
987 
    ) STATEMENT POP_ec #
988 
 
989 
#pragma interface SIZE_ec COPY_ec DEREF_ec
990 
#pragma interface CONS_ec UN_CONS_ec DESTROY_CONS_ec
991 
#pragma interface PUSH_ec POP_ec
992 
 
993 
 
994 
/* Definitions for structure ENUM */
995 
 
996 
#pragma token PROC ( EXP : PTR ( ENUM ) : ) EXP : PTR ( CLASS_ID_P ) : en_id #
997 
#pragma interface en_id
998 
 
999 
#pragma token PROC ( EXP : PTR ( ENUM ) : ) EXP : PTR ( LIST ( ECONST_P ) ) : en_consts #
1000 
#pragma interface en_consts
1001 
 
1002 
#pragma token PROC ( EXP : PTR ( ENUM ) : ) EXP : PTR ( number ) : en_order #
1003 
#pragma interface en_order
1004 
 
1005 
#pragma token PROC ( EXP : PTR ( ENUM ) : ) EXP : PTR ( int ) : en_lists #
1006 
#pragma interface en_lists
1007 
 
1008 
#pragma token PROC (\
1009 
	EXP : CLASS_ID_P :,\
1010 
	EXP : LIST ( ECONST_P ) :,\
1011 
	EXP : number :,\
1012 
	EXP : int :,\
1013 
	EXP : PTR ( ENUM ) :\
1014 
    ) STATEMENT MAKE_en #
1015 
#pragma interface MAKE_en
1016 
 
1017 
#pragma token EXP const : SIZE ( ENUM ) : SIZE_en #
1018 
 
1019 
#pragma token PROC (\
1020 
	EXP : PTR ( ENUM ) :,\
1021 
	EXP : ENUM :\
1022 
    ) STATEMENT COPY_en #
1023 
 
1024 
#pragma token PROC (\
1025 
	EXP : PTR ( ENUM ) :,\
1026 
	EXP lvalue : ENUM :\
1027 
    ) STATEMENT DEREF_en #
1028 
 
1029 
#pragma token PROC (\
1030 
	EXP : ENUM :,\
1031 
	EXP : LIST ( ENUM ) :,\
1032 
	EXP lvalue : LIST ( ENUM ) :\
1033 
    ) STATEMENT CONS_en #
1034 
 
1035 
#pragma token PROC (\
1036 
	EXP lvalue : ENUM :,\
1037 
	EXP lvalue : LIST ( ENUM ) :,\
1038 
	EXP : LIST ( ENUM ) :\
1039 
    ) STATEMENT UN_CONS_en #
1040 
 
1041 
#pragma token PROC (\
1042 
	EXP : DESTROYER :,\
1043 
	EXP lvalue : ENUM :,\
1044 
	EXP lvalue : LIST ( ENUM ) :,\
1045 
	EXP : LIST ( ENUM ) :\
1046 
    ) STATEMENT DESTROY_CONS_en #
1047 
 
1048 
#pragma token PROC (\
1049 
	EXP : ENUM :,\
1050 
	EXP lvalue : STACK ( ENUM ) :\
1051 
    ) STATEMENT PUSH_en #
1052 
 
1053 
#pragma token PROC (\
1054 
	EXP lvalue : ENUM :,\
1055 
	EXP lvalue : STACK ( ENUM ) :\
1056 
    ) STATEMENT POP_en #
1057 
 
1058 
#pragma interface SIZE_en COPY_en DEREF_en
1059 
#pragma interface CONS_en UN_CONS_en DESTROY_CONS_en
1060 
#pragma interface PUSH_en POP_en
1061 
 
1062 
 
1063 
/* Definitions for structure IDENTITY */
1064 
 
1065 
#pragma token PROC ( EXP : PTR ( IDENTITY ) : ) EXP : PTR ( CLASS_ID_P ) : ident_id #
1066 
#pragma interface ident_id
1067 
 
1068 
#pragma token PROC ( EXP : PTR ( IDENTITY ) : ) EXP : PTR ( TYPE_P ) : ident_defn #
1069 
#pragma interface ident_defn
1070 
 
1071 
#pragma token PROC (\
1072 
	EXP : CLASS_ID_P :,\
1073 
	EXP : TYPE_P :,\
1074 
	EXP : PTR ( IDENTITY ) :\
1075 
    ) STATEMENT MAKE_ident #
1076 
#pragma interface MAKE_ident
1077 
 
1078 
#pragma token EXP const : SIZE ( IDENTITY ) : SIZE_ident #
1079 
 
1080 
#pragma token PROC (\
1081 
	EXP : PTR ( IDENTITY ) :,\
1082 
	EXP : IDENTITY :\
1083 
    ) STATEMENT COPY_ident #
1084 
 
1085 
#pragma token PROC (\
1086 
	EXP : PTR ( IDENTITY ) :,\
1087 
	EXP lvalue : IDENTITY :\
1088 
    ) STATEMENT DEREF_ident #
1089 
 
1090 
#pragma token PROC (\
1091 
	EXP : IDENTITY :,\
1092 
	EXP : LIST ( IDENTITY ) :,\
1093 
	EXP lvalue : LIST ( IDENTITY ) :\
1094 
    ) STATEMENT CONS_ident #
1095 
 
1096 
#pragma token PROC (\
1097 
	EXP lvalue : IDENTITY :,\
1098 
	EXP lvalue : LIST ( IDENTITY ) :,\
1099 
	EXP : LIST ( IDENTITY ) :\
1100 
    ) STATEMENT UN_CONS_ident #
1101 
 
1102 
#pragma token PROC (\
1103 
	EXP : DESTROYER :,\
1104 
	EXP lvalue : IDENTITY :,\
1105 
	EXP lvalue : LIST ( IDENTITY ) :,\
1106 
	EXP : LIST ( IDENTITY ) :\
1107 
    ) STATEMENT DESTROY_CONS_ident #
1108 
 
1109 
#pragma token PROC (\
1110 
	EXP : IDENTITY :,\
1111 
	EXP lvalue : STACK ( IDENTITY ) :\
1112 
    ) STATEMENT PUSH_ident #
1113 
 
1114 
#pragma token PROC (\
1115 
	EXP lvalue : IDENTITY :,\
1116 
	EXP lvalue : STACK ( IDENTITY ) :\
1117 
    ) STATEMENT POP_ident #
1118 
 
1119 
#pragma interface SIZE_ident COPY_ident DEREF_ident
1120 
#pragma interface CONS_ident UN_CONS_ident DESTROY_CONS_ident
1121 
#pragma interface PUSH_ident POP_ident
1122 
 
1123 
 
1124 
/* Definitions for structure COMPONENT */
1125 
 
1126 
#pragma token PROC ( EXP : PTR ( COMPONENT ) : ) EXP : PTR ( string ) : cmp_name #
1127 
#pragma interface cmp_name
1128 
 
1129 
#pragma token PROC ( EXP : PTR ( COMPONENT ) : ) EXP : PTR ( TYPE_P ) : cmp_type #
1130 
#pragma interface cmp_type
1131 
 
1132 
#pragma token PROC ( EXP : PTR ( COMPONENT ) : ) EXP : PTR ( string ) : cmp_value #
1133 
#pragma interface cmp_value
1134 
 
1135 
#pragma token PROC (\
1136 
	EXP : string :,\
1137 
	EXP : TYPE_P :,\
1138 
	EXP : string :,\
1139 
	EXP : PTR ( COMPONENT ) :\
1140 
    ) STATEMENT MAKE_cmp #
1141 
#pragma interface MAKE_cmp
1142 
 
1143 
#pragma token EXP const : SIZE ( COMPONENT ) : SIZE_cmp #
1144 
 
1145 
#pragma token PROC (\
1146 
	EXP : PTR ( COMPONENT ) :,\
1147 
	EXP : COMPONENT :\
1148 
    ) STATEMENT COPY_cmp #
1149 
 
1150 
#pragma token PROC (\
1151 
	EXP : PTR ( COMPONENT ) :,\
1152 
	EXP lvalue : COMPONENT :\
1153 
    ) STATEMENT DEREF_cmp #
1154 
 
1155 
#pragma token PROC (\
1156 
	EXP : COMPONENT :,\
1157 
	EXP : LIST ( COMPONENT ) :,\
1158 
	EXP lvalue : LIST ( COMPONENT ) :\
1159 
    ) STATEMENT CONS_cmp #
1160 
 
1161 
#pragma token PROC (\
1162 
	EXP lvalue : COMPONENT :,\
1163 
	EXP lvalue : LIST ( COMPONENT ) :,\
1164 
	EXP : LIST ( COMPONENT ) :\
1165 
    ) STATEMENT UN_CONS_cmp #
1166 
 
1167 
#pragma token PROC (\
1168 
	EXP : DESTROYER :,\
1169 
	EXP lvalue : COMPONENT :,\
1170 
	EXP lvalue : LIST ( COMPONENT ) :,\
1171 
	EXP : LIST ( COMPONENT ) :\
1172 
    ) STATEMENT DESTROY_CONS_cmp #
1173 
 
1174 
#pragma token PROC (\
1175 
	EXP : COMPONENT :,\
1176 
	EXP lvalue : STACK ( COMPONENT ) :\
1177 
    ) STATEMENT PUSH_cmp #
1178 
 
1179 
#pragma token PROC (\
1180 
	EXP lvalue : COMPONENT :,\
1181 
	EXP lvalue : STACK ( COMPONENT ) :\
1182 
    ) STATEMENT POP_cmp #
1183 
 
1184 
#pragma interface SIZE_cmp COPY_cmp DEREF_cmp
1185 
#pragma interface CONS_cmp UN_CONS_cmp DESTROY_CONS_cmp
1186 
#pragma interface PUSH_cmp POP_cmp
1187 
 
1188 
 
1189 
/* Definitions for structure STRUCTURE */
1190 
 
1191 
#pragma token PROC ( EXP : PTR ( STRUCTURE ) : ) EXP : PTR ( CLASS_ID_P ) : str_id #
1192 
#pragma interface str_id
1193 
 
1194 
#pragma token PROC ( EXP : PTR ( STRUCTURE ) : ) EXP : PTR ( STRUCTURE_P ) : str_base #
1195 
#pragma interface str_base
1196 
 
1197 
#pragma token PROC ( EXP : PTR ( STRUCTURE ) : ) EXP : PTR ( LIST ( COMPONENT_P ) ) : str_defn #
1198 
#pragma interface str_defn
1199 
 
1200 
#pragma token PROC ( EXP : PTR ( STRUCTURE ) : ) EXP : PTR ( zero_int ) : str_output #
1201 
#pragma interface str_output
1202 
 
1203 
#pragma token PROC (\
1204 
	EXP : CLASS_ID_P :,\
1205 
	EXP : STRUCTURE_P :,\
1206 
	EXP : LIST ( COMPONENT_P ) :,\
1207 
	EXP : zero_int :,\
1208 
	EXP : PTR ( STRUCTURE ) :\
1209 
    ) STATEMENT MAKE_str #
1210 
#pragma interface MAKE_str
1211 
 
1212 
#pragma token EXP const : SIZE ( STRUCTURE ) : SIZE_str #
1213 
 
1214 
#pragma token PROC (\
1215 
	EXP : PTR ( STRUCTURE ) :,\
1216 
	EXP : STRUCTURE :\
1217 
    ) STATEMENT COPY_str #
1218 
 
1219 
#pragma token PROC (\
1220 
	EXP : PTR ( STRUCTURE ) :,\
1221 
	EXP lvalue : STRUCTURE :\
1222 
    ) STATEMENT DEREF_str #
1223 
 
1224 
#pragma token PROC (\
1225 
	EXP : STRUCTURE :,\
1226 
	EXP : LIST ( STRUCTURE ) :,\
1227 
	EXP lvalue : LIST ( STRUCTURE ) :\
1228 
    ) STATEMENT CONS_str #
1229 
 
1230 
#pragma token PROC (\
1231 
	EXP lvalue : STRUCTURE :,\
1232 
	EXP lvalue : LIST ( STRUCTURE ) :,\
1233 
	EXP : LIST ( STRUCTURE ) :\
1234 
    ) STATEMENT UN_CONS_str #
1235 
 
1236 
#pragma token PROC (\
1237 
	EXP : DESTROYER :,\
1238 
	EXP lvalue : STRUCTURE :,\
1239 
	EXP lvalue : LIST ( STRUCTURE ) :,\
1240 
	EXP : LIST ( STRUCTURE ) :\
1241 
    ) STATEMENT DESTROY_CONS_str #
1242 
 
1243 
#pragma token PROC (\
1244 
	EXP : STRUCTURE :,\
1245 
	EXP lvalue : STACK ( STRUCTURE ) :\
1246 
    ) STATEMENT PUSH_str #
1247 
 
1248 
#pragma token PROC (\
1249 
	EXP lvalue : STRUCTURE :,\
1250 
	EXP lvalue : STACK ( STRUCTURE ) :\
1251 
    ) STATEMENT POP_str #
1252 
 
1253 
#pragma interface SIZE_str COPY_str DEREF_str
1254 
#pragma interface CONS_str UN_CONS_str DESTROY_CONS_str
1255 
#pragma interface PUSH_str POP_str
1256 
 
1257 
 
1258 
/* Definitions for structure FIELD */
1259 
 
1260 
#pragma token PROC ( EXP : PTR ( FIELD ) : ) EXP : PTR ( string ) : fld_name #
1261 
#pragma interface fld_name
1262 
 
1263 
#pragma token PROC ( EXP : PTR ( FIELD ) : ) EXP : PTR ( int ) : fld_tag #
1264 
#pragma interface fld_tag
1265 
 
1266 
#pragma token PROC ( EXP : PTR ( FIELD ) : ) EXP : PTR ( int ) : fld_flag #
1267 
#pragma interface fld_flag
1268 
 
1269 
#pragma token PROC ( EXP : PTR ( FIELD ) : ) EXP : PTR ( int ) : fld_set #
1270 
#pragma interface fld_set
1271 
 
1272 
#pragma token PROC ( EXP : PTR ( FIELD ) : ) EXP : PTR ( FIELD_P ) : fld_base #
1273 
#pragma interface fld_base
1274 
 
1275 
#pragma token PROC ( EXP : PTR ( FIELD ) : ) EXP : PTR ( LIST ( COMPONENT_P ) ) : fld_defn #
1276 
#pragma interface fld_defn
1277 
 
1278 
#pragma token PROC (\
1279 
	EXP : string :,\
1280 
	EXP : int :,\
1281 
	EXP : int :,\
1282 
	EXP : int :,\
1283 
	EXP : FIELD_P :,\
1284 
	EXP : LIST ( COMPONENT_P ) :,\
1285 
	EXP : PTR ( FIELD ) :\
1286 
    ) STATEMENT MAKE_fld #
1287 
#pragma interface MAKE_fld
1288 
 
1289 
#pragma token EXP const : SIZE ( FIELD ) : SIZE_fld #
1290 
 
1291 
#pragma token PROC (\
1292 
	EXP : PTR ( FIELD ) :,\
1293 
	EXP : FIELD :\
1294 
    ) STATEMENT COPY_fld #
1295 
 
1296 
#pragma token PROC (\
1297 
	EXP : PTR ( FIELD ) :,\
1298 
	EXP lvalue : FIELD :\
1299 
    ) STATEMENT DEREF_fld #
1300 
 
1301 
#pragma token PROC (\
1302 
	EXP : FIELD :,\
1303 
	EXP : LIST ( FIELD ) :,\
1304 
	EXP lvalue : LIST ( FIELD ) :\
1305 
    ) STATEMENT CONS_fld #
1306 
 
1307 
#pragma token PROC (\
1308 
	EXP lvalue : FIELD :,\
1309 
	EXP lvalue : LIST ( FIELD ) :,\
1310 
	EXP : LIST ( FIELD ) :\
1311 
    ) STATEMENT UN_CONS_fld #
1312 
 
1313 
#pragma token PROC (\
1314 
	EXP : DESTROYER :,\
1315 
	EXP lvalue : FIELD :,\
1316 
	EXP lvalue : LIST ( FIELD ) :,\
1317 
	EXP : LIST ( FIELD ) :\
1318 
    ) STATEMENT DESTROY_CONS_fld #
1319 
 
1320 
#pragma token PROC (\
1321 
	EXP : FIELD :,\
1322 
	EXP lvalue : STACK ( FIELD ) :\
1323 
    ) STATEMENT PUSH_fld #
1324 
 
1325 
#pragma token PROC (\
1326 
	EXP lvalue : FIELD :,\
1327 
	EXP lvalue : STACK ( FIELD ) :\
1328 
    ) STATEMENT POP_fld #
1329 
 
1330 
#pragma interface SIZE_fld COPY_fld DEREF_fld
1331 
#pragma interface CONS_fld UN_CONS_fld DESTROY_CONS_fld
1332 
#pragma interface PUSH_fld POP_fld
1333 
 
1334 
 
1335 
/* Definitions for structure ARGUMENT */
1336 
 
1337 
#pragma token PROC ( EXP : PTR ( ARGUMENT ) : ) EXP : PTR ( string ) : arg_name #
1338 
#pragma interface arg_name
1339 
 
1340 
#pragma token PROC ( EXP : PTR ( ARGUMENT ) : ) EXP : PTR ( TYPE_P ) : arg_type #
1341 
#pragma interface arg_type
1342 
 
1343 
#pragma token PROC (\
1344 
	EXP : string :,\
1345 
	EXP : TYPE_P :,\
1346 
	EXP : PTR ( ARGUMENT ) :\
1347 
    ) STATEMENT MAKE_arg #
1348 
#pragma interface MAKE_arg
1349 
 
1350 
#pragma token EXP const : SIZE ( ARGUMENT ) : SIZE_arg #
1351 
 
1352 
#pragma token PROC (\
1353 
	EXP : PTR ( ARGUMENT ) :,\
1354 
	EXP : ARGUMENT :\
1355 
    ) STATEMENT COPY_arg #
1356 
 
1357 
#pragma token PROC (\
1358 
	EXP : PTR ( ARGUMENT ) :,\
1359 
	EXP lvalue : ARGUMENT :\
1360 
    ) STATEMENT DEREF_arg #
1361 
 
1362 
#pragma token PROC (\
1363 
	EXP : ARGUMENT :,\
1364 
	EXP : LIST ( ARGUMENT ) :,\
1365 
	EXP lvalue : LIST ( ARGUMENT ) :\
1366 
    ) STATEMENT CONS_arg #
1367 
 
1368 
#pragma token PROC (\
1369 
	EXP lvalue : ARGUMENT :,\
1370 
	EXP lvalue : LIST ( ARGUMENT ) :,\
1371 
	EXP : LIST ( ARGUMENT ) :\
1372 
    ) STATEMENT UN_CONS_arg #
1373 
 
1374 
#pragma token PROC (\
1375 
	EXP : DESTROYER :,\
1376 
	EXP lvalue : ARGUMENT :,\
1377 
	EXP lvalue : LIST ( ARGUMENT ) :,\
1378 
	EXP : LIST ( ARGUMENT ) :\
1379 
    ) STATEMENT DESTROY_CONS_arg #
1380 
 
1381 
#pragma token PROC (\
1382 
	EXP : ARGUMENT :,\
1383 
	EXP lvalue : STACK ( ARGUMENT ) :\
1384 
    ) STATEMENT PUSH_arg #
1385 
 
1386 
#pragma token PROC (\
1387 
	EXP lvalue : ARGUMENT :,\
1388 
	EXP lvalue : STACK ( ARGUMENT ) :\
1389 
    ) STATEMENT POP_arg #
1390 
 
1391 
#pragma interface SIZE_arg COPY_arg DEREF_arg
1392 
#pragma interface CONS_arg UN_CONS_arg DESTROY_CONS_arg
1393 
#pragma interface PUSH_arg POP_arg
1394 
 
1395 
 
1396 
/* Definitions for structure MAP */
1397 
 
1398 
#pragma token PROC ( EXP : PTR ( MAP ) : ) EXP : PTR ( string ) : map_name #
1399 
#pragma interface map_name
1400 
 
1401 
#pragma token PROC ( EXP : PTR ( MAP ) : ) EXP : PTR ( int ) : map_flag #
1402 
#pragma interface map_flag
1403 
 
1404 
#pragma token PROC ( EXP : PTR ( MAP ) : ) EXP : PTR ( TYPE_P ) : map_ret_type #
1405 
#pragma interface map_ret_type
1406 
 
1407 
#pragma token PROC ( EXP : PTR ( MAP ) : ) EXP : PTR ( LIST ( ARGUMENT_P ) ) : map_args #
1408 
#pragma interface map_args
1409 
 
1410 
#pragma token PROC (\
1411 
	EXP : string :,\
1412 
	EXP : int :,\
1413 
	EXP : TYPE_P :,\
1414 
	EXP : LIST ( ARGUMENT_P ) :,\
1415 
	EXP : PTR ( MAP ) :\
1416 
    ) STATEMENT MAKE_map #
1417 
#pragma interface MAKE_map
1418 
 
1419 
#pragma token EXP const : SIZE ( MAP ) : SIZE_map #
1420 
 
1421 
#pragma token PROC (\
1422 
	EXP : PTR ( MAP ) :,\
1423 
	EXP : MAP :\
1424 
    ) STATEMENT COPY_map #
1425 
 
1426 
#pragma token PROC (\
1427 
	EXP : PTR ( MAP ) :,\
1428 
	EXP lvalue : MAP :\
1429 
    ) STATEMENT DEREF_map #
1430 
 
1431 
#pragma token PROC (\
1432 
	EXP : MAP :,\
1433 
	EXP : LIST ( MAP ) :,\
1434 
	EXP lvalue : LIST ( MAP ) :\
1435 
    ) STATEMENT CONS_map #
1436 
 
1437 
#pragma token PROC (\
1438 
	EXP lvalue : MAP :,\
1439 
	EXP lvalue : LIST ( MAP ) :,\
1440 
	EXP : LIST ( MAP ) :\
1441 
    ) STATEMENT UN_CONS_map #
1442 
 
1443 
#pragma token PROC (\
1444 
	EXP : DESTROYER :,\
1445 
	EXP lvalue : MAP :,\
1446 
	EXP lvalue : LIST ( MAP ) :,\
1447 
	EXP : LIST ( MAP ) :\
1448 
    ) STATEMENT DESTROY_CONS_map #
1449 
 
1450 
#pragma token PROC (\
1451 
	EXP : MAP :,\
1452 
	EXP lvalue : STACK ( MAP ) :\
1453 
    ) STATEMENT PUSH_map #
1454 
 
1455 
#pragma token PROC (\
1456 
	EXP lvalue : MAP :,\
1457 
	EXP lvalue : STACK ( MAP ) :\
1458 
    ) STATEMENT POP_map #
1459 
 
1460 
#pragma interface SIZE_map COPY_map DEREF_map
1461 
#pragma interface CONS_map UN_CONS_map DESTROY_CONS_map
1462 
#pragma interface PUSH_map POP_map
1463 
 
1464 
 
1465 
/* Definitions for structure UNION */
1466 
 
1467 
#pragma token PROC ( EXP : PTR ( UNION ) : ) EXP : PTR ( CLASS_ID_P ) : un_id #
1468 
#pragma interface un_id
1469 
 
1470 
#pragma token PROC ( EXP : PTR ( UNION ) : ) EXP : PTR ( UNION_P ) : un_base #
1471 
#pragma interface un_base
1472 
 
1473 
#pragma token PROC ( EXP : PTR ( UNION ) : ) EXP : PTR ( LIST ( COMPONENT_P ) ) : un_s_defn #
1474 
#pragma interface un_s_defn
1475 
 
1476 
#pragma token PROC ( EXP : PTR ( UNION ) : ) EXP : PTR ( LIST ( FIELD_P ) ) : un_u_defn #
1477 
#pragma interface un_u_defn
1478 
 
1479 
#pragma token PROC ( EXP : PTR ( UNION ) : ) EXP : PTR ( LIST ( MAP_P ) ) : un_map #
1480 
#pragma interface un_map
1481 
 
1482 
#pragma token PROC ( EXP : PTR ( UNION ) : ) EXP : PTR ( int ) : un_no_fields #
1483 
#pragma interface un_no_fields
1484 
 
1485 
#pragma token PROC (\
1486 
	EXP : CLASS_ID_P :,\
1487 
	EXP : UNION_P :,\
1488 
	EXP : LIST ( COMPONENT_P ) :,\
1489 
	EXP : LIST ( FIELD_P ) :,\
1490 
	EXP : LIST ( MAP_P ) :,\
1491 
	EXP : int :,\
1492 
	EXP : PTR ( UNION ) :\
1493 
    ) STATEMENT MAKE_un #
1494 
#pragma interface MAKE_un
1495 
 
1496 
#pragma token EXP const : SIZE ( UNION ) : SIZE_un #
1497 
 
1498 
#pragma token PROC (\
1499 
	EXP : PTR ( UNION ) :,\
1500 
	EXP : UNION :\
1501 
    ) STATEMENT COPY_un #
1502 
 
1503 
#pragma token PROC (\
1504 
	EXP : PTR ( UNION ) :,\
1505 
	EXP lvalue : UNION :\
1506 
    ) STATEMENT DEREF_un #
1507 
 
1508 
#pragma token PROC (\
1509 
	EXP : UNION :,\
1510 
	EXP : LIST ( UNION ) :,\
1511 
	EXP lvalue : LIST ( UNION ) :\
1512 
    ) STATEMENT CONS_un #
1513 
 
1514 
#pragma token PROC (\
1515 
	EXP lvalue : UNION :,\
1516 
	EXP lvalue : LIST ( UNION ) :,\
1517 
	EXP : LIST ( UNION ) :\
1518 
    ) STATEMENT UN_CONS_un #
1519 
 
1520 
#pragma token PROC (\
1521 
	EXP : DESTROYER :,\
1522 
	EXP lvalue : UNION :,\
1523 
	EXP lvalue : LIST ( UNION ) :,\
1524 
	EXP : LIST ( UNION ) :\
1525 
    ) STATEMENT DESTROY_CONS_un #
1526 
 
1527 
#pragma token PROC (\
1528 
	EXP : UNION :,\
1529 
	EXP lvalue : STACK ( UNION ) :\
1530 
    ) STATEMENT PUSH_un #
1531 
 
1532 
#pragma token PROC (\
1533 
	EXP lvalue : UNION :,\
1534 
	EXP lvalue : STACK ( UNION ) :\
1535 
    ) STATEMENT POP_un #
1536 
 
1537 
#pragma interface SIZE_un COPY_un DEREF_un
1538 
#pragma interface CONS_un UN_CONS_un DESTROY_CONS_un
1539 
#pragma interface PUSH_un POP_un
1540 
 
1541 
 
1542 
/* Definitions for union TYPE */
1543 
 
1544 
#define ORDER_type ( ( unsigned ) 12 )
1545 
#pragma token EXP const : TYPE : NULL_type #
1546 
#pragma token PROC ( EXP : TYPE : ) EXP : int : IS_NULL_type #
1547 
#pragma token PROC ( EXP : TYPE :, EXP : TYPE : ) EXP : int : EQ_type #
1548 
#pragma interface NULL_type IS_NULL_type EQ_type
1549 
 
1550 
#pragma token EXP const : SIZE ( TYPE ) : SIZE_type #
1551 
 
1552 
#pragma token PROC (\
1553 
	EXP : PTR ( TYPE ) :,\
1554 
	EXP : TYPE :\
1555 
    ) EXP : void : COPY_type #
1556 
 
1557 
#pragma token PROC (\
1558 
	EXP : PTR ( TYPE ) :\
1559 
    ) EXP : TYPE : DEREF_type #
1560 
 
1561 
#pragma token PROC (\
1562 
	EXP : TYPE :,\
1563 
	EXP : LIST ( TYPE ) :,\
1564 
	EXP lvalue : LIST ( TYPE ) :\
1565 
    ) STATEMENT CONS_type #
1566 
 
1567 
#pragma token PROC (\
1568 
	EXP lvalue : TYPE :,\
1569 
	EXP lvalue : LIST ( TYPE ) :,\
1570 
	EXP : LIST ( TYPE ) :\
1571 
    ) STATEMENT UN_CONS_type #
1572 
 
1573 
#pragma token PROC (\
1574 
	EXP : DESTROYER :,\
1575 
	EXP lvalue : TYPE :,\
1576 
	EXP lvalue : LIST ( TYPE ) :,\
1577 
	EXP : LIST ( TYPE ) :\
1578 
    ) STATEMENT DESTROY_CONS_type #
1579 
 
1580 
#pragma token PROC (\
1581 
	EXP : TYPE :,\
1582 
	EXP lvalue : STACK ( TYPE ) :\
1583 
    ) STATEMENT PUSH_type #
1584 
 
1585 
#pragma token PROC (\
1586 
	EXP lvalue : TYPE :,\
1587 
	EXP lvalue : STACK ( TYPE ) :\
1588 
    ) STATEMENT POP_type #
1589 
 
1590 
#pragma interface SIZE_type COPY_type DEREF_type
1591 
#pragma interface CONS_type UN_CONS_type DESTROY_CONS_type
1592 
#pragma interface PUSH_type POP_type
1593 
 
1594 
 
1595 
/* Definitions for union COMMAND */
1596 
 
1597 
#define ORDER_cmd ( ( unsigned ) 4 )
1598 
#pragma token EXP const : COMMAND : NULL_cmd #
1599 
#pragma token PROC ( EXP : COMMAND : ) EXP : int : IS_NULL_cmd #
1600 
#pragma token PROC ( EXP : COMMAND :, EXP : COMMAND : ) EXP : int : EQ_cmd #
1601 
#pragma interface NULL_cmd IS_NULL_cmd EQ_cmd
1602 
 
1603 
#pragma token EXP const : SIZE ( COMMAND ) : SIZE_cmd #
1604 
 
1605 
#pragma token PROC (\
1606 
	EXP : PTR ( COMMAND ) :,\
1607 
	EXP : COMMAND :\
1608 
    ) EXP : void : COPY_cmd #
1609 
 
1610 
#pragma token PROC (\
1611 
	EXP : PTR ( COMMAND ) :\
1612 
    ) EXP : COMMAND : DEREF_cmd #
1613 
 
1614 
#pragma token PROC (\
1615 
	EXP : COMMAND :,\
1616 
	EXP : LIST ( COMMAND ) :,\
1617 
	EXP lvalue : LIST ( COMMAND ) :\
1618 
    ) STATEMENT CONS_cmd #
1619 
 
1620 
#pragma token PROC (\
1621 
	EXP lvalue : COMMAND :,\
1622 
	EXP lvalue : LIST ( COMMAND ) :,\
1623 
	EXP : LIST ( COMMAND ) :\
1624 
    ) STATEMENT UN_CONS_cmd #
1625 
 
1626 
#pragma token PROC (\
1627 
	EXP : DESTROYER :,\
1628 
	EXP lvalue : COMMAND :,\
1629 
	EXP lvalue : LIST ( COMMAND ) :,\
1630 
	EXP : LIST ( COMMAND ) :\
1631 
    ) STATEMENT DESTROY_CONS_cmd #
1632 
 
1633 
#pragma token PROC (\
1634 
	EXP : COMMAND :,\
1635 
	EXP lvalue : STACK ( COMMAND ) :\
1636 
    ) STATEMENT PUSH_cmd #
1637 
 
1638 
#pragma token PROC (\
1639 
	EXP lvalue : COMMAND :,\
1640 
	EXP lvalue : STACK ( COMMAND ) :\
1641 
    ) STATEMENT POP_cmd #
1642 
 
1643 
#pragma interface SIZE_cmd COPY_cmd DEREF_cmd
1644 
#pragma interface CONS_cmd UN_CONS_cmd DESTROY_CONS_cmd
1645 
#pragma interface PUSH_cmd POP_cmd
1646 
 
1647 
 
1648 
#endif