Subversion Repositories tendra.SVN

Rev

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

Rev 2 Rev 7
Line 42... Line 42...
42 
#define tdf_IMPLEMENTATION		0
 42 
#define tdf_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 char * string ;
 55 
typedef char * string;
72 
 
 56 
 
73 
 
 57 
 
74 
/* Basic types */
 58 
/* Basic types */
75 
 
 59 
 
76 
#ifndef tdf_DESTR_DEFINED
 60 
#ifndef tdf_DESTR_DEFINED
77 
#define tdf_DESTR_DEFINED
 61 
#define tdf_DESTR_DEFINED
78 
typedef void ( *DESTROYER ) () ;
 62 
typedef void (*DESTROYER)();
79 
#endif
 63 
#endif
80 
 
 64 
 
81 
#pragma token PROC ( TYPE ) TYPE PTR #
 65 
#pragma token PROC(TYPE) TYPE PTR #
82 
#pragma token PROC ( TYPE ) TYPE LIST #
 66 
#pragma token PROC(TYPE) TYPE LIST #
83 
#pragma token PROC ( TYPE ) TYPE STACK #
 67 
#pragma token PROC(TYPE) TYPE STACK #
84 
#pragma token PROC ( TYPE ) TYPE SIZE #
 68 
#pragma token PROC(TYPE) TYPE SIZE #
85 
 
 69 
 
86 
#pragma interface PTR LIST STACK SIZE
 70 
#pragma interface PTR LIST STACK SIZE
87 
 
 71 
 
88 
 
 72 
 
89 
/* Enumeration type definitions */
 73 
/* Enumeration type definitions */
Line 124... Line 108...
124 
#endif /* tdf_STRUCT_DEFINED */
 108 
#endif /* tdf_STRUCT_DEFINED */
125 
 
 109 
 
126 
 
 110 
 
127 
/* Function declarations */
 111 
/* Function declarations */
128 
 
 112 
 
129 
extern void destroy_tdf () ;
 113 
extern void destroy_tdf();
130 
extern void dummy_destroy_tdf () ;
 114 
extern void dummy_destroy_tdf();
131 
#ifdef tdf_IO_ROUTINES
 115 
#ifdef tdf_IO_ROUTINES
132 
extern unsigned crt_tdf_alias ;
 116 
extern unsigned crt_tdf_alias;
133 
extern void clear_tdf_alias PROTO_S ( ( void ) ) ;
 117 
extern void clear_tdf_alias(void);
134 
#endif
 118 
#endif
135 
 
 119 
 
136 
 
 120 
 
137 
/* Pointer token specifications */
 121 
/* Pointer token specifications */
138 
 
 122 
 
139 
#pragma token PROC {\
 123 
#pragma token PROC {\
140 
	TYPE t, EXP : PTR ( t ) : e1, EXP : SIZE ( t ) : e2 |\
 124 
	TYPE t, EXP : PTR(t) : e1, EXP : SIZE(t) : e2 |\
141 
	EXP e1, EXP e2\
 125 
	EXP e1, EXP e2\
142 
    } EXP : PTR ( t ) : STEP_ptr #
 126 
    } EXP : PTR(t) : STEP_ptr #
143 
 
 127 
 
144 
#pragma token PROC (\
 128 
#pragma token PROC(\
145 
	TYPE t\
 129 
	TYPE t\
146 
    ) EXP const : PTR ( t ) : NULL_ptr #
 130 
    ) EXP const : PTR(t) : NULL_ptr #
147 
 
 131 
 
148 
#pragma token PROC {\
 132 
#pragma token PROC {\
149 
	TYPE t, EXP : PTR ( t ) : e |\
 133 
	TYPE t, EXP : PTR(t) : e |\
150 
	EXP e\
 134 
	EXP e\
151 
    } EXP : int : IS_NULL_ptr #
 135 
    } EXP : int : IS_NULL_ptr #
152 
 
 136 
 
153 
#pragma token PROC {\
 137 
#pragma token PROC {\
154 
	TYPE t, EXP : PTR ( t ) : e1, EXP : PTR ( t ) : e2 |\
 138 
	TYPE t, EXP : PTR(t) : e1, EXP : PTR(t) : e2 |\
155 
	EXP e1, EXP e2\
 139 
	EXP e1, EXP e2\
156 
    } EXP : int : EQ_ptr #
 140 
    } EXP : int : EQ_ptr #
157 
 
 141 
 
158 
#pragma token PROC {\
 142 
#pragma token PROC {\
159 
	TYPE t, EXP : SIZE ( t ) : e |\
 143 
	TYPE t, EXP : SIZE(t) : e |\
160 
	EXP e\
 144 
	EXP e\
161 
    } EXP : PTR ( t ) : MAKE_ptr #
 145 
    } EXP : PTR(t) : MAKE_ptr #
162 
 
 146 
 
163 
#pragma token PROC {\
 147 
#pragma token PROC {\
164 
	TYPE t, EXP : PTR ( t ) : e1, EXP : SIZE ( t ) : e2 |\
 148 
	TYPE t, EXP : PTR(t) : e1, EXP : SIZE(t) : e2 |\
165 
	EXP e1, EXP e2\
 149 
	EXP e1, EXP e2\
166 
    } EXP : void : DESTROY_ptr #
 150 
    } EXP : void : DESTROY_ptr #
167 
 
 151 
 
168 
#pragma token PROC (\
 152 
#pragma token PROC(\
169 
	TYPE t\
 153 
	TYPE t\
170 
    ) EXP : PTR ( t ) : UNIQ_ptr #
 154 
    ) EXP : PTR(t) : UNIQ_ptr #
171 
 
 155 
 
172 
#pragma token PROC {\
 156 
#pragma token PROC {\
173 
	TYPE t, EXP : PTR ( t ) : e |\
 157 
	TYPE t, EXP : PTR(t) : e |\
174 
	EXP e\
 158 
	EXP e\
175 
    } EXP : void : DESTROY_UNIQ_ptr #
 159 
    } EXP : void : DESTROY_UNIQ_ptr #
176 
 
 160 
 
177 
#pragma interface STEP_ptr NULL_ptr IS_NULL_ptr EQ_ptr
 161 
#pragma interface STEP_ptr NULL_ptr IS_NULL_ptr EQ_ptr
178 
#pragma interface MAKE_ptr DESTROY_ptr
 162 
#pragma interface MAKE_ptr DESTROY_ptr
179 
 
 163 
 
180 
#ifdef tdf_IO_ROUTINES
 164 
#ifdef tdf_IO_ROUTINES
181 
#pragma token PROC {\
 165 
#pragma token PROC {\
182 
	TYPE t, EXP : PTR ( t ) : e |\
 166 
	TYPE t, EXP : PTR(t) : e |\
183 
	EXP e\
 167 
	EXP e\
184 
    } EXP : void * : VOIDSTAR_ptr #
 168 
    } EXP : void * : VOIDSTAR_ptr #
185 
#pragma interface VOIDSTAR_ptr
 169 
#pragma interface VOIDSTAR_ptr
186 
#endif
 170 
#endif
187 
 
 171 
 
188 
#pragma token PROC (\
 172 
#pragma token PROC(\
189 
	TYPE t\
 173 
	TYPE t\
190 
    ) EXP const : SIZE ( PTR ( t ) ) : SIZE_ptr #
 174 
    ) EXP const : SIZE(PTR(t)) : SIZE_ptr #
191 
 
 175 
 
192 
#pragma token PROC {\
 176 
#pragma token PROC {\
193 
	TYPE t, EXP : PTR ( PTR ( t ) ) : e1,\
 177 
	TYPE t, EXP : PTR(PTR(t)) : e1,\
194 
	EXP : PTR ( t ) : e2 |\
 178 
	EXP : PTR(t) : e2 |\
195 
	EXP e1, EXP e2\
 179 
	EXP e1, EXP e2\
196 
    } EXP : void : COPY_ptr #
 180 
    } EXP : void : COPY_ptr #
197 
 
 181 
 
198 
#pragma token PROC {\
 182 
#pragma token PROC {\
199 
	TYPE t, EXP : PTR ( PTR ( t ) ) : e |\
 183 
	TYPE t, EXP : PTR(PTR(t)) : e |\
200 
	EXP e\
 184 
	EXP e\
201 
    } EXP : PTR ( t ) : DEREF_ptr #
 185 
    } EXP : PTR(t) : DEREF_ptr #
202 
 
 186 
 
203 
#pragma token PROC {\
 187 
#pragma token PROC {\
204 
	TYPE t, EXP : PTR ( t ) : e2,\
 188 
	TYPE t, EXP : PTR(t) : e2,\
205 
	EXP : LIST ( PTR ( t ) ) : e3,\
 189 
	EXP : LIST(PTR(t)) : e3,\
206 
	EXP lvalue : LIST ( PTR ( t ) ) : e4 |\
 190 
	EXP lvalue : LIST(PTR(t)) : e4 |\
207 
	EXP e2, EXP e3, EXP e4\
 191 
	EXP e2, EXP e3, EXP e4\
208 
    } STATEMENT CONS_ptr #
 192 
    } STATEMENT CONS_ptr #
209 
 
 193 
 
210 
#pragma token PROC {\
 194 
#pragma token PROC {\
211 
	TYPE t, EXP lvalue : PTR ( t ) : e2,\
 195 
	TYPE t, EXP lvalue : PTR(t) : e2,\
212 
	EXP lvalue : LIST ( PTR ( t ) ) : e3,\
 196 
	EXP lvalue : LIST(PTR(t)) : e3,\
213 
	EXP : LIST ( PTR ( t ) ) : e4 |\
 197 
	EXP : LIST(PTR(t)) : e4 |\
214 
	EXP e2, EXP e3, EXP e4\
 198 
	EXP e2, EXP e3, EXP e4\
215 
    } STATEMENT UN_CONS_ptr #
 199 
    } STATEMENT UN_CONS_ptr #
216 
 
 200 
 
217 
#pragma token PROC {\
 201 
#pragma token PROC {\
218 
	TYPE t, EXP : DESTROYER : e1,\
 202 
	TYPE t, EXP : DESTROYER : e1,\
