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 1... Line 1...
1 
/*
 1 
/*
2 
    		 Crown Copyright (c) 1997
 2 
    		 Crown Copyright (c) 1997
3
3 
 
4 
    This TenDRA(r) Computer Program is subject to Copyright
 4 
    This TenDRA(r) Computer Program is subject to Copyright
5 
    owned by the United Kingdom Secretary of State for Defence
 5 
    owned by the United Kingdom Secretary of State for Defence
6 
    acting through the Defence Evaluation and Research Agency
 6 
    acting through the Defence Evaluation and Research Agency
7 
    (DERA).  It is made available to Recipients with a
 7 
    (DERA).  It is made available to Recipients with a
8 
    royalty-free licence for its use, reproduction, transfer
 8 
    royalty-free licence for its use, reproduction, transfer
9 
    to other parties and amendment for any purpose not excluding
 9 
    to other parties and amendment for any purpose not excluding
10 
    product development provided that any such use et cetera
 10 
    product development provided that any such use et cetera
11 
    shall be deemed to be acceptance of the following conditions:-
 11 
    shall be deemed to be acceptance of the following conditions:-
12
12 
 
13 
        (1) Its Recipients shall ensure that this Notice is
 13 
        (1) Its Recipients shall ensure that this Notice is
14 
        reproduced upon any copies or amended versions of it;
 14 
        reproduced upon any copies or amended versions of it;
15
15 
 
16 
        (2) Any amended version of it shall be clearly marked to
 16 
        (2) Any amended version of it shall be clearly marked to
17 
        show both the nature of and the organisation responsible
 17 
        show both the nature of and the organisation responsible
18 
        for the relevant amendment or amendments;
 18 
        for the relevant amendment or amendments;
19
19 
 
20 
        (3) Its onward transfer from a recipient to another
 20 
        (3) Its onward transfer from a recipient to another
21 
        party shall be deemed to be that party's acceptance of
 21 
        party shall be deemed to be that party's acceptance of
22 
        these conditions;
 22 
        these conditions;
23
23 
 
24 
        (4) DERA gives no warranty or assurance as to its
 24 
        (4) DERA gives no warranty or assurance as to its
25 
        quality or suitability for any purpose and DERA accepts
 25 
        quality or suitability for any purpose and DERA accepts
26 
        no liability whatsoever in relation to any use to which
 26 
        no liability whatsoever in relation to any use to which
27 
        it may be put.
 27 
        it may be put.
28 
*/
 28 
*/
29 
 
 29 
 
30 
/*
 30 
/*
31 
    AUTOMATICALLY GENERATED FROM ALGEBRA errors (VERSION 1.0)
 31 
    AUTOMATICALLY GENERATED FROM ALGEBRA errors (VERSION 1.0)
32 
    BY calculus (VERSION 1.2)
 32 
    BY calculus (VERSION 1.2)
33 
*/
 33 
*/
34 
 
 34 
 
35 
#ifndef ERRORS_H_TOK_INCLUDED
 35 
#ifndef ERRORS_H_TOK_INCLUDED
36 
#define ERRORS_H_TOK_INCLUDED
 36 
#define ERRORS_H_TOK_INCLUDED
37 
 
 37 
 
38 
#ifndef errors_NAME
 38 
#ifndef errors_NAME
39 
#define errors_NAME			"errors"
 39 
#define errors_NAME			"errors"
40 
#define errors_VERSION			"1.0"
 40 
#define errors_VERSION			"1.0"
41 
#define errors_SPECIFICATION		1
 41 
#define errors_SPECIFICATION		1
42 
#define errors_IMPLEMENTATION		0
 42 
#define errors_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 errors_DESTR_DEFINED
 60 
#ifndef errors_DESTR_DEFINED
77 
#define errors_DESTR_DEFINED
 61 
#define errors_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 108... Line 92...
108 
 
 92 
 
109 
 
 93 
 
110 
 
 94 
 
111 
/* Identity type definitions */
 95 
/* Identity type definitions */
112 
 
 96 
 
113 
typedef NAME KEY ;
 97 
typedef NAME KEY;
114 
typedef NAME PROPERTY ;
 98 
typedef NAME PROPERTY;
115 
typedef NAME TYPE ;
 99 
typedef NAME TYPE;
116 
typedef NAME USAGE ;
 100 
