Subversion Repositories tendra.SVN

Rev

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

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