219 
	EXP lvalue : PTR ( t ) : e2,\
 203 
	EXP lvalue : PTR(t) : e2,\
220 
	EXP lvalue : LIST ( PTR ( t ) ) : e3,\
 204 
	EXP lvalue : LIST(PTR(t)) : e3,\
221 
	EXP : LIST ( PTR ( t ) ) : e4 |\
 205 
	EXP : LIST(PTR(t)) : e4 |\
222 
	EXP e1, EXP e2, EXP e3, EXP e4\
 206 
	EXP e1, EXP e2, EXP e3, EXP e4\
223 
    } STATEMENT DESTROY_CONS_ptr #
 207 
    } STATEMENT DESTROY_CONS_ptr #
224 
 
 208 
 
225 
#pragma token PROC {\
 209 
#pragma token PROC {\
226 
	TYPE t, EXP : PTR ( t ) : e2,\
 210 
	TYPE t, EXP : PTR(t) : e2,\
227 
	EXP lvalue : STACK ( PTR ( t ) ) : e3 |\
 211 
	EXP lvalue : STACK(PTR(t)) : e3 |\
228 
	EXP e2, EXP e3\
 212 
	EXP e2, EXP e3\
229 
    } STATEMENT PUSH_ptr #
 213 
    } STATEMENT PUSH_ptr #
230 
 
 214 
 
231 
#pragma token PROC {\
 215 
#pragma token PROC {\
232 
	TYPE t, EXP lvalue : PTR ( t ) : e2,\
 216 
	TYPE t, EXP lvalue : PTR(t) : e2,\
233 
	EXP lvalue : STACK ( PTR ( t ) ) : e3 |\
 217 
	EXP lvalue : STACK(PTR(t)) : e3 |\
234 
	EXP e2, EXP e3\
 218 
	EXP e2, EXP e3\
235 
    } STATEMENT POP_ptr #
 219 
    } STATEMENT POP_ptr #
236 
 
 220 
 
237 
#pragma interface SIZE_ptr COPY_ptr DEREF_ptr
 221 
#pragma interface SIZE_ptr COPY_ptr DEREF_ptr
238 
#pragma interface CONS_ptr UN_CONS_ptr DESTROY_CONS_ptr
 222 
#pragma interface CONS_ptr UN_CONS_ptr DESTROY_CONS_ptr
Line 240... Line 224...
240 
 
 224 
 
241 
 
 225 
 
242 
/* List token specifications */
 226 
/* List token specifications */
243 
 
 227 
 
244 
#pragma token PROC {\
 228 
#pragma token PROC {\
245 
	TYPE t, EXP : LIST ( t ) : e |\
 229 
	TYPE t, EXP : LIST(t) : e |\
246 
	EXP e\
 230 
	EXP e\
247 
    } EXP : PTR ( t ) : HEAD_list #
 231 
    } EXP : PTR(t) : HEAD_list #
248 
 
 232 
 
249 
#pragma token PROC {\
 233 
#pragma token PROC {\
250 
	TYPE t, EXP : LIST ( t ) : e |\
 234 
	TYPE t, EXP : LIST(t) : e |\
251 
	EXP e\
 235 
	EXP e\
252 
    } EXP : PTR ( LIST ( t ) ) : PTR_TAIL_list #
 236 
    } EXP : PTR(LIST(t)) : PTR_TAIL_list #
253 
 
 237 
 
254 
#pragma token PROC {\
 238 
#pragma token PROC {\
255 
	TYPE t, EXP : LIST ( t ) : e |\
 239 
	TYPE t, EXP : LIST(t) : e |\
256 
	EXP e\
 240 
	EXP e\
257 
    } EXP : LIST ( t ) : TAIL_list #
 241 
    } EXP : LIST(t) : TAIL_list #
258 
 
 242 
 
259 
#pragma token PROC {\
 243 
#pragma token PROC {\
260 
	TYPE t, EXP : LIST ( t ) : e1 |\
 244 
	TYPE t, EXP : LIST(t) : e1 |\
261 
	EXP e1\
 245 
	EXP e1\
262 
    } EXP : unsigned : LENGTH_list #
 246 
    } EXP : unsigned : LENGTH_list #
263 
 
 247 
 
264 
#pragma token PROC {\
 248 
#pragma token PROC {\
265 
	TYPE t, EXP : LIST ( t ) : e1 |\
 249 
	TYPE t, EXP : LIST(t) : e1 |\
266 
	EXP e1\
 250 
	EXP e1\
267 
    } EXP : LIST ( t ) : END_list #
 251 
    } EXP : LIST(t) : END_list #
268 
 
 252 
 
269 
#pragma token PROC {\
 253 
#pragma token PROC {\
270 
	TYPE t, EXP : LIST ( t ) : e1 |\
 254 
	TYPE t, EXP : LIST(t) : e1 |\
271 
	EXP e1\
 255 
	EXP e1\
272 
    } EXP : LIST ( t ) : REVERSE_list #
 256 
    } EXP : LIST(t) : REVERSE_list #
273 
 
 257 
 
274 
#pragma token PROC {\
 258 
#pragma token PROC {\
275 
	TYPE t, EXP : LIST ( t ) : e1, EXP : LIST ( t ) : e2 |\
 259 
	TYPE t, EXP : LIST(t) : e1, EXP : LIST(t) : e2 |\
276 
	EXP e1, EXP e2\
 260 
	EXP e1, EXP e2\
277 
    } EXP : LIST ( t ) : APPEND_list #
 261 
    } EXP : LIST(t) : APPEND_list #
278 
 
 262 
 
279 
#pragma token PROC (\
 263 
#pragma token PROC(\
280 
	TYPE t\
 264 
	TYPE t\
281 
    ) EXP const : LIST ( t ) : NULL_list #
 265 
    ) EXP const : LIST(t) : NULL_list #
282 
 
 266 
 
283 
#pragma token PROC {\
 267 
#pragma token PROC {\
284 
	TYPE t, EXP : LIST ( t ) : e |\
 268 
	TYPE t, EXP : LIST(t) : e |\
285 
	EXP e\
 269 
	EXP e\
286 
    } EXP : int : IS_NULL_list #
 270 
    } EXP : int : IS_NULL_list #
287 
 
 271 
 
288 
#pragma token PROC {\
 272 
#pragma token PROC {\
289 
	TYPE t, EXP : LIST ( t ) : e1, EXP : LIST ( t ) : e2 |\
 273 
	TYPE t, EXP : LIST(t) : e1, EXP : LIST(t) : e2 |\
290 
	EXP e1, EXP e2\
 274 
	EXP e1, EXP e2\
291 
    } EXP : int : EQ_list #
 275 
    } EXP : int : EQ_list #
292 
 
 276 
 
293 
#pragma token PROC (\
 277 
#pragma token PROC(\
294 
	TYPE t\
 278 
	TYPE t\
295 
    ) EXP : LIST ( t ) : UNIQ_list #
 279 
    ) EXP : LIST(t) : UNIQ_list #
296 
 
 280 
 
297 
#pragma token PROC {\
 281 
#pragma token PROC {\
298 
	TYPE t, EXP : LIST ( t ) : e |\
 282 
	TYPE t, EXP : LIST(t) : e |\
299 
	EXP e\
 283 
	EXP e\
300 
    } EXP : void : DESTROY_UNIQ_list #
 284 
    } EXP : void : DESTROY_UNIQ_list #
301 
 
 285 
 
302 
#pragma token PROC {\
 286 
#pragma token PROC {\
303 
	TYPE t, EXP : LIST ( t ) : e1, EXP : SIZE ( t ) : e2 |\
 287 
	TYPE t, EXP : LIST(t) : e1, EXP : SIZE(t) : e2 |\
304 
	EXP e1, EXP e2\
 288 
	EXP e1, EXP e2\
305 
    } STATEMENT DESTROY_list #
 289 
    } STATEMENT DESTROY_list #
306 
 
 290 
 
307 
#pragma interface HEAD_list PTR_TAIL_list TAIL_list
 291 
#pragma interface HEAD_list PTR_TAIL_list TAIL_list
308 
#pragma interface LENGTH_list END_list REVERSE_list APPEND_list
 292 
#pragma interface LENGTH_list END_list REVERSE_list APPEND_list
309 
#pragma interface NULL_list IS_NULL_list EQ_list
 293 
#pragma interface NULL_list IS_NULL_list EQ_list
310 
#pragma interface UNIQ_list DESTROY_UNIQ_list DESTROY_list
 294 
#pragma interface UNIQ_list DESTROY_UNIQ_list DESTROY_list
311 
 
 295 
 
312 
#ifdef tdf_IO_ROUTINES
 296 
#ifdef tdf_IO_ROUTINES
313 
#pragma token PROC {\
 297 
#pragma token PROC {\
314 
	TYPE t, EXP : LIST ( t ) : e |\
 298 
	TYPE t, EXP : LIST(t) : e |\
315 
	EXP e\
 299 
	EXP e\
316 
    } EXP : void * : VOIDSTAR_list #
 300 
    } EXP : void * : VOIDSTAR_list #
317 
#pragma interface VOIDSTAR_list
 301 
#pragma interface VOIDSTAR_list
318 
#endif
 302 
#endif
319 
 
 303 
 
320 
#pragma token PROC (\
 304 
#pragma token PROC(\
321 
	TYPE t\
 305 
	TYPE t\
322 
    ) EXP const : SIZE ( LIST ( t ) ) : SIZE_list #
 306 
    ) EXP const : SIZE(LIST(t)) : SIZE_list #
323 
 
 307 
 
324 
#pragma token PROC {\
 308 
#pragma token PROC {\
325 
	TYPE t, EXP : PTR ( LIST ( t ) ) : e1,\
 309 
	TYPE t, EXP : PTR(LIST(t)) : e1,\
326 
	EXP : LIST ( t ) : e2 |\
 310 
	EXP : LIST(t) : e2 |\
327 
	EXP e1, EXP e2\
 311 
	EXP e1, EXP e2\
328 
    } EXP : void : COPY_list #
 312 
    } EXP : void : COPY_list #