typedef NAME USAGE;
117 
 
 101 
 
118 
 
 102 
 
119 
/* Structure definitions */
 103 
/* Structure definitions */
120 
 
 104 
 
121 
#ifndef errors_STRUCT_DEFINED
 105 
#ifndef errors_STRUCT_DEFINED
Line 124... Line 108...
124 
#endif /* errors_STRUCT_DEFINED */
 108 
#endif /* errors_STRUCT_DEFINED */
125 
 
 109 
 
126 
 
 110 
 
127 
/* Function declarations */
 111 
/* Function declarations */
128 
 
 112 
 
129 
extern void destroy_errors () ;
 113 
extern void destroy_errors();
130 
extern void dummy_destroy_errors () ;
 114 
extern void dummy_destroy_errors();
131 
#ifdef errors_IO_ROUTINES
 115 
#ifdef errors_IO_ROUTINES
132 
extern unsigned crt_errors_alias ;
 116 
extern unsigned crt_errors_alias;
133 
extern void clear_errors_alias PROTO_S ( ( void ) ) ;
 117 
extern void clear_errors_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 errors_IO_ROUTINES
 164 
#ifdef errors_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 errors_IO_ROUTINES
 296 
#ifdef errors_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 string */
 493 
/* Definitions for primitive string */
510 
 
 494 
 
511 
#pragma token EXP const : SIZE ( string ) : SIZE_string #
 495 
#pragma token EXP const : SIZE(string) : SIZE_string #
512 
 
 496 
 
513 
#pragma token PROC (\
 497 
#pragma token PROC(\
514 
	EXP : PTR ( string ) :,\
 498 
	EXP : PTR(string) :,\
515 
	EXP : string :\
 499 
	EXP : string :\
516 
    ) EXP : void : COPY_string #
 500 
    ) EXP : void : COPY_string #
517 
 
 501 
 
518 
#pragma token PROC (\
 502 
#pragma token PROC(\
519 
	EXP : PTR ( string ) :\
 503 
	EXP : PTR(string) :\
520 
    ) EXP : string : DEREF_string #
 504 
    ) EXP : string : DEREF_string #
521 
 
 505 
 
522 
#pragma token PROC (\
 506 
#pragma token PROC(\
523 
	EXP : string :,\
 507 
	EXP : string :,\
524 
	EXP : LIST ( string ) :,\
 508 
	EXP : LIST(string) :,\
525 
	EXP lvalue : LIST ( string ) :\
 509 
	EXP lvalue : LIST(string) :\
526 
    ) STATEMENT CONS_string #
 510 
    ) STATEMENT CONS_string #
527 
 
 511 
 
528 
#pragma token PROC (\
 512 
#pragma token PROC(\
529 
	EXP lvalue : string :,\
 513 
	EXP lvalue : string :,\
530 
	EXP lvalue : LIST ( string ) :,\
 514 
	EXP lvalue : LIST(string) :,\
531 
	EXP : LIST ( string ) :\
 515 
	EXP : LIST(string) :\
532 
    ) STATEMENT UN_CONS_string #
 516 
    ) STATEMENT UN_CONS_string #
533 
 
 517 
 
534 
#pragma token PROC (\
 518 
#pragma token PROC(\
535 
	EXP : DESTROYER :,\
 519 
	EXP : DESTROYER :,\
536 
	EXP lvalue : string :,\
 520 
	EXP lvalue : string :,\
537 
	EXP lvalue : LIST ( string ) :,\
 521 
	EXP lvalue : LIST(string) :,\
538 
	EXP : LIST ( string ) :\
 522 
	EXP : LIST(string) :\
539 
    ) STATEMENT DESTROY_CONS_string #
 523 
    ) STATEMENT DESTROY_CONS_string #
540 
 
 524 
 
541 
#pragma token PROC (\
 525 
#pragma token PROC(\
542 
	EXP : string :,\
 526 
	EXP : string :,\
543 
	EXP lvalue : STACK ( string ) :\
 527 
	EXP lvalue : STACK(string) :\
544 
    ) STATEMENT PUSH_string #
 528 
    ) STATEMENT PUSH_string #
545 
 
 529 
 
546 
#pragma token PROC (\
 530 
#pragma token PROC(\
547 
	EXP lvalue : string :,\
 531 
	EXP lvalue : string :,\