329 
 
 313 
 
330 
#pragma token PROC {\
 314 
#pragma token PROC {\
331 
	TYPE t, EXP : PTR ( LIST ( t ) ) : e |\
 315 
	TYPE t, EXP : PTR(LIST(t)) : e |\
332 
	EXP e\
 316 
	EXP e\
333 
    } EXP : LIST ( t ) : DEREF_list #
 317 
    } EXP : LIST(t) : DEREF_list #
334 
 
 318 
 
335 
#pragma token PROC {\
 319 
#pragma token PROC {\
336 
	TYPE t, EXP : LIST ( t ) : e2,\
 320 
	TYPE t, EXP : LIST(t) : e2,\
337 
	EXP : LIST ( LIST ( t ) ) : e3,\
 321 
	EXP : LIST(LIST(t)) : e3,\
338 
	EXP lvalue : LIST ( LIST ( t ) ) : e4 |\
 322 
	EXP lvalue : LIST(LIST(t)) : e4 |\
339 
	EXP e2, EXP e3, EXP e4\
 323 
	EXP e2, EXP e3, EXP e4\
340 
    } STATEMENT CONS_list #
 324 
    } STATEMENT CONS_list #
341 
 
 325 
 
342 
#pragma token PROC {\
 326 
#pragma token PROC {\
343 
	TYPE t, EXP lvalue : LIST ( t ) : e2,\
 327 
	TYPE t, EXP lvalue : LIST(t) : e2,\
344 
	EXP lvalue : LIST ( LIST ( t ) ) : e3,\
 328 
	EXP lvalue : LIST(LIST(t)) : e3,\
345 
	EXP : LIST ( LIST ( t ) ) : e4 |\
 329 
	EXP : LIST(LIST(t)) : e4 |\
346 
	EXP e2, EXP e3, EXP e4\
 330 
	EXP e2, EXP e3, EXP e4\
347 
    } STATEMENT UN_CONS_list #
 331 
    } STATEMENT UN_CONS_list #
348 
 
 332 
 
349 
#pragma token PROC {\
 333 
#pragma token PROC {\
350 
	TYPE t, EXP : DESTROYER : e1,\
 334 
	TYPE t, EXP : DESTROYER : e1,\
351 
	EXP lvalue : LIST ( t ) : e2,\
 335 
	EXP lvalue : LIST(t) : e2,\
352 
	EXP lvalue : LIST ( LIST ( t ) ) : e3,\
 336 
	EXP lvalue : LIST(LIST(t)) : e3,\
353 
	EXP : LIST ( LIST ( t ) ) : e4 |\
 337 
	EXP : LIST(LIST(t)) : e4 |\
354 
	EXP e1, EXP e2, EXP e3, EXP e4\
 338 
	EXP e1, EXP e2, EXP e3, EXP e4\
355 
    } STATEMENT DESTROY_CONS_list #
 339 
    } STATEMENT DESTROY_CONS_list #
356 
 
 340 
 
357 
#pragma token PROC {\
 341 
#pragma token PROC {\
358 
	TYPE t, EXP : LIST ( t ) : e2,\
 342 
	TYPE t, EXP : LIST(t) : e2,\
359 
	EXP lvalue : STACK ( LIST ( t ) ) : e3 |\
 343 
	EXP lvalue : STACK(LIST(t)) : e3 |\
360 
	EXP e2, EXP e3\
 344 
	EXP e2, EXP e3\
361 
    } STATEMENT PUSH_list #
 345 
    } STATEMENT PUSH_list #
362 
 
 346 
 
363 
#pragma token PROC {\
 347 
#pragma token PROC {\
364 
	TYPE t, EXP lvalue : LIST ( t ) : e2,\
 348 
	TYPE t, EXP lvalue : LIST(t) : e2,\
365 
	EXP lvalue : STACK ( LIST ( t ) ) : e3 |\
 349 
	EXP lvalue : STACK(LIST(t)) : e3 |\
366 
	EXP e2, EXP e3\
 350 
	EXP e2, EXP e3\
367 
    } STATEMENT POP_list #
 351 
    } STATEMENT POP_list #
368 
 
 352 
 
369 
#pragma interface SIZE_list COPY_list DEREF_list
 353 
#pragma interface SIZE_list COPY_list DEREF_list
370 
#pragma interface CONS_list UN_CONS_list DESTROY_CONS_list
 354 
#pragma interface CONS_list UN_CONS_list DESTROY_CONS_list
371 
#pragma interface PUSH_list POP_list
 355 
#pragma interface PUSH_list POP_list
372 
 
 356 
 
373 
 
 357 
 
374 
/* Stack token specifications */
 358 
/* Stack token specifications */
375 
 
 359 
 
376 
#pragma token PROC (\
 360 
#pragma token PROC(\
377 
	TYPE t\
 361 
	TYPE t\
378 
    ) EXP const : STACK ( t ) : NULL_stack #
 362 
    ) EXP const : STACK(t) : NULL_stack #
379 
 
 363 
 
380 
#pragma token PROC {\
 364 
#pragma token PROC {\
381 
	TYPE t, EXP : STACK ( t ) : e |\
 365 
	TYPE t, EXP : STACK(t) : e |\
382 
	EXP e\
 366 
	EXP e\
383 
    } EXP : int : IS_NULL_stack #
 367 
    } EXP : int : IS_NULL_stack #
384 
 
 368 
 
385 
#pragma token PROC {\
 369 
#pragma token PROC {\
386 
	TYPE t, EXP : STACK ( t ) : e1 |\
 370 
	TYPE t, EXP : STACK(t) : e1 |\
387 
	EXP e1\
 371 
	EXP e1\
388 
    } EXP : LIST ( t ) : LIST_stack #
 372 
    } EXP : LIST(t) : LIST_stack #
389 
 
 373 
 
390 
#pragma token PROC {\
 374 
#pragma token PROC {\
391 
	TYPE t, EXP : LIST ( t ) : e1 |\
 375 
	TYPE t, EXP : LIST(t) : e1 |\
392 
	EXP e1\
 376 
	EXP e1\
393 
    } EXP : STACK ( t ) : STACK_list #
 377 
    } EXP : STACK(t) : STACK_list #
394 
 
 378 
 
395 
#pragma interface NULL_stack IS_NULL_stack LIST_stack STACK_list
 379 
#pragma interface NULL_stack IS_NULL_stack LIST_stack STACK_list
396 
 
 380 
 
397 
#pragma token PROC (\
 381 
#pragma token PROC(\
398 
	TYPE t\
 382 
	TYPE t\
399 
    ) EXP const : SIZE ( STACK ( t ) ) : SIZE_stack #
 383 
    ) EXP const : SIZE(STACK(t)) : SIZE_stack #
400 
 
 384 
 
401 
#pragma token PROC {\
 385 
#pragma token PROC {\
402 
	TYPE t, EXP : PTR ( STACK ( t ) ) : e1,\
 386 
	TYPE t, EXP : PTR(STACK(t)) : e1,\
403 
	EXP : STACK ( t ) : e2 |\
 387 
	EXP : STACK(t) : e2 |\
404 
	EXP e1, EXP e2\
 388 
	EXP e1, EXP e2\
405 
    } EXP : void : COPY_stack #
 389 
    } EXP : void : COPY_stack #
406 
 
 390 
 
407 
#pragma token PROC {\
 391 
#pragma token PROC {\
408 
	TYPE t, EXP : PTR ( STACK ( t ) ) : e |\
 392 
	TYPE t, EXP : PTR(STACK(t)) : e |\
409 
	EXP e\
 393 
	EXP e\
410 
    } EXP : STACK ( t ) : DEREF_stack #
 394 
    } EXP : STACK(t) : DEREF_stack #
411 
 
 395 
 
412 
#pragma token PROC {\
 396 
#pragma token PROC {\
413 
	TYPE t, EXP : STACK ( t ) : e2,\
 397 
	TYPE t, EXP : STACK(t) : e2,\
414 
	EXP : LIST ( STACK ( t ) ) : e3,\
 398 
	EXP : LIST(STACK(t)) : e3,\
415 
	EXP lvalue : LIST ( STACK ( t ) ) : e4 |\
 399 
	EXP lvalue : LIST(STACK(t)) : e4 |\
416 
	EXP e2, EXP e3, EXP e4\
 400 
	EXP e2, EXP e3, EXP e4\
417 
    } STATEMENT CONS_stack #
 401 
    } STATEMENT CONS_stack #
418 
 
 402 
 
419 
#pragma token PROC {\
 403 
#pragma token PROC {\
420 
	TYPE t, EXP lvalue : STACK ( t ) : e2,\
 404 
	TYPE t, EXP lvalue : STACK(t) : e2,\
421 
	EXP lvalue : LIST ( STACK ( t ) ) : e3,\
 405 
	EXP lvalue : LIST(STACK(t)) : e3,\
422 
	EXP : LIST ( STACK ( t ) ) : e4 |\
 406 
	EXP : LIST(STACK(t)) : e4 |\
423 
	EXP e2, EXP e3, EXP e4\
 407 
	EXP e2, EXP e3, EXP e4\
424 
    } STATEMENT UN_CONS_stack #
 408 
    } STATEMENT UN_CONS_stack #
425 
 
 409 
 
426 
#pragma token PROC {\
 410 
#pragma token PROC {\
427 
	TYPE t, EXP : DESTROYER : e1,\
 411 
	TYPE t, EXP : DESTROYER : e1,\
428 
	EXP lvalue : STACK ( t ) : e2,\
 412 
	EXP lvalue : STACK(t) : e2,\
429 
	EXP lvalue : LIST ( STACK ( t ) ) : e3,\
 413 
	EXP lvalue : LIST(STACK(t)) : e3,\
430 
	EXP : LIST ( STACK ( t ) ) : e4 |\
 414 
	EXP : LIST(STACK(t)) : e4 |\
431 
	EXP e1, EXP e2, EXP e3, EXP e4\
 415 
	EXP e1, EXP e2, EXP e3, EXP e4\
432 
    } STATEMENT DESTROY_CONS_stack #
 416 
    } STATEMENT DESTROY_CONS_stack #
433 
 
 417 
 
434 
#pragma token PROC {\
 418 
#pragma token PROC {\
435 
	TYPE t, EXP : STACK ( t ) : e2,\
 419 
	TYPE t, EXP : STACK(t) : e2,\
436 
	EXP lvalue : STACK ( STACK ( t ) ) : e3 |\
 420 
	EXP lvalue : STACK(STACK(t)) : e3 |\
437 
	EXP e2, EXP e3\
 421 
	EXP e2, EXP e3\
438 
    } STATEMENT PUSH_stack #
 422 
    } STATEMENT PUSH_stack #
439 
 
 423 
 
440 
#pragma token PROC {\
 424 
#pragma token PROC {\
441 
	TYPE t, EXP lvalue : STACK ( t ) : e2,\
 425 
	TYPE t, EXP lvalue : STACK(t) : e2,\
442 
	EXP lvalue : STACK ( STACK ( t ) ) : e3 |\
 426 
	EXP lvalue : STACK(STACK(t)) : e3 |\
443 
	EXP e2, EXP e3\
 427 
	EXP e2, EXP e3\
444 
    } STATEMENT POP_stack #
 428 
    } STATEMENT POP_stack #
445 
 
 429 
 
446 
#pragma interface SIZE_stack COPY_stack DEREF_stack
 430 
#pragma interface SIZE_stack COPY_stack DEREF_stack
447 
#pragma interface CONS_stack UN_CONS_stack DESTROY_CONS_stack
 431 
#pragma interface CONS_stack UN_CONS_stack DESTROY_CONS_stack
Line 450... Line 434...
450 
 
 434 
 
451 
/* Size token specifications */
 435 
/* Size token specifications */
452 
 
 436 
 
453 
#pragma token PROC {\
 437 
#pragma token PROC {\
454 
	TYPE t, VARIETY v,\
 438 
	TYPE t, VARIETY v,\
455 
	EXP : SIZE ( t ) : e1, EXP : v : e2 |\
 439 
	EXP : SIZE(t) : e1, EXP : v : e2 |\
456 
	EXP e1, EXP e2\
 440 
	EXP e1, EXP e2\
457 
    } EXP : SIZE ( t ) : SCALE #
 441 
    } EXP : SIZE(t) : SCALE #
458 
 
 442 
 
459 
#pragma interface SCALE
 443 
#pragma interface SCALE
460 
 
 444 
 
461 
 
 445 
 
462 
/* Definitions for primitive int */
 446 
/* Definitions for primitive int */
463 
 
 447 
 
464 
#pragma token EXP const : SIZE ( int ) : SIZE_int #
 448 
#pragma token EXP const : SIZE(int) : SIZE_int #
465 
 
 449 
 
466 
#pragma token PROC (\
 450 
#pragma token PROC(\
467 
	EXP : PTR ( int ) :,\
 451 
	EXP : PTR(int) :,\
468 
	EXP : int :\
 452 
	EXP : int :\
469 
    ) EXP : void : COPY_int #
 453 
    ) EXP : void : COPY_int #
470 
 
 454 
 
471 
#pragma token PROC (\
 455 
#pragma token PROC(\
472 
	EXP : PTR ( int ) :\
 456 
	EXP : PTR(int) :\
473 
    ) EXP : int : DEREF_int #
 457 
    ) EXP : int : DEREF_int #
474 
 
 458 
 
475 
#pragma token PROC (\
 459 
#pragma token PROC(\
476 
	EXP : int :,\
 460 
	EXP : int :,\
477 
	EXP : LIST ( int ) :,\
 461 
	EXP : LIST(int) :,\
478 
	EXP lvalue : LIST ( int ) :\
 462 
	EXP lvalue : LIST(int) :\
479 
    ) STATEMENT CONS_int #
 463 
    ) STATEMENT CONS_int #
480 
 
 464 
 
481 
#pragma token PROC (\
 465 
#pragma token PROC(\
482 
	EXP lvalue : int :,\
 466 
	EXP lvalue : int :,\
483 
	EXP lvalue : LIST ( int ) :,\
 467 
	EXP lvalue : LIST(int) :,\
484 
	EXP : LIST ( int ) :\
 468 
	EXP : LIST(int) :\
485 
    ) STATEMENT UN_CONS_int #
 469 
    ) STATEMENT UN_CONS_int #
486 
 
 470 
 
487 
#pragma token PROC (\
 471 
#pragma token PROC(\
488 
	EXP : DESTROYER :,\
 472 
	EXP : DESTROYER :,\
489 
	EXP lvalue : int :,\
 473 
	EXP lvalue : int :,\
490 
	EXP lvalue : LIST ( int ) :,\
 474 
	EXP lvalue : LIST(int) :,\
491 
	EXP : LIST ( int ) :\
 475 
	EXP : LIST(int) :\
492 
    ) STATEMENT DESTROY_CONS_int #
 476 
    ) STATEMENT DESTROY_CONS_int #
493 
 
 477 
 
494 
#pragma token PROC (\
 478 
#pragma token PROC(\
495 
	EXP : int :,\
 479 
	EXP : int :,\
496 
	EXP lvalue : STACK ( int ) :\
 480 
	EXP lvalue : STACK(int) :\
497 
    ) STATEMENT PUSH_int #
 481 
    ) STATEMENT PUSH_int #
498 
 
 482 
 
499 
#pragma token PROC (\
 483 
#pragma token PROC(\
500 
	EXP lvalue : int :,\
 484 
	EXP lvalue : int :,\
501 
	EXP lvalue : STACK ( int ) :\
 485 
	EXP lvalue : STACK(int) :\
502 
    ) STATEMENT POP_int #
 486 
    ) STATEMENT POP_int #
503 
 
 487 
 
504 
#pragma interface SIZE_int COPY_int DEREF_int
 488 
#pragma interface SIZE_int COPY_int DEREF_int
505 
#pragma interface CONS_int UN_CONS_int DESTROY_CONS_int
 489 
#pragma interface CONS_int UN_CONS_int DESTROY_CONS_int
506 
#pragma interface PUSH_int POP_int
 490 
#pragma interface PUSH_int POP_int
507 
 
 491 
 
508 
 
 492 
 
509 
/* Definitions for primitive unsigned */
 493 
/* Definitions for primitive unsigned */
510 
 
 494 
 
511 
#pragma token EXP const : SIZE ( unsigned ) : SIZE_unsigned #
 495 
#pragma token EXP const : SIZE(unsigned) : SIZE_unsigned #
512 
 
 496 
 
513 
#pragma token PROC (\
 497 
#pragma token PROC(\
514 
	EXP : PTR ( unsigned ) :,\
 498 
	EXP : PTR(unsigned) :,\
515 
	EXP : unsigned :\
 499 
	EXP : unsigned :\
516 
    ) EXP : void : COPY_unsigned #
 500 
    ) EXP : void : COPY_unsigned #
517 
 
 501 
 
518 
#pragma token PROC (\
 502 
#pragma token PROC(\
519 
	EXP : PTR ( unsigned ) :\
 503 
	EXP : PTR(unsigned) :\
520 
    ) EXP : unsigned : DEREF_unsigned #
 504 
    ) EXP : unsigned : DEREF_unsigned #
521 
 
 505 
 
522 
#pragma token PROC (\
 506 
#pragma token PROC(\
523 
	EXP : unsigned :,\
 507 
	EXP : unsigned :,\
524 
	EXP : LIST ( unsigned ) :,\
 508 
	EXP : LIST(unsigned) :,\
525 
	EXP lvalue : LIST ( unsigned ) :\
 509 
	EXP lvalue : LIST(unsigned) :\
526 
    ) STATEMENT CONS_unsigned #
 510 
    ) STATEMENT CONS_unsigned #
527 
 
 511 
 
528 
#pragma token PROC (\
 512 
#pragma token PROC(\
529 
	EXP lvalue : unsigned :,\
 513 
	EXP lvalue : unsigned :,\
530 
	EXP lvalue : LIST ( unsigned ) :,\
 514 
	EXP lvalue : LIST(unsigned) :,\
531 
	EXP : LIST ( unsigned ) :\
 515 
	EXP : LIST(unsigned) :\
532 
    ) STATEMENT UN_CONS_unsigned #
 516 
    ) STATEMENT UN_CONS_unsigned #
533 
 
 517 
 
534 
#pragma token PROC (\
 518 
#pragma token PROC(\
535 
	EXP : DESTROYER :,\
 519 
	EXP : DESTROYER :,\
536 
	EXP lvalue : unsigned :,\
 520 
	EXP lvalue : unsigned :,\
537 
	EXP lvalue : LIST ( unsigned ) :,\
 521 
	EXP lvalue : LIST(unsigned) :,\
538 
	EXP : LIST ( unsigned ) :\
 522 
	EXP : LIST(unsigned) :\
539 
    ) STATEMENT DESTROY_CONS_unsigned #
 523 
    ) STATEMENT DESTROY_CONS_unsigned #
540 
 
 524 
 
541 
#pragma token PROC (\
 525 
#pragma token PROC(\
542 
	EXP : unsigned :,\
 526 
	EXP : unsigned :,\
543 
	EXP lvalue : STACK ( unsigned ) :\
 527 
	EXP lvalue : STACK(unsigned) :\
544 
    ) STATEMENT PUSH_unsigned #
 528 
    ) STATEMENT PUSH_unsigned #
545 
 
 529 
 
546 
#pragma token PROC (\
 530 
#pragma token PROC(\
547 
	EXP lvalue : unsigned :,\
 531 
	EXP lvalue : unsigned :,\
548 
	EXP lvalue : STACK ( unsigned ) :\
 532 
	EXP lvalue : STACK(unsigned) :\
549 
    ) STATEMENT POP_unsigned #
 533 
    ) STATEMENT POP_unsigned #
550 
 
 534 
 
551 
#pragma interface SIZE_unsigned COPY_unsigned DEREF_unsigned
 535 
#pragma interface SIZE_unsigned COPY_unsigned DEREF_unsigned
552 
#pragma interface CONS_unsigned UN_CONS_unsigned DESTROY_CONS_unsigned
 536 