548 
	EXP lvalue : STACK ( string ) :\
 532 
	EXP lvalue : STACK(string) :\
549 
    ) STATEMENT POP_string #
 533 
    ) STATEMENT POP_string #
550 
 
 534 
 
551 
#pragma interface SIZE_string COPY_string DEREF_string
 535 
#pragma interface SIZE_string COPY_string DEREF_string
552 
#pragma interface CONS_string UN_CONS_string DESTROY_CONS_string
 536 
#pragma interface CONS_string UN_CONS_string DESTROY_CONS_string
553 
#pragma interface PUSH_string POP_string
 537 
#pragma interface PUSH_string POP_string
554 
 
 538 
 
555 
 
 539 
 
556 
/* Definitions for union NAME */
 540 
/* Definitions for union NAME */
557 
 
 541 
 
558 
#define ORDER_name ( ( unsigned ) 1 )
 542 
#define ORDER_name ((unsigned)1)
559 
#pragma token EXP const : NAME : NULL_name #
 543 
#pragma token EXP const : NAME : NULL_name #
560 
#pragma token PROC ( EXP : NAME : ) EXP : int : IS_NULL_name #
 544 
#pragma token PROC(EXP : NAME :) EXP : int : IS_NULL_name #
561 
#pragma token PROC ( EXP : NAME :, EXP : NAME : ) EXP : int : EQ_name #
 545 
#pragma token PROC(EXP : NAME :, EXP : NAME :) EXP : int : EQ_name #
562 
#pragma interface NULL_name IS_NULL_name EQ_name
 546 
#pragma interface NULL_name IS_NULL_name EQ_name
563 
 
 547 
 
564 
#pragma token EXP const : SIZE ( NAME ) : SIZE_name #
 548 
#pragma token EXP const : SIZE(NAME) : SIZE_name #
565 
 
 549 
 
566 
#pragma token PROC (\
 550 
#pragma token PROC(\
567 
	EXP : PTR ( NAME ) :,\
 551 
	EXP : PTR(NAME) :,\
568 
	EXP : NAME :\
 552 
	EXP : NAME :\
569 
    ) EXP : void : COPY_name #
 553 
    ) EXP : void : COPY_name #
570 
 
 554 
 
571 
#pragma token PROC (\
 555 
#pragma token PROC(\
572 
	EXP : PTR ( NAME ) :\
 556 
	EXP : PTR(NAME) :\
573 
    ) EXP : NAME : DEREF_name #
 557 
    ) EXP : NAME : DEREF_name #
574 
 
 558 
 
575 
#pragma token PROC (\
 559 
#pragma token PROC(\
576 
	EXP : NAME :,\
 560 
	EXP : NAME :,\
577 
	EXP : LIST ( NAME ) :,\
 561 
	EXP : LIST(NAME) :,\
578 
	EXP lvalue : LIST ( NAME ) :\
 562 
	EXP lvalue : LIST(NAME) :\
579 
    ) STATEMENT CONS_name #
 563 
    ) STATEMENT CONS_name #
580 
 
 564 
 
581 
#pragma token PROC (\
 565 
#pragma token PROC(\
582 
	EXP lvalue : NAME :,\
 566 
	EXP lvalue : NAME :,\
583 
	EXP lvalue : LIST ( NAME ) :,\
 567 
	EXP lvalue : LIST(NAME) :,\
584 
	EXP : LIST ( NAME ) :\
 568 
	EXP : LIST(NAME) :\
585 
    ) STATEMENT UN_CONS_name #
 569 
    ) STATEMENT UN_CONS_name #
586 
 
 570 
 
587 
#pragma token PROC (\
 571 
#pragma token PROC(\
588 
	EXP : DESTROYER :,\
 572 
	EXP : DESTROYER :,\
589 
	EXP lvalue : NAME :,\
 573 
	EXP lvalue : NAME :,\
590 
	EXP lvalue : LIST ( NAME ) :,\
 574 
	EXP lvalue : LIST(NAME) :,\
591 
	EXP : LIST ( NAME ) :\
 575 
	EXP : LIST(NAME) :\
592 
    ) STATEMENT DESTROY_CONS_name #
 576 
    ) STATEMENT DESTROY_CONS_name #
593 
 
 577 
 