#pragma interface CONS_unsigned UN_CONS_unsigned DESTROY_CONS_unsigned
553 
#pragma interface PUSH_unsigned POP_unsigned
 537 
#pragma interface PUSH_unsigned POP_unsigned
554 
 
 538 
 
555 
 
 539 
 
556 
/* Definitions for primitive string */
 540 
/* Definitions for primitive string */
557 
 
 541 
 
558 
#pragma token EXP const : SIZE ( string ) : SIZE_string #
 542 
#pragma token EXP const : SIZE(string) : SIZE_string #
559 
 
 543 
 
560 
#pragma token PROC (\
 544 
#pragma token PROC(\
561 
	EXP : PTR ( string ) :,\
 545 
	EXP : PTR(string) :,\
562 
	EXP : string :\
 546 
	EXP : string :\
563 
    ) EXP : void : COPY_string #
 547 
    ) EXP : void : COPY_string #
564 
 
 548 
 
565 
#pragma token PROC (\
 549 
#pragma token PROC(\
566 
	EXP : PTR ( string ) :\
 550 
	EXP : PTR(string) :\
567 
    ) EXP : string : DEREF_string #
 551 
    ) EXP : string : DEREF_string #
568 
 
 552 
 
569 
#pragma token PROC (\
 553 
#pragma token PROC(\
570 
	EXP : string :,\
 554 
	EXP : string :,\
571 
	EXP : LIST ( string ) :,\
 555 
	EXP : LIST(string) :,\
572 
	EXP lvalue : LIST ( string ) :\
 556 
	EXP lvalue : LIST(string) :\
573 
    ) STATEMENT CONS_string #
 557 
    ) STATEMENT CONS_string #
574 
 
 558 
 
575 
#pragma token PROC (\
 559 
#pragma token PROC(\
576 
	EXP lvalue : string :,\
 560 
	EXP lvalue : string :,\
577 
	EXP lvalue : LIST ( string ) :,\
 561 
	EXP lvalue : LIST(string) :,\
578 
	EXP : LIST ( string ) :\
 562 
	EXP : LIST(string) :\
579 
    ) STATEMENT UN_CONS_string #
 563 
    ) STATEMENT UN_CONS_string #
580 
 
 564 
 
581 
#pragma token PROC (\
 565 
#pragma token PROC(\
582 
	EXP : DESTROYER :,\
 566 
	EXP : DESTROYER :,\
583 
	EXP lvalue : string :,\
 567 
	EXP lvalue : string :,\
584 
	EXP lvalue : LIST ( string ) :,\
 568 
	EXP lvalue : LIST(string) :,\
585 
	EXP : LIST ( string ) :\
 569 
	EXP : LIST(string) :\
586 
    ) STATEMENT DESTROY_CONS_string #
 570 
    ) STATEMENT DESTROY_CONS_string #
587 
 
 571 
 
588 
#pragma token PROC (\
 572 
#pragma token PROC(\
589 
	EXP : string :,\
 573 
	EXP : string :,\
590 
	EXP lvalue : STACK ( string ) :\
 574 
	EXP lvalue : STACK(string) :\
591 
    ) STATEMENT PUSH_string #
 575 
    ) STATEMENT PUSH_string #
592 
 
 576 
 
593 
#pragma token PROC (\
 577 
#pragma token PROC(\
594 
	EXP lvalue : string :,\
 578 
	EXP lvalue : string :,\
595 
	EXP lvalue : STACK ( string ) :\
 579 
	EXP lvalue : STACK(string) :\
596 
    ) STATEMENT POP_string #
 580 
    ) STATEMENT POP_string #
597 
 
 581 
 
598 
#pragma interface SIZE_string COPY_string DEREF_string
 582 
#pragma interface SIZE_string COPY_string DEREF_string
599 
#pragma interface CONS_string UN_CONS_string DESTROY_CONS_string
 583 
#pragma interface CONS_string UN_CONS_string DESTROY_CONS_string
600 
#pragma interface PUSH_string POP_string
 584 
#pragma interface PUSH_string POP_string
601 
 
 585 
 
602 
 
 586 
 
603 
/* Definitions for union PARAMETER */
 587 
/* Definitions for union PARAMETER */
604 
 
 588 
 
605 
#define ORDER_par ( ( unsigned ) 1 )
 589 
#define ORDER_par ((unsigned)1)
606 
#pragma token EXP const : PARAMETER : NULL_par #
 590 
#pragma token EXP const : PARAMETER : NULL_par #
607 
#pragma token PROC ( EXP : PARAMETER : ) EXP : int : IS_NULL_par #
 591 
#pragma token PROC(EXP : PARAMETER :) EXP : int : IS_NULL_par #
608 
#pragma token PROC ( EXP : PARAMETER :, EXP : PARAMETER : ) EXP : int : EQ_par #
 592 
#pragma token PROC(EXP : PARAMETER :, EXP : PARAMETER :) EXP : int : EQ_par #
609 
#pragma interface NULL_par IS_NULL_par EQ_par
 593 
#pragma interface NULL_par IS_NULL_par EQ_par
610 
 
 594 
 
611 
#pragma token EXP const : SIZE ( PARAMETER ) : SIZE_par #
 595 
#pragma token EXP const : SIZE(PARAMETER) : SIZE_par #
612 
 
 596 
 
613 
#pragma token PROC (\
 597 
#pragma token PROC(\
614 
	EXP : PTR ( PARAMETER ) :,\
 598 
	EXP : PTR(PARAMETER) :,\
615 
	EXP : PARAMETER :\
 599 
	EXP : PARAMETER :\
616 
    ) EXP : void : COPY_par #
 600 
    ) EXP : void : COPY_par #
617 
 
 601 
 
618 
#pragma token PROC (\
 602 
#pragma token PROC(\
619 
	EXP : PTR ( PARAMETER ) :\
 603 
	EXP : PTR(PARAMETER) :\
620 
    ) EXP : PARAMETER : DEREF_par #
 604 
    ) EXP : PARAMETER : DEREF_par #
621 
 
 605 
 
622 
#pragma token PROC (\
 606 
#pragma token PROC(\
623 
	EXP : PARAMETER :,\
 607 
	EXP : PARAMETER :,\
624 
	EXP : LIST ( PARAMETER ) :,\
 608 
	EXP : LIST(PARAMETER) :,\
625 
	EXP lvalue : LIST ( PARAMETER ) :\
 609 
	EXP lvalue : LIST(PARAMETER) :\
626 
    ) STATEMENT CONS_par #
 610 
    ) STATEMENT CONS_par #
627 
 
 611 
 
628 
#pragma token PROC (\
 612 
#pragma token PROC(\
629 
	EXP lvalue : PARAMETER :,\
 613 
	EXP lvalue : PARAMETER :,\
630 
	EXP lvalue : LIST ( PARAMETER ) :,\
 614 
	EXP lvalue : LIST(PARAMETER) :,\
631 
	EXP : LIST ( PARAMETER ) :\
 615 
	EXP : LIST(PARAMETER) :\
632 
    ) STATEMENT UN_CONS_par #
 616 
    ) STATEMENT UN_CONS_par #
633 
 
 617 
 
634 
#pragma token PROC (\
 618 
#pragma token PROC(\
635 
	EXP : DESTROYER :,\
 619 
	EXP : DESTROYER :,\
636 
	EXP lvalue : PARAMETER :,\
 620 
	EXP lvalue : PARAMETER :,\
637 
	EXP lvalue : LIST ( PARAMETER ) :,\
 621 
	EXP lvalue : LIST(PARAMETER) :,\
638 
	EXP : LIST ( PARAMETER ) :\
 622 
	EXP : LIST(PARAMETER) :\
639 
    ) STATEMENT DESTROY_CONS_par #
 623 
    ) STATEMENT DESTROY_CONS_par #
640 
 
 624 
 
641 
#pragma token PROC (\
 625 
#pragma token PROC(\
642 
	EXP : PARAMETER :,\
 626 
	EXP : PARAMETER :,\
643 
	EXP lvalue : STACK ( PARAMETER ) :\
 627 
	EXP lvalue : STACK(PARAMETER) :\
644 
    ) STATEMENT PUSH_par #
 628 
    ) STATEMENT PUSH_par #
645 
 
 629 
 
646 
#pragma token PROC (\
 630 
#pragma token PROC(\
647 
	EXP lvalue : PARAMETER :,\
 631 
	EXP lvalue : PARAMETER :,\
648 
	EXP lvalue : STACK ( PARAMETER ) :\
 632 
	EXP lvalue : STACK(PARAMETER) :\
649 
    ) STATEMENT POP_par #
 633 
    ) STATEMENT POP_par #
650 
 
 634 
 
651 
#pragma interface SIZE_par COPY_par DEREF_par
 635 
#pragma interface SIZE_par COPY_par DEREF_par
652 
#pragma interface CONS_par UN_CONS_par DESTROY_CONS_par
 636 
#pragma interface CONS_par UN_CONS_par DESTROY_CONS_par
653 
#pragma interface PUSH_par POP_par
 637 
#pragma interface PUSH_par POP_par
654 
 
 638 
 
655 
 
 639 
 
656 
/* Definitions for union CONSTRUCT */
 640 
/* Definitions for union CONSTRUCT */
657 
 
 641 
 
658 
#define ORDER_cons ( ( unsigned ) 1 )
 642 
#define ORDER_cons ((unsigned)1)
659 
#pragma token EXP const : CONSTRUCT : NULL_cons #
 643 
#pragma token EXP const : CONSTRUCT : NULL_cons #
660 
#pragma token PROC ( EXP : CONSTRUCT : ) EXP : int : IS_NULL_cons #
 644 
#pragma token PROC(EXP : CONSTRUCT :) EXP : int : IS_NULL_cons #
661 
#pragma token PROC ( EXP : CONSTRUCT :, EXP : CONSTRUCT : ) EXP : int : EQ_cons #
 645 