594 
#pragma token PROC (\
 578 
#pragma token PROC(\
595 
	EXP : NAME :,\
 579 
	EXP : NAME :,\
596 
	EXP lvalue : STACK ( NAME ) :\
 580 
	EXP lvalue : STACK(NAME) :\
597 
    ) STATEMENT PUSH_name #
 581 
    ) STATEMENT PUSH_name #
598 
 
 582 
 
599 
#pragma token PROC (\
 583 
#pragma token PROC(\
600 
	EXP lvalue : NAME :,\
 584 
	EXP lvalue : NAME :,\
601 
	EXP lvalue : STACK ( NAME ) :\
 585 
	EXP lvalue : STACK(NAME) :\
602 
    ) STATEMENT POP_name #
 586 
    ) STATEMENT POP_name #
603 
 
 587 
 
604 
#pragma interface SIZE_name COPY_name DEREF_name
 588 
#pragma interface SIZE_name COPY_name DEREF_name
605 
#pragma interface CONS_name UN_CONS_name DESTROY_CONS_name
 589 
#pragma interface CONS_name UN_CONS_name DESTROY_CONS_name
606 
#pragma interface PUSH_name POP_name
 590 
#pragma interface PUSH_name POP_name
607 
 
 591 
 
608 
 
 592 
 
609 
/* Definitions for union MESSAGE */
 593 
/* Definitions for union MESSAGE */
610 
 
 594 
 
611 
#define ORDER_msg ( ( unsigned ) 2 )
 595 
#define ORDER_msg ((unsigned)2)
612 
#pragma token EXP const : MESSAGE : NULL_msg #
 596 
#pragma token EXP const : MESSAGE : NULL_msg #
613 
#pragma token PROC ( EXP : MESSAGE : ) EXP : int : IS_NULL_msg #
 597 
#pragma token PROC(EXP : MESSAGE :) EXP : int : IS_NULL_msg #
614 
#pragma token PROC ( EXP : MESSAGE :, EXP : MESSAGE : ) EXP : int : EQ_msg #
 598 
#pragma token PROC(EXP : MESSAGE :, EXP : MESSAGE :) EXP : int : EQ_msg #
615 
#pragma interface NULL_msg IS_NULL_msg EQ_msg
 599 
#pragma interface NULL_msg IS_NULL_msg EQ_msg
616 
 
 600 
 
617 
#pragma token EXP const : SIZE ( MESSAGE ) : SIZE_msg #
 601 
#pragma token EXP const : SIZE(MESSAGE) : SIZE_msg #
618 
 
 602 
 
619 
#pragma token PROC (\
 603 
#pragma token PROC(\
620 
	EXP : PTR ( MESSAGE ) :,\
 604 
	EXP : PTR(MESSAGE) :,\
621 
	EXP : MESSAGE :\
 605 
	EXP : MESSAGE :\
622 
    ) EXP : void : COPY_msg #
 606 
    ) EXP : void : COPY_msg #
623 
 
 607 
 
624 
#pragma token PROC (\
 608 
#pragma token PROC(\
625 
	EXP : PTR ( MESSAGE ) :\
 609 
	EXP : PTR(MESSAGE) :\
626 
    ) EXP : MESSAGE : DEREF_msg #
 610 
    ) EXP : MESSAGE : DEREF_msg #
627 
 
 611 
 
628 
#pragma token PROC (\
 612 
#pragma token PROC(\
629 
	EXP : MESSAGE :,\
 613 
	EXP : MESSAGE :,\
630 
	EXP : LIST ( MESSAGE ) :,\
 614 
	EXP : LIST(MESSAGE) :,\
631 
	EXP lvalue : LIST ( MESSAGE ) :\
 615 
	EXP lvalue : LIST(MESSAGE) :\
632 
    ) STATEMENT CONS_msg #
 616 
    ) STATEMENT CONS_msg #
633 
 
 617 
 
634 
#pragma token PROC (\
 618 
#pragma token PROC(\
635 
	EXP lvalue : MESSAGE :,\
 619 
	EXP lvalue : MESSAGE :,\
636 
	EXP lvalue : LIST ( MESSAGE ) :,\
 620 
	EXP lvalue : LIST(MESSAGE) :,\
637 
	EXP : LIST ( MESSAGE ) :\
 621 
	EXP : LIST(MESSAGE) :\
638 
    ) STATEMENT UN_CONS_msg #
 622 
    ) STATEMENT UN_CONS_msg #
639 
 
 623 
 
640 
#pragma token PROC (\
 624 
#pragma token PROC(\
641 
	EXP : DESTROYER :,\
 625 
	EXP : DESTROYER :,\
642 
	EXP lvalue : MESSAGE :,\
 626 
	EXP lvalue : MESSAGE :,\
643 
	EXP lvalue : LIST ( MESSAGE ) :,\
 627 
	EXP lvalue : LIST(MESSAGE) :,\
644 
	EXP : LIST ( MESSAGE ) :\
 628 
	EXP : LIST(MESSAGE) :\
645 
    ) STATEMENT DESTROY_CONS_msg #
 629 
    ) STATEMENT DESTROY_CONS_msg #
646 
 
 630 
 
647 
#pragma token PROC (\
 631 
#pragma token PROC(\
648 
	EXP : MESSAGE :,\
 632 
	EXP : MESSAGE :,\
649 
	EXP lvalue : STACK ( MESSAGE ) :\
 633 
	EXP lvalue : STACK(MESSAGE) :\
650 
    ) STATEMENT PUSH_msg #
 634 
    ) STATEMENT PUSH_msg #
651 
 
 635 
 
652 
#pragma token PROC (\
 636 
#pragma token PROC(\
653 
	EXP lvalue : MESSAGE :,\
 637 
	EXP lvalue : MESSAGE :,\
654 
	EXP lvalue : STACK ( MESSAGE ) :\
 638 
	EXP lvalue : STACK(MESSAGE) :\
655 
    ) STATEMENT POP_msg #
 639 
    ) STATEMENT POP_msg #
656 
 
 640 
 
657 
#pragma interface SIZE_msg COPY_msg DEREF_msg
 641 
#pragma interface SIZE_msg COPY_msg DEREF_msg
658 
#pragma interface CONS_msg UN_CONS_msg DESTROY_CONS_msg
 642 
#pragma interface CONS_msg UN_CONS_msg DESTROY_CONS_msg
659 
#pragma interface PUSH_msg POP_msg
 643 
#pragma interface PUSH_msg POP_msg
660 
 
 644 
 
661 
 
 645 
 
662 
/* Definitions for union MAP */
 646 
/* Definitions for union MAP */
663 
 
 647 
 
664 
#define ORDER_map ( ( unsigned ) 1 )
 648 
#define ORDER_map ((unsigned)1)
665 
#pragma token EXP const : MAP : NULL_map #
 649 
#pragma token EXP const : MAP : NULL_map #
666 
#pragma token PROC ( EXP : MAP : ) EXP : int : IS_NULL_map #
 650 
#pragma token PROC(EXP : MAP :) EXP : int : IS_NULL_map #
667 
#pragma token PROC ( EXP : MAP :, EXP : MAP : ) EXP : int : EQ_map #
 651 
#pragma token PROC(EXP : MAP :, EXP : MAP :) EXP : int : EQ_map #
668 
#pragma interface NULL_map IS_NULL_map EQ_map
 652 
#pragma interface NULL_map IS_NULL_map EQ_map
669 
 
 653 
 
670 
#pragma token EXP const : SIZE ( MAP ) : SIZE_map #
 654 
#pragma token EXP const : SIZE(MAP) : SIZE_map #
671 
 
 655 
 
672 
#pragma token PROC (\
 656 
#pragma token PROC(\
673 
	EXP : PTR ( MAP ) :,\
 657 
	EXP : PTR(MAP) :,\
674 
	EXP : MAP :\
 658 
	EXP : MAP :\
675 
    ) EXP : void : COPY_map #
 659 
    ) EXP : void : COPY_map #
676 
 
 660 
 
677 
#pragma token PROC (\
 661 
#pragma token PROC(\
678 
	EXP : PTR ( MAP ) :\
 662 
	EXP : PTR(MAP) :\
679 
    ) EXP : MAP : DEREF_map #
 663 
    ) EXP : MAP : DEREF_map #
680 
 
 664 
 
681 
#pragma token PROC (\
 665 
#pragma token PROC(\
682 
	EXP : MAP :,\
 666 
	EXP : MAP :,\