#pragma token PROC(EXP : CONSTRUCT :, EXP : CONSTRUCT :) EXP : int : EQ_cons #
662 
#pragma interface NULL_cons IS_NULL_cons EQ_cons
 646 
#pragma interface NULL_cons IS_NULL_cons EQ_cons
663 
 
 647 
 
664 
#pragma token EXP const : SIZE ( CONSTRUCT ) : SIZE_cons #
 648 
#pragma token EXP const : SIZE(CONSTRUCT) : SIZE_cons #
665 
 
 649 
 
666 
#pragma token PROC (\
 650 
#pragma token PROC(\
667 
	EXP : PTR ( CONSTRUCT ) :,\
 651 
	EXP : PTR(CONSTRUCT) :,\
668 
	EXP : CONSTRUCT :\
 652 
	EXP : CONSTRUCT :\
669 
    ) EXP : void : COPY_cons #
 653 
    ) EXP : void : COPY_cons #
670 
 
 654 
 
671 
#pragma token PROC (\
 655 
#pragma token PROC(\
672 
	EXP : PTR ( CONSTRUCT ) :\
 656 
	EXP : PTR(CONSTRUCT) :\
673 
    ) EXP : CONSTRUCT : DEREF_cons #
 657 
    ) EXP : CONSTRUCT : DEREF_cons #
674 
 
 658 
 
675 
#pragma token PROC (\
 659 
#pragma token PROC(\
676 
	EXP : CONSTRUCT :,\
 660 
	EXP : CONSTRUCT :,\
677 
	EXP : LIST ( CONSTRUCT ) :,\
 661 
	EXP : LIST(CONSTRUCT) :,\
678 
	EXP lvalue : LIST ( CONSTRUCT ) :\
 662 
	EXP lvalue : LIST(CONSTRUCT) :\
679 
    ) STATEMENT CONS_cons #
 663 
    ) STATEMENT CONS_cons #
680 
 
 664 
 
681 
#pragma token PROC (\
 665 
#pragma token PROC(\
682 
	EXP lvalue : CONSTRUCT :,\
 666 
	EXP lvalue : CONSTRUCT :,\
683 
	EXP lvalue : LIST ( CONSTRUCT ) :,\
 667 
	EXP lvalue : LIST(CONSTRUCT) :,\
684 
	EXP : LIST ( CONSTRUCT ) :\
 668 
	EXP : LIST(CONSTRUCT) :\
685 
    ) STATEMENT UN_CONS_cons #
 669 
    ) STATEMENT UN_CONS_cons #
686 
 
 670 
 
687 
#pragma token PROC (\
 671 
#pragma token PROC(\
688 
	EXP : DESTROYER :,\
 672 
	EXP : DESTROYER :,\
689 
	EXP lvalue : CONSTRUCT :,\
 673 
	EXP lvalue : CONSTRUCT :,\
690 
	EXP lvalue : LIST ( CONSTRUCT ) :,\
 674 
	EXP lvalue : LIST(CONSTRUCT) :,\
691 
	EXP : LIST ( CONSTRUCT ) :\
 675 
	EXP : LIST(CONSTRUCT) :\
692 
    ) STATEMENT DESTROY_CONS_cons #
 676 
    ) STATEMENT DESTROY_CONS_cons #
693 
 
 677 
 
694 
#pragma token PROC (\
 678 
#pragma token PROC(\
695 
	EXP : CONSTRUCT :,\
 679 
	EXP : CONSTRUCT :,\
696 
	EXP lvalue : STACK ( CONSTRUCT ) :\
 680 
	EXP lvalue : STACK(CONSTRUCT) :\
697 
    ) STATEMENT PUSH_cons #
 681 
    ) STATEMENT PUSH_cons #
698 
 
 682 
 
699 
#pragma token PROC (\
 683 
#pragma token PROC(\
700 
	EXP lvalue : CONSTRUCT :,\
 684 
	EXP lvalue : CONSTRUCT :,\
701 
	EXP lvalue : STACK ( CONSTRUCT ) :\
 685 
	EXP lvalue : STACK(CONSTRUCT) :\
702 
    ) STATEMENT POP_cons #
 686 
    ) STATEMENT POP_cons #
703 
 
 687 
 
704 
#pragma interface SIZE_cons COPY_cons DEREF_cons
 688 
#pragma interface SIZE_cons COPY_cons DEREF_cons
705 
#pragma interface CONS_cons UN_CONS_cons DESTROY_CONS_cons
 689 
#pragma interface CONS_cons UN_CONS_cons DESTROY_CONS_cons
706 
#pragma interface PUSH_cons POP_cons
 690 
#pragma interface PUSH_cons POP_cons
707 
 
 691 
 
708 
 
 692 
 
709 
/* Definitions for union SORT_INFO */
 693 
/* Definitions for union SORT_INFO */
710 
 
 694 
 
711 
#define ORDER_info ( ( unsigned ) 6 )
 695 
#define ORDER_info ((unsigned)6)
712 
#pragma token EXP const : SORT_INFO : NULL_info #
 696 
#pragma token EXP const : SORT_INFO : NULL_info #
713 
#pragma token PROC ( EXP : SORT_INFO : ) EXP : int : IS_NULL_info #
 697 
#pragma token PROC(EXP : SORT_INFO :) EXP : int : IS_NULL_info #
714 
#pragma token PROC ( EXP : SORT_INFO :, EXP : SORT_INFO : ) EXP : int : EQ_info #
 698 
#pragma token PROC(EXP : SORT_INFO :, EXP : SORT_INFO :) EXP : int : EQ_info #
715 
#pragma interface NULL_info IS_NULL_info EQ_info
 699 
#pragma interface NULL_info IS_NULL_info EQ_info
716 
 
 700 
 
717 
#pragma token EXP const : SIZE ( SORT_INFO ) : SIZE_info #
 701 
#pragma token EXP const : SIZE(SORT_INFO) : SIZE_info #
718 
 
 702 
 
719 
#pragma token PROC (\
 703 
#pragma token PROC(\
720 
	EXP : PTR ( SORT_INFO ) :,\
 704 
	EXP : PTR(SORT_INFO) :,\
721 
	EXP : SORT_INFO :\
 705 
	EXP : SORT_INFO :\
722 
    ) EXP : void : COPY_info #
 706 
    ) EXP : void : COPY_info #
723 
 
 707 
 
724 
#pragma token PROC (\
 708 
#pragma token PROC(\
725 
	EXP : PTR ( SORT_INFO ) :\
 709 
	EXP : PTR(SORT_INFO) :\
726 
    ) EXP : SORT_INFO : DEREF_info #
 710 
    ) EXP : SORT_INFO : DEREF_info #
727 
 
 711 
 
728 
#pragma token PROC (\
 712 
#pragma token PROC(\
729 
	EXP : SORT_INFO :,\
 713 
	EXP : SORT_INFO :,\
730 
	EXP : LIST ( SORT_INFO ) :,\
 714 
	EXP : LIST(SORT_INFO) :,\
731 
	EXP lvalue : LIST ( SORT_INFO ) :\
 715 
	EXP lvalue : LIST(SORT_INFO) :\
732 
    ) STATEMENT CONS_info #
 716 
    ) STATEMENT CONS_info #
733 
 
 717 
 
734 
#pragma token PROC (\
 718 
#pragma token PROC(\
735 
	EXP lvalue : SORT_INFO :,\
 719 
	EXP lvalue : SORT_INFO :,\
736 
	EXP lvalue : LIST ( SORT_INFO ) :,\
 720 
	EXP lvalue : LIST(SORT_INFO) :,\
737 
	EXP : LIST ( SORT_INFO ) :\
 721 
	EXP : LIST(SORT_INFO) :\
738 
    ) STATEMENT UN_CONS_info #
 722 
    ) STATEMENT UN_CONS_info #
739 
 
 723 
 
740 
#pragma token PROC (\
 724 
#pragma token PROC(\
741 
	EXP : DESTROYER :,\
 725 
	EXP : DESTROYER :,\
742 
	EXP lvalue : SORT_INFO :,\
 726 
	EXP lvalue : SORT_INFO :,\
743 
	EXP lvalue : LIST ( SORT_INFO ) :,\
 727 
	EXP lvalue : LIST(SORT_INFO) :,\
744 
	EXP : LIST ( SORT_INFO ) :\
 728 
	EXP : LIST(SORT_INFO) :\
745 
    ) STATEMENT DESTROY_CONS_info #
 729 
    ) STATEMENT DESTROY_CONS_info #
746 
 
 730 
 
747 
#pragma token PROC (\
 731 
#pragma token PROC(\
748 
	EXP : SORT_INFO :,\
 732 
	EXP : SORT_INFO :,\
749 
	EXP lvalue : STACK ( SORT_INFO ) :\
 733 
	EXP lvalue : STACK(SORT_INFO) :\
750 
    ) STATEMENT PUSH_info #
 734 
    ) STATEMENT PUSH_info #
751 
 
 735 
 
752 
#pragma token PROC (\
 736 
#pragma token PROC(\
753 
	EXP lvalue : SORT_INFO :,\
 737 
	EXP lvalue : SORT_INFO :,\
754 
	EXP lvalue : STACK ( SORT_INFO ) :\
 738 
	EXP lvalue : STACK(SORT_INFO) :\
755 
    ) STATEMENT POP_info #
 739 
    ) STATEMENT POP_info #
756 
 
 740 
 
757 
#pragma interface SIZE_info COPY_info DEREF_info
 741 
#pragma interface SIZE_info COPY_info DEREF_info
758 
#pragma interface CONS_info UN_CONS_info DESTROY_CONS_info
 742 
#pragma interface CONS_info UN_CONS_info DESTROY_CONS_info
759 
#pragma interface PUSH_info POP_info
 743 
#pragma interface PUSH_info POP_info
760 
 
 744 
 
761 
 
 745 
 
762 
/* Definitions for union SORT */
 746 
/* Definitions for union SORT */
763 
 
 747 
 
764 
#define ORDER_sort ( ( unsigned ) 1 )
 748 
#define ORDER_sort ((unsigned)1)
765 
#pragma token EXP const : SORT : NULL_sort #
 749 
#pragma token EXP const : SORT : NULL_sort #
766 
#pragma token PROC ( EXP : SORT : ) EXP : int : IS_NULL_sort #
 750 
#pragma token PROC(EXP : SORT :) EXP : int : IS_NULL_sort #
767 
#pragma token PROC ( EXP : SORT :, EXP : SORT : ) EXP : int : EQ_sort #
 751 
#pragma token PROC(EXP : SORT :, EXP : SORT :) EXP : int : EQ_sort #
768 
#pragma interface NULL_sort IS_NULL_sort EQ_sort
 752 
#pragma interface NULL_sort IS_NULL_sort EQ_sort
769 
 
 753 
 
770 
#pragma token EXP const : SIZE ( SORT ) : SIZE_sort #
 754 
#pragma token EXP const : SIZE(SORT) : SIZE_sort #
771 
 
 755 
 
772 
#pragma token PROC (\
 756 
#pragma token PROC(\
773 
	EXP : PTR ( SORT ) :,\
 757 
	EXP : PTR(SORT) :,\
774 
	EXP : SORT :\
 758 
	EXP : SORT :\
775 
    ) EXP : void : COPY_sort #
 759 
    ) EXP : void : COPY_sort #
776 
 
 760 
 
777 
#pragma token PROC (\
 761 
#pragma token PROC(\
778 
	EXP : PTR ( SORT ) :\
 762 
	EXP : PTR(SORT) :\
779 
    ) EXP : SORT : DEREF_sort #
 763 
    ) EXP : SORT : DEREF_sort #
780 
 
 764 
 
781 
#pragma token PROC (\
 765 
#pragma token PROC(\
782 
	EXP : SORT :,\
 766 
	EXP : SORT :,\
783 
	EXP : LIST ( SORT ) :,\
 767 
	EXP : LIST(SORT) :,\
784 
	EXP lvalue : LIST ( SORT ) :\
 768 
	EXP lvalue : LIST(SORT) :\
785 
    ) STATEMENT CONS_sort #
 769 
    ) STATEMENT CONS_sort #
786 
 
 770 
 
787 
#pragma token PROC (\
 771 
#pragma token PROC(\
788 
	EXP lvalue : SORT :,\
 772 
	EXP lvalue : SORT :,\
789 
	EXP lvalue : LIST ( SORT ) :,\
 773 
	EXP lvalue : LIST(SORT) :,\
790 
	EXP : LIST ( SORT ) :\
 774 
	EXP : LIST(SORT) :\
791 
    ) STATEMENT UN_CONS_sort #
 775 
    ) STATEMENT UN_CONS_sort #
792 
 
 776 
 
793 
#pragma token PROC (\
 777 
#pragma token PROC(\
794 
	EXP : DESTROYER :,\
 778 
	EXP : DESTROYER :,\
795 
	EXP lvalue : SORT :,\
 779 
	EXP lvalue : SORT :,\
796 
	EXP lvalue : LIST ( SORT ) :,\
 780 
	EXP lvalue : LIST(SORT) :,\
797 
	EXP : LIST ( SORT ) :\
 781 
	EXP : LIST(SORT) :\
798 
    ) STATEMENT DESTROY_CONS_sort #
 782 
    ) STATEMENT DESTROY_CONS_sort #
799 
 
 783 
 
800 
#pragma token PROC (\
 784 
#pragma token PROC(\
801 
	EXP : SORT :,\
 785 
	EXP : SORT :,\
802 
	EXP lvalue : STACK ( SORT ) :\
 786 
	EXP lvalue : STACK(SORT) :\
803 
    ) STATEMENT PUSH_sort #
 787 
    ) STATEMENT PUSH_sort #
804 
 
 788 
 
805 
#pragma token PROC (\
 789 
#pragma token PROC(\
806 
	EXP lvalue : SORT :,\
 790 
	EXP lvalue : SORT :,\
807 
	EXP lvalue : STACK ( SORT ) :\
 791 
	EXP lvalue : STACK(SORT) :\
808 
    ) STATEMENT POP_sort #
 792 
    ) STATEMENT POP_sort #
809 
 
 793 
 
810 
#pragma interface SIZE_sort COPY_sort DEREF_sort
 794 
#pragma interface SIZE_sort COPY_sort DEREF_sort
811 
#pragma interface CONS_sort UN_CONS_sort DESTROY_CONS_sort
 795 
#pragma interface CONS_sort UN_CONS_sort DESTROY_CONS_sort
812 
#pragma interface PUSH_sort POP_sort
 796 
#pragma interface PUSH_sort POP_sort
813 
 
 797 
 
814 
 
 798 
 
815 
/* Definitions for union LINKAGE */
 799 
/* Definitions for union LINKAGE */
816 
 
 800 
 
817 
#define ORDER_link ( ( unsigned ) 1 )
 801 
#define ORDER_link ((unsigned)1)
818 
#pragma token EXP const : LINKAGE : NULL_link #
 802 
#pragma token EXP const : LINKAGE : NULL_link #
819 
#pragma token PROC ( EXP : LINKAGE : ) EXP : int : IS_NULL_link #
 803 
#pragma token PROC(EXP : LINKAGE :) EXP : int : IS_NULL_link #
820 
#pragma token PROC ( EXP : LINKAGE :, EXP : LINKAGE : ) EXP : int : EQ_link #
 804 
#pragma token PROC(EXP : LINKAGE :, EXP : LINKAGE :) EXP : int : EQ_link #
821 
#pragma interface NULL_link IS_NULL_link EQ_link
 805 
#pragma interface NULL_link IS_NULL_link EQ_link
822 
 
 806 
 
823 
#pragma token EXP const : SIZE ( LINKAGE ) : SIZE_link #
 807 
#pragma token EXP const : SIZE(LINKAGE) : SIZE_link #
824 
 
 808 
 
825 
#pragma token PROC (\
 809 
#pragma token PROC(\
826 
	EXP : PTR ( LINKAGE ) :,\
 810 
	EXP : PTR(LINKAGE) :,\
827 
	EXP : LINKAGE :\
 811 
	EXP : LINKAGE :\
828 
    ) EXP : void : COPY_link #
 812 
    ) EXP : void : COPY_link #
829 
 
 813 
 
830 
#pragma token PROC (\
 814 
#pragma token PROC(\
831 
	EXP : PTR ( LINKAGE ) :\
 815 
	EXP : PTR(LINKAGE) :\
832 
    ) EXP : LINKAGE : DEREF_link #
 816 
    ) EXP : LINKAGE : DEREF_link #
833 
 
 817 
 
834 
#pragma token PROC (\
 818 
#pragma token PROC(\
835 
	EXP : LINKAGE :,\
 819 
	EXP : LINKAGE :,\
836 
	EXP : LIST ( LINKAGE ) :,\
 820 
	EXP : LIST(LINKAGE) :,\
837 
	EXP lvalue : LIST ( LINKAGE ) :\
 821 
	EXP lvalue : LIST(LINKAGE) :\
838 
    ) STATEMENT CONS_link #
 822 
    ) STATEMENT CONS_link #
839 
 
 823 
 
840 
#pragma token PROC (\
 824 
#pragma token PROC(\
841 
	EXP lvalue : LINKAGE :,\
 825 
	EXP lvalue : LINKAGE :,\
842 
	EXP lvalue : LIST ( LINKAGE ) :,\
 826 
	EXP lvalue : LIST(LINKAGE) :,\
843 
	EXP : LIST ( LINKAGE ) :\
 827 
	EXP : LIST(LINKAGE) :\
844 
    ) STATEMENT UN_CONS_link #
 828 
    ) STATEMENT UN_CONS_link #
845 
 
 829 
 
846 
#pragma token PROC (\
 830 
#pragma token PROC(\
847 
	EXP : DESTROYER :,\
 831 
	EXP : DESTROYER :,\
848 
	EXP lvalue : LINKAGE :,\
 832 
	EXP lvalue : LINKAGE :,\
849 
	EXP lvalue : LIST ( LINKAGE ) :,\
 833 
	EXP lvalue : LIST(LINKAGE) :,\
850 
	EXP : LIST ( LINKAGE ) :\
 834 
	EXP : LIST(LINKAGE) :\
851 
    ) STATEMENT DESTROY_CONS_link #
 835 
    ) STATEMENT DESTROY_CONS_link #
852 
 
 836 
 
853 
#pragma token PROC (\
 837 
#pragma token PROC(\
854 
	EXP : LINKAGE :,\
 838 
	EXP : LINKAGE :,\
855 
	EXP lvalue : STACK ( LINKAGE ) :\
 839 
	EXP lvalue : STACK(LINKAGE) :\
856 
    ) STATEMENT PUSH_link #
 840 
    ) STATEMENT PUSH_link #
857 
 
 841 
 
858 
#pragma token PROC (\
 842 
#pragma token PROC(\
859 
	EXP lvalue : LINKAGE :,\
 843 
	EXP lvalue : LINKAGE :,\
860 
	EXP lvalue : STACK ( LINKAGE ) :\
 844 
	EXP lvalue : STACK(LINKAGE) :\
861 
    ) STATEMENT POP_link #
 845 
    ) STATEMENT POP_link #
862 
 
 846 
 
863 
#pragma interface SIZE_link COPY_link DEREF_link
 847 
#pragma interface SIZE_link COPY_link DEREF_link
864 
#pragma interface CONS_link UN_CONS_link DESTROY_CONS_link
 848 
#pragma interface CONS_link UN_CONS_link DESTROY_CONS_link
865 
#pragma interface PUSH_link POP_link
 849 
#pragma interface PUSH_link POP_link
866 
 
 850 
 
867 
 
 851 
 
868 
/* Definitions for union SPECIFICATION */
 852 
/* Definitions for union SPECIFICATION */
869 
 
 853 
 
870 
#define ORDER_spec ( ( unsigned ) 1 )
 854 
#define ORDER_spec ((unsigned)1)
871 
#pragma token EXP const : SPECIFICATION : NULL_spec #
 855 
#pragma token EXP const : SPECIFICATION : NULL_spec #
872 
#pragma token PROC ( EXP : SPECIFICATION : ) EXP : int : IS_NULL_spec #
 856 