683 
	EXP : LIST ( MAP ) :,\
 667 
	EXP : LIST(MAP) :,\
684 
	EXP lvalue : LIST ( MAP ) :\
 668 
	EXP lvalue : LIST(MAP) :\
685 
    ) STATEMENT CONS_map #
 669 
    ) STATEMENT CONS_map #
686 
 
 670 
 
687 
#pragma token PROC (\
 671 
#pragma token PROC(\
688 
	EXP lvalue : MAP :,\
 672 
	EXP lvalue : MAP :,\
689 
	EXP lvalue : LIST ( MAP ) :,\
 673 
	EXP lvalue : LIST(MAP) :,\
690 
	EXP : LIST ( MAP ) :\
 674 
	EXP : LIST(MAP) :\
691 
    ) STATEMENT UN_CONS_map #
 675 
    ) STATEMENT UN_CONS_map #
692 
 
 676 
 
693 
#pragma token PROC (\
 677 
#pragma token PROC(\
694 
	EXP : DESTROYER :,\
 678 
	EXP : DESTROYER :,\
695 
	EXP lvalue : MAP :,\
 679 
	EXP lvalue : MAP :,\
696 
	EXP lvalue : LIST ( MAP ) :,\
 680 
	EXP lvalue : LIST(MAP) :,\
697 
	EXP : LIST ( MAP ) :\
 681 
	EXP : LIST(MAP) :\
698 
    ) STATEMENT DESTROY_CONS_map #
 682 
    ) STATEMENT DESTROY_CONS_map #
699 
 
 683 
 
700 
#pragma token PROC (\
 684 
#pragma token PROC(\
701 
	EXP : MAP :,\
 685 
	EXP : MAP :,\
702 
	EXP lvalue : STACK ( MAP ) :\
 686 
	EXP lvalue : STACK(MAP) :\
703 
    ) STATEMENT PUSH_map #
 687 
    ) STATEMENT PUSH_map #
704 
 
 688 
 
705 
#pragma token PROC (\
 689 
#pragma token PROC(\
706 
	EXP lvalue : MAP :,\
 690 
	EXP lvalue : MAP :,\
707 
	EXP lvalue : STACK ( MAP ) :\
 691 
	EXP lvalue : STACK(MAP) :\
708 
    ) STATEMENT POP_map #
 692 
    ) STATEMENT POP_map #
709 
 
 693 
 
710 
#pragma interface SIZE_map COPY_map DEREF_map
 694 
#pragma interface SIZE_map COPY_map DEREF_map
711 
#pragma interface CONS_map UN_CONS_map DESTROY_CONS_map
 695 
#pragma interface CONS_map UN_CONS_map DESTROY_CONS_map
712 
#pragma interface PUSH_map POP_map
 696 
#pragma interface PUSH_map POP_map
713 
 
 697 
 
714 
 
 698 
 
715 
/* Definitions for union PARAM */
 699 
/* Definitions for union PARAM */
716 
 
 700 
 
717 
#define ORDER_param ( ( unsigned ) 1 )
 701 
#define ORDER_param ((unsigned)1)
718 
#pragma token EXP const : PARAM : NULL_param #
 702 
#pragma token EXP const : PARAM : NULL_param #
719 
#pragma token PROC ( EXP : PARAM : ) EXP : int : IS_NULL_param #
 703 
#pragma token PROC(EXP : PARAM :) EXP : int : IS_NULL_param #
720 
#pragma token PROC ( EXP : PARAM :, EXP : PARAM : ) EXP : int : EQ_param #
 704 
#pragma token PROC(EXP : PARAM :, EXP : PARAM :) EXP : int : EQ_param #
721 
#pragma interface NULL_param IS_NULL_param EQ_param
 705 
#pragma interface NULL_param IS_NULL_param EQ_param
722 
 
 706 
 
723 
#pragma token EXP const : SIZE ( PARAM ) : SIZE_param #
 707 
#pragma token EXP const : SIZE(PARAM) : SIZE_param #
724 
 
 708 
 
725 
#pragma token PROC (\
 709 
#pragma token PROC(\
726 
	EXP : PTR ( PARAM ) :,\
 710 
	EXP : PTR(PARAM) :,\
727 
	EXP : PARAM :\
 711 
	EXP : PARAM :\
728 
    ) EXP : void : COPY_param #
 712 
    ) EXP : void : COPY_param #
729 
 
 713 
 
730 
#pragma token PROC (\
 714 
#pragma token PROC(\
731 
	EXP : PTR ( PARAM ) :\
 715 
	EXP : PTR(PARAM) :\
732 
    ) EXP : PARAM : DEREF_param #
 716 
    ) EXP : PARAM : DEREF_param #
733 
 
 717 
 
734 
#pragma token PROC (\
 718 
#pragma token PROC(\
735 
	EXP : PARAM :,\
 719 
	EXP : PARAM :,\
736 
	EXP : LIST ( PARAM ) :,\
 720 
	EXP : LIST(PARAM) :,\
737 
	EXP lvalue : LIST ( PARAM ) :\
 721 
	EXP lvalue : LIST(PARAM) :\
738 
    ) STATEMENT CONS_param #
 722 
    ) STATEMENT CONS_param #
739 
 
 723 
 
740 
#pragma token PROC (\
 724 
#pragma token PROC(\
741 
	EXP lvalue : PARAM :,\
 725 
	EXP lvalue : PARAM :,\
742 
	EXP lvalue : LIST ( PARAM ) :,\
 726 
	EXP lvalue : LIST(PARAM) :,\
743 
	EXP : LIST ( PARAM ) :\
 727 
	EXP : LIST(PARAM) :\
744 
    ) STATEMENT UN_CONS_param #
 728 
    ) STATEMENT UN_CONS_param #
745 
 
 729 
 
746 
#pragma token PROC (\
 730 
#pragma token PROC(\
747 
	EXP : DESTROYER :,\
 731 
	EXP : DESTROYER :,\
748 
	EXP lvalue : PARAM :,\
 732 
	EXP lvalue : PARAM :,\
749 
	EXP lvalue : LIST ( PARAM ) :,\
 733 
	EXP lvalue : LIST(PARAM) :,\
750 
	EXP : LIST ( PARAM ) :\
 734 
	EXP : LIST(PARAM) :\
751 
    ) STATEMENT DESTROY_CONS_param #
 735 
    ) STATEMENT DESTROY_CONS_param #
752 
 
 736 
 
753 
#pragma token PROC (\
 737 
#pragma token PROC(\
754 
	EXP : PARAM :,\
 738 
	EXP : PARAM :,\
755 
	EXP lvalue : STACK ( PARAM ) :\
 739 
	EXP lvalue : STACK(PARAM) :\
756 
    ) STATEMENT PUSH_param #
 740 
    ) STATEMENT PUSH_param #
757 
 
 741 
 
758 
#pragma token PROC (\
 742 
#pragma token PROC(\
759 
	EXP lvalue : PARAM :,\
 743 
	EXP lvalue : PARAM :,\
760 
	EXP lvalue : STACK ( PARAM ) :\
 744 
	EXP lvalue : STACK(PARAM) :\
761 
    ) STATEMENT POP_param #
 745 
    ) STATEMENT POP_param #
762 
 
 746 
 
763 
#pragma interface SIZE_param COPY_param DEREF_param
 747 
#pragma interface SIZE_param COPY_param DEREF_param
764 
#pragma interface CONS_param UN_CONS_param DESTROY_CONS_param
 748 
#pragma interface CONS_param UN_CONS_param DESTROY_CONS_param
765 
#pragma interface PUSH_param POP_param
 749 
#pragma interface PUSH_param POP_param
766 
 
 750 
 
767 
 
 751 
 
768 
/* Definitions for union ENTRY */
 752 
/* Definitions for union ENTRY */
769 
 
 753 
 
770 
#define ORDER_entry ( ( unsigned ) 1 )
 754 
#define ORDER_entry ((unsigned)1)
771 
#pragma token EXP const : ENTRY : NULL_entry #
 755 
#pragma token EXP const : ENTRY : NULL_entry #
772 
#pragma token PROC ( EXP : ENTRY : ) EXP : int : IS_NULL_entry #
 756 
#pragma token PROC(EXP : ENTRY :) EXP : int : IS_NULL_entry #
773 
#pragma token PROC ( EXP : ENTRY :, EXP : ENTRY : ) EXP : int : EQ_entry #
 757 