#pragma token PROC(EXP : SPECIFICATION :) EXP : int : IS_NULL_spec #
873 
#pragma token PROC ( EXP : SPECIFICATION :, EXP : SPECIFICATION : ) EXP : int : EQ_spec #
 857 
#pragma token PROC(EXP : SPECIFICATION :, EXP : SPECIFICATION :) EXP : int : EQ_spec #
874 
#pragma interface NULL_spec IS_NULL_spec EQ_spec
 858 
#pragma interface NULL_spec IS_NULL_spec EQ_spec
875 
 
 859 
 
876 
#pragma token EXP const : SIZE ( SPECIFICATION ) : SIZE_spec #
 860 
#pragma token EXP const : SIZE(SPECIFICATION) : SIZE_spec #
877 
 
 861 
 
878 
#pragma token PROC (\
 862 
#pragma token PROC(\
879 
	EXP : PTR ( SPECIFICATION ) :,\
 863 
	EXP : PTR(SPECIFICATION) :,\
880 
	EXP : SPECIFICATION :\
 864 
	EXP : SPECIFICATION :\
881 
    ) EXP : void : COPY_spec #
 865 
    ) EXP : void : COPY_spec #
882 
 
 866 
 
883 
#pragma token PROC (\
 867 
#pragma token PROC(\
884 
	EXP : PTR ( SPECIFICATION ) :\
 868 
	EXP : PTR(SPECIFICATION) :\
885 
    ) EXP : SPECIFICATION : DEREF_spec #
 869 
    ) EXP : SPECIFICATION : DEREF_spec #
886 
 
 870 
 
887 
#pragma token PROC (\
 871 
#pragma token PROC(\
888 
	EXP : SPECIFICATION :,\
 872 
	EXP : SPECIFICATION :,\
889 
	EXP : LIST ( SPECIFICATION ) :,\
 873 
	EXP : LIST(SPECIFICATION) :,\
890 
	EXP lvalue : LIST ( SPECIFICATION ) :\
 874 
	EXP lvalue : LIST(SPECIFICATION) :\
891 
    ) STATEMENT CONS_spec #
 875 
    ) STATEMENT CONS_spec #
892 
 
 876 
 
893 
#pragma token PROC (\
 877 
#pragma token PROC(\
894 
	EXP lvalue : SPECIFICATION :,\
 878 
	EXP lvalue : SPECIFICATION :,\
895 
	EXP lvalue : LIST ( SPECIFICATION ) :,\
 879 
	EXP lvalue : LIST(SPECIFICATION) :,\
896 
	EXP : LIST ( SPECIFICATION ) :\
 880 
	EXP : LIST(SPECIFICATION) :\
897 
    ) STATEMENT UN_CONS_spec #
 881 
    ) STATEMENT UN_CONS_spec #
898 
 
 882 
 
899 
#pragma token PROC (\
 883 
#pragma token PROC(\
900 
	EXP : DESTROYER :,\
 884 
	EXP : DESTROYER :,\
901 
	EXP lvalue : SPECIFICATION :,\
 885 
	EXP lvalue : SPECIFICATION :,\
902 
	EXP lvalue : LIST ( SPECIFICATION ) :,\
 886 
	EXP lvalue : LIST(SPECIFICATION) :,\
903 
	EXP : LIST ( SPECIFICATION ) :\
 887 
	EXP : LIST(SPECIFICATION) :\
904 
    ) STATEMENT DESTROY_CONS_spec #
 888 
    ) STATEMENT DESTROY_CONS_spec #
905 
 
 889 
 
906 
#pragma token PROC (\
 890 
#pragma token PROC(\
907 
	EXP : SPECIFICATION :,\
 891 
	EXP : SPECIFICATION :,\
908 
	EXP lvalue : STACK ( SPECIFICATION ) :\
 892 
	EXP lvalue : STACK(SPECIFICATION) :\
909 
    ) STATEMENT PUSH_spec #
 893 
    ) STATEMENT PUSH_spec #
910 
 
 894 
 
911 
#pragma token PROC (\
 895 
#pragma token PROC(\
912 
	EXP lvalue : SPECIFICATION :,\
 896 
	EXP lvalue : SPECIFICATION :,\
913 
	EXP lvalue : STACK ( SPECIFICATION ) :\
 897 
	EXP lvalue : STACK(SPECIFICATION) :\
914 
    ) STATEMENT POP_spec #
 898 
    ) STATEMENT POP_spec #
915 
 
 899 
 
916 
#pragma interface SIZE_spec COPY_spec DEREF_spec
 900 
#pragma interface SIZE_spec COPY_spec DEREF_spec
917 
#pragma interface CONS_spec UN_CONS_spec DESTROY_CONS_spec
 901 
#pragma interface CONS_spec UN_CONS_spec DESTROY_CONS_spec
918 
#pragma interface PUSH_spec POP_spec
 902 
#pragma interface PUSH_spec POP_spec
919 
 
 903 
 
920 
 
 904 
 
921 
/* Definitions for union COMMAND */
 905 
/* Definitions for union COMMAND */
922 
 
 906 
 
923 
#define ORDER_cmd ( ( unsigned ) 6 )
 907 
#define ORDER_cmd ((unsigned)6)
924 
#pragma token EXP const : COMMAND : NULL_cmd #
 908 
#pragma token EXP const : COMMAND : NULL_cmd #
925 
#pragma token PROC ( EXP : COMMAND : ) EXP : int : IS_NULL_cmd #
 909 
#pragma token PROC(EXP : COMMAND :) EXP : int : IS_NULL_cmd #
926 
#pragma token PROC ( EXP : COMMAND :, EXP : COMMAND : ) EXP : int : EQ_cmd #
 910 
#pragma token PROC(EXP : COMMAND :, EXP : COMMAND :) EXP : int : EQ_cmd #
927 
#pragma interface NULL_cmd IS_NULL_cmd EQ_cmd
 911 
#pragma interface NULL_cmd IS_NULL_cmd EQ_cmd
928 
 
 912 
 
929 
#pragma token EXP const : SIZE ( COMMAND ) : SIZE_cmd #
 913 
#pragma token EXP const : SIZE(COMMAND) : SIZE_cmd #
930 
 
 914 
 
931 
#pragma token PROC (\
 915 
#pragma token PROC(\
932 
	EXP : PTR ( COMMAND ) :,\
 916 
	EXP : PTR(COMMAND) :,\
933 
	EXP : COMMAND :\
 917 
	EXP : COMMAND :\
934 
    ) EXP : void : COPY_cmd #
 918 
    ) EXP : void : COPY_cmd #
935 
 
 919 
 
936 
#pragma token PROC (\
 920 
#pragma token PROC(\
937 
	EXP : PTR ( COMMAND ) :\
 921 
	EXP : PTR(COMMAND) :\
938 
    ) EXP : COMMAND : DEREF_cmd #
 922 
    ) EXP : COMMAND : DEREF_cmd #
939 
 
 923 
 
940 
#pragma token PROC (\
 924 
#pragma token PROC(\
941 
	EXP : COMMAND :,\
 925 
	EXP : COMMAND :,\
942 
	EXP : LIST ( COMMAND ) :,\
 926 
	EXP : LIST(COMMAND) :,\
943 
	EXP lvalue : LIST ( COMMAND ) :\
 927 
	EXP lvalue : LIST(COMMAND) :\
944 
    ) STATEMENT CONS_cmd #
 928 
    ) STATEMENT CONS_cmd #
945 
 
 929 
 
946 
#pragma token PROC (\
 930 
#pragma token PROC(\
947 
	EXP lvalue : COMMAND :,\
 931 
	EXP lvalue : COMMAND :,\
948 
	EXP lvalue : LIST ( COMMAND ) :,\
 932 
	EXP lvalue : LIST(COMMAND) :,\
949 
	EXP : LIST ( COMMAND ) :\
 933 
	EXP : LIST(COMMAND) :\
950 
    ) STATEMENT UN_CONS_cmd #
 934 
    ) STATEMENT UN_CONS_cmd #
951 
 
 935 
 
952 
#pragma token PROC (\
 936 
#pragma token PROC(\
953 
	EXP : DESTROYER :,\
 937 
	EXP : DESTROYER :,\
954 
	EXP lvalue : COMMAND :,\
 938 
	EXP lvalue : COMMAND :,\
955 
	EXP lvalue : LIST ( COMMAND ) :,\
 939 
	EXP lvalue : LIST(COMMAND) :,\
956 
	EXP : LIST ( COMMAND ) :\
 940 
	EXP : LIST(COMMAND) :\
957 
    ) STATEMENT DESTROY_CONS_cmd #
 941 
    ) STATEMENT DESTROY_CONS_cmd #
958 
 
 942 
 
959 
#pragma token PROC (\
 943 
#pragma token PROC(\
960 
	EXP : COMMAND :,\
 944 
	EXP : COMMAND :,\
961 
	EXP lvalue : STACK ( COMMAND ) :\
 945 
	EXP lvalue : STACK(COMMAND) :\
962 
    ) STATEMENT PUSH_cmd #
 946 
    ) STATEMENT PUSH_cmd #
963 
 
 947 
 
964 
#pragma token PROC (\
 948 
#pragma token PROC(\
965 
	EXP lvalue : COMMAND :,\
 949 
	EXP lvalue : COMMAND :,\
966 
	EXP lvalue : STACK ( COMMAND ) :\
 950 
	EXP lvalue : STACK(COMMAND) :\
967 
    ) STATEMENT POP_cmd #
 951 
    ) STATEMENT POP_cmd #
968 
 
 952 
 
969 
#pragma interface SIZE_cmd COPY_cmd DEREF_cmd
 953 
#pragma interface SIZE_cmd COPY_cmd DEREF_cmd
970 
#pragma interface CONS_cmd UN_CONS_cmd DESTROY_CONS_cmd
 954 
#pragma interface CONS_cmd UN_CONS_cmd DESTROY_CONS_cmd
971 
#pragma interface PUSH_cmd POP_cmd
 955 
#pragma interface PUSH_cmd POP_cmd