#pragma token PROC(EXP : ENTRY :, EXP : ENTRY :) EXP : int : EQ_entry #
774 
#pragma interface NULL_entry IS_NULL_entry EQ_entry
 758 
#pragma interface NULL_entry IS_NULL_entry EQ_entry
775 
 
 759 
 
776 
#pragma token EXP const : SIZE ( ENTRY ) : SIZE_entry #
 760 
#pragma token EXP const : SIZE(ENTRY) : SIZE_entry #
777 
 
 761 
 
778 
#pragma token PROC (\
 762 
#pragma token PROC(\
779 
	EXP : PTR ( ENTRY ) :,\
 763 
	EXP : PTR(ENTRY) :,\
780 
	EXP : ENTRY :\
 764 
	EXP : ENTRY :\
781 
    ) EXP : void : COPY_entry #
 765 
    ) EXP : void : COPY_entry #
782 
 
 766 
 
783 
#pragma token PROC (\
 767 
#pragma token PROC(\
784 
	EXP : PTR ( ENTRY ) :\
 768 
	EXP : PTR(ENTRY) :\
785 
    ) EXP : ENTRY : DEREF_entry #
 769 
    ) EXP : ENTRY : DEREF_entry #
786 
 
 770 
 
787 
#pragma token PROC (\
 771 
#pragma token PROC(\
788 
	EXP : ENTRY :,\
 772 
	EXP : ENTRY :,\
789 
	EXP : LIST ( ENTRY ) :,\
 773 
	EXP : LIST(ENTRY) :,\
790 
	EXP lvalue : LIST ( ENTRY ) :\
 774 
	EXP lvalue : LIST(ENTRY) :\
791 
    ) STATEMENT CONS_entry #
 775 
    ) STATEMENT CONS_entry #
792 
 
 776 
 
793 
#pragma token PROC (\
 777 
#pragma token PROC(\
794 
	EXP lvalue : ENTRY :,\
 778 
	EXP lvalue : ENTRY :,\
795 
	EXP lvalue : LIST ( ENTRY ) :,\
 779 
	EXP lvalue : LIST(ENTRY) :,\
796 
	EXP : LIST ( ENTRY ) :\
 780 
	EXP : LIST(ENTRY) :\
797 
    ) STATEMENT UN_CONS_entry #
 781 
    ) STATEMENT UN_CONS_entry #
798 
 
 782 
 
799 
#pragma token PROC (\
 783 
#pragma token PROC(\
800 
	EXP : DESTROYER :,\
 784 
	EXP : DESTROYER :,\
801 
	EXP lvalue : ENTRY :,\
 785 
	EXP lvalue : ENTRY :,\
802 
	EXP lvalue : LIST ( ENTRY ) :,\
 786 
	EXP lvalue : LIST(ENTRY) :,\
803 
	EXP : LIST ( ENTRY ) :\
 787 
	EXP : LIST(ENTRY) :\
804 
    ) STATEMENT DESTROY_CONS_entry #
 788 
    ) STATEMENT DESTROY_CONS_entry #
805 
 
 789 
 
806 
#pragma token PROC (\
 790 
#pragma token PROC(\
807 
	EXP : ENTRY :,\
 791 
	EXP : ENTRY :,\
808 
	EXP lvalue : STACK ( ENTRY ) :\
 792 
	EXP lvalue : STACK(ENTRY) :\
809 
    ) STATEMENT PUSH_entry #
 793 
    ) STATEMENT PUSH_entry #
810 
 
 794 
 
811 
#pragma token PROC (\
 795 
#pragma token PROC(\
812 
	EXP lvalue : ENTRY :,\
 796 
	EXP lvalue : ENTRY :,\
813 
	EXP lvalue : STACK ( ENTRY ) :\
 797 
	EXP lvalue : STACK(ENTRY) :\
814 
    ) STATEMENT POP_entry #
 798 
    ) STATEMENT POP_entry #
815 
 
 799 
 
816 
#pragma interface SIZE_entry COPY_entry DEREF_entry
 800 
#pragma interface SIZE_entry COPY_entry DEREF_entry
817 
#pragma interface CONS_entry UN_CONS_entry DESTROY_CONS_entry
 801 
#pragma interface CONS_entry UN_CONS_entry DESTROY_CONS_entry
818 
#pragma interface PUSH_entry POP_entry
 802 
#pragma interface PUSH_entry POP_entry