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 -... Line 1...
- 
 
 1 
/*
- 
 
 2 
 * Copyright (c) 2002-2005 The TenDRA Project <http://www.tendra.org/>.
- 
 
 3 
 * All rights reserved.
- 
 
 4 
 *
- 
 
 5 
 * Redistribution and use in source and binary forms, with or without
- 
 
 6 
 * modification, are permitted provided that the following conditions are met:
- 
 
 7 
 *
- 
 
 8 
 * 1. Redistributions of source code must retain the above copyright notice,
- 
 
 9 
 *    this list of conditions and the following disclaimer.
- 
 
 10 
 * 2. Redistributions in binary form must reproduce the above copyright notice,
- 
 
 11 
 *    this list of conditions and the following disclaimer in the documentation
- 
 
 12 
 *    and/or other materials provided with the distribution.
- 
 
 13 
 * 3. Neither the name of The TenDRA Project nor the names of its contributors
- 
 
 14 
 *    may be used to endorse or promote products derived from this software
- 
 
 15 
 *    without specific, prior written permission.
- 
 
 16 
 *
- 
 
 17 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
- 
 
 18 
 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- 
 
 19 
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- 
 
 20 
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
- 
 
 21 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- 
 
 22 
 * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- 
 
 23 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- 
 
 24 
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- 
 
 25 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- 
 
 26 
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- 
 
 27 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
 
 28 
 *
- 
 
 29 
 * $Id$
- 
 
 30 
 */
1 
/*
 31 
/*
2 
    		 Crown Copyright (c) 1997
 32 
    		 Crown Copyright (c) 1997
3
33 
 
4 
    This TenDRA(r) Computer Program is subject to Copyright
 34 
    This TenDRA(r) Computer Program is subject to Copyright
5 
    owned by the United Kingdom Secretary of State for Defence
 35 
    owned by the United Kingdom Secretary of State for Defence
6 
    acting through the Defence Evaluation and Research Agency
 36 
    acting through the Defence Evaluation and Research Agency
7 
    (DERA).  It is made available to Recipients with a
 37 
    (DERA).  It is made available to Recipients with a
8 
    royalty-free licence for its use, reproduction, transfer
 38 
    royalty-free licence for its use, reproduction, transfer
9 
    to other parties and amendment for any purpose not excluding
 39 
    to other parties and amendment for any purpose not excluding
10 
    product development provided that any such use et cetera
 40 
    product development provided that any such use et cetera
11 
    shall be deemed to be acceptance of the following conditions:-
 41 
    shall be deemed to be acceptance of the following conditions:-
12
42 
 
13 
        (1) Its Recipients shall ensure that this Notice is
 43 
        (1) Its Recipients shall ensure that this Notice is
14 
        reproduced upon any copies or amended versions of it;
 44 
        reproduced upon any copies or amended versions of it;
15
45 
 
16 
        (2) Any amended version of it shall be clearly marked to
 46 
        (2) Any amended version of it shall be clearly marked to
17 
        show both the nature of and the organisation responsible
 47 
        show both the nature of and the organisation responsible
18 
        for the relevant amendment or amendments;
 48 
        for the relevant amendment or amendments;
19
49 
 
20 
        (3) Its onward transfer from a recipient to another
 50 
        (3) Its onward transfer from a recipient to another
21 
        party shall be deemed to be that party's acceptance of
 51 
        party shall be deemed to be that party's acceptance of
22 
        these conditions;
 52 
        these conditions;
23
53 
 
24 
        (4) DERA gives no warranty or assurance as to its
 54 
        (4) DERA gives no warranty or assurance as to its
25 
        quality or suitability for any purpose and DERA accepts
 55 
        quality or suitability for any purpose and DERA accepts
26 
        no liability whatsoever in relation to any use to which
 56 
        no liability whatsoever in relation to any use to which
27 
        it may be put.
 57 
        it may be put.
28 
*/
 58 
*/
29 
 
 59 
 
30 
 
 60 
 
31 
/* AUTOMATICALLY GENERATED BY make_tdf VERSION 2.0 FROM TDF 4.1 */
 61 
/* AUTOMATICALLY GENERATED BY make_tdf VERSION 2.0 FROM TDF 4.1 */
32 
 
 62 
 
33 
#define sub0( X )	( ( X )->son )
 63 
#define sub0(X)	((X)->son)
34 
#define sub1( X )	( ( X )->son->bro )
 64 
#define sub1(X)	((X)->son->bro)
35 
#define sub2( X )	( ( X )->son->bro->bro )
 65 
#define sub2(X)	((X)->son->bro->bro)
36 
#define sub3( X )	( ( X )->son->bro->bro->bro )
 66 
#define sub3(X)	((X)->son->bro->bro->bro)
37 
#define sub4( X )	( ( X )->son->bro->bro->bro->bro )
 67 
#define sub4(X)	((X)->son->bro->bro->bro->bro)
38 
#define sub5( X )	( ( X )->son->bro->bro->bro->bro->bro )
 68 
#define sub5(X)	((X)->son->bro->bro->bro->bro->bro)
39 
#define sub6( X )	( ( X )->son->bro->bro->bro->bro->bro->bro )
 69 
#define sub6(X)	((X)->son->bro->bro->bro->bro->bro->bro)
40 
#define sub7( X )	( ( X )->son->bro->bro->bro->bro->bro->bro->bro )
 70 
#define sub7(X)	((X)->son->bro->bro->bro->bro->bro->bro->bro)
41 
 
 71 
 
42 
 
 72 
 
43 
/*
 73 
/*
44 
    SET THE SHAPE OF AN EXPRESSION
 74 
    SET THE SHAPE OF AN EXPRESSION
45 
 
 75 
 
46 
    The shape of the expression exp is calculated and assigned.  Most of
 76 
    The shape of the expression exp is calculated and assigned.  Most of
47 
    the work is done by the check routines above, as selected by an
 77 
    the work is done by the check routines above, as selected by an
48 
    automatically generated switch statement.
 78 
    automatically generated switch statement.
49 
*/
 79 
*/
50 
 
 80 
 
51 
void check_exp_fn
 81 
void
52 
    PROTO_N ( ( exp ) )
 - 
 
53 
    PROTO_T ( node *exp )
 82 
check_exp_fn(node *exp)
54 
{
 83 
{
55 
    long m ;
 84 
    long m;
56 
    if ( exp == null ) return ;
 85 
    if (exp == null) {
57 
    m = exp->cons->encoding ;
 - 
 
58 
    if ( m == ENC_labelled ) {
 - 
 
59 
	node *placelabs_intro = sub0 ( exp ) ;
 - 
 
60 
	node *places = sub2 ( exp ) ;
 - 
 
61 
	if ( placelabs_intro->cons->encoding != places->cons->encoding ) {
 - 
 
62 
	    input_error ( "Labels don't match exps in labelled" ) ;
 - 
 
63 
	}
 86 
	return;
64 
    }
 87 
    }
- 
 
 88 
    m = exp->cons->encoding;
- 
 
 89 
    if (m == ENC_labelled) {
- 
 
 90 
	node *placelabs_intro = sub0(exp);
- 
 
 91 
	node *places = sub2(exp);
- 
 
 92 
	if (placelabs_intro->cons->encoding != places->cons->encoding) {
- 
 
 93 
	    input_error("Labels don't match exps in labelled");
- 
 
 94 
	}
- 
 
 95 
    }
65 
    if ( do_check ) {
 96 
    if (do_check) {
66 
	if ( exp->shape ) return ;
 97 
	if (exp->shape) {
- 
 
 98 
	    return;
- 
 
 99 
	}
67 
	checking = exp->cons->name ;
 100 
	checking = exp->cons->name;
68 
	switch ( m ) {
 101 
	switch (m) {
69 
	    case ENC_exp_apply_token : {
 102 
	    case ENC_exp_apply_token: {
70 
		CHECK_exp_apply_token
 103 
		CHECK_exp_apply_token
71 
		break ;
 104 
		break;
72 
	    }
 105 
	    }
73 
	    case ENC_exp_cond : {
 106 
	    case ENC_exp_cond: {
74 
		node *control = sub0 ( exp ) ;
 107 
		node *control = sub0(exp);
75 
		CHECK_exp_cond
 108 
		CHECK_exp_cond
76 
		break ;
 109 
		break;
77 
	    }
 110 
	    }
78 
	    case ENC_abs : {
 111 
	    case ENC_abs: {
79 
		node *arg1 = sub1 ( exp ) ;
 112 
		node *arg1 = sub1(exp);
80 
		CHECK_abs
 113 
		CHECK_abs
81 
		break ;
 114 
		break;
82 
	    }
 115 
	    }
83 
	    case ENC_add_to_ptr : {
 116 
	    case ENC_add_to_ptr: {
84 
		node *arg1 = sub0 ( exp ) ;
 117 
		node *arg1 = sub0(exp);
85 
		node *arg2 = sub1 ( exp ) ;
 118 
		node *arg2 = sub1(exp);
86 
		CHECK_add_to_ptr
 119 
		CHECK_add_to_ptr
87 
		break ;
 120 
		break;
88 
	    }
 121 
	    }
89 
	    case ENC_and : {
 122 
	    case ENC_and: {
90 
		node *arg1 = sub0 ( exp ) ;
 123 
		node *arg1 = sub0(exp);
91 
		node *arg2 = sub1 ( exp ) ;
 124 
		node *arg2 = sub1(exp);
92 
		CHECK_and
 125 
		CHECK_and
93 
		break ;
 126 
		break;
94 
	    }
 127 
	    }
95 
	    case ENC_apply_proc : {
 128 
	    case ENC_apply_proc: {
96 
		node *result_shape = sub0 ( exp ) ;
 129 
		node *result_shape = sub0(exp);
97 
		node *p = sub1 ( exp ) ;
 130 
		node *p = sub1(exp);
98 
		node *params = sub2 ( exp ) ;
 131 
		node *params = sub2(exp);
99 
		node *var_param = sub3 ( exp ) ;
 132 
		node *var_param = sub3(exp);
100 
		CHECK_apply_proc
 133 
		CHECK_apply_proc
101 
		break ;
 134 
		break;
102 
	    }
 135 
	    }
103 
	    case ENC_apply_general_proc : {
 136 
	    case ENC_apply_general_proc: {
104 
		node *result_shape = sub0 ( exp ) ;
 137 
		node *result_shape = sub0(exp);
105 
		node *p = sub2 ( exp ) ;
 138 
		node *p = sub2(exp);
106 
		node *postlude = sub5 ( exp ) ;
 139 
		node *postlude = sub5(exp);
107 
		CHECK_apply_general_proc
 140 
		CHECK_apply_general_proc
108 
		break ;
 141 
		break;
109 
	    }
 142 
	    }
110 
	    case ENC_assign : {
 143 
	    case ENC_assign: {
111 
		node *arg1 = sub0 ( exp ) ;
 144 
		node *arg1 = sub0(exp);
112 
		node *arg2 = sub1 ( exp ) ;
 145 
		node *arg2 = sub1(exp);
113 
		CHECK_assign
 146 
		CHECK_assign
114 
		break ;
 147 
		break;
115 
	    }
 148 
	    }
116 
	    case ENC_assign_with_mode : {
 149 
	    case ENC_assign_with_mode: {
117 
		node *arg1 = sub1 ( exp ) ;
 150 
		node *arg1 = sub1(exp);
118 
		node *arg2 = sub2 ( exp ) ;
 151 
		node *arg2 = sub2(exp);
119 
		CHECK_assign_with_mode
 152 
		CHECK_assign_with_mode
120 
		break ;
 153 
		break;
121 
	    }
 154 
	    }
122 
	    case ENC_bitfield_assign : {
 155 
	    case ENC_bitfield_assign: {
123 
		node *arg1 = sub0 ( exp ) ;
 156 
		node *arg1 = sub0(exp);
124 
		node *arg2 = sub1 ( exp ) ;
 157 
		node *arg2 = sub1(exp);
125 
		node *arg3 = sub2 ( exp ) ;
 158 
		node *arg3 = sub2(exp);
126 
		CHECK_bitfield_assign
 159 
		CHECK_bitfield_assign
127 
		break ;
 160 
		break;
128 
	    }
 161 
	    }
129 
	    case ENC_bitfield_assign_with_mode : {
 162 
	    case ENC_bitfield_assign_with_mode: {
130 
		node *arg1 = sub1 ( exp ) ;
 163 
		node *arg1 = sub1(exp);
131 
		node *arg2 = sub2 ( exp ) ;
 164 
		node *arg2 = sub2(exp);
132 
		node *arg3 = sub3 ( exp ) ;
 165 
		node *arg3 = sub3(exp);
133 
		CHECK_bitfield_assign_with_mode
 166 
		CHECK_bitfield_assign_with_mode
134 
		break ;
 167 
		break;
135 
	    }
 168 
	    }
136 
	    case ENC_bitfield_contents : {
 169 
	    case ENC_bitfield_contents: {
137 
		node *v = sub0 ( exp ) ;
 170 
		node *v = sub0(exp);
138 
		node *arg1 = sub1 ( exp ) ;
 171 
		node *arg1 = sub1(exp);
139 
		node *arg2 = sub2 ( exp ) ;
 172 
		node *arg2 = sub2(exp);
140 
		CHECK_bitfield_contents
 173 
		CHECK_bitfield_contents
141 
		break ;
 174 
		break;
142 
	    }
 175 
	    }
143 
	    case ENC_bitfield_contents_with_mode : {
 176 
	    case ENC_bitfield_contents_with_mode: {
144 
		node *v = sub1 ( exp ) ;
 177 
		node *v = sub1(exp);
145 
		node *arg1 = sub2 ( exp ) ;
 178 
		node *arg1 = sub2(exp);
146 
		node *arg2 = sub3 ( exp ) ;
 179 
		node *arg2 = sub3(exp);
147 
		CHECK_bitfield_contents_with_mo
 180 
		CHECK_bitfield_contents_with_mo
148 
		break ;
 181 
		break;
149 
	    }
 182 
	    }
150 
	    case ENC_case : {
 183 
	    case ENC_case: {
151 
		node *exhaustive = sub0 ( exp ) ;
 184 
		node *exhaustive = sub0(exp);
152 
		node *control = sub1 ( exp ) ;
 185 
		node *control = sub1(exp);
153 
		CHECK_case
 186 
		CHECK_case
154 
		break ;
 187 
		break;
155 
	    }
 188 
	    }
156 
	    case ENC_change_bitfield_to_int : {
 189 
	    case ENC_change_bitfield_to_int: {
157 
		node *v = sub0 ( exp ) ;
 190 
		node *v = sub0(exp);
158 
		node *arg1 = sub1 ( exp ) ;
 191 
		node *arg1 = sub1(exp);
159 
		CHECK_change_bitfield_to_int
 192 
		CHECK_change_bitfield_to_int
160 
		break ;
 193 
		break;
161 
	    }
 194 
	    }
162 
	    case ENC_change_floating_variety : {
 195 
	    case ENC_change_floating_variety: {
163 
		node *r = sub1 ( exp ) ;
 196 
		node *r = sub1(exp);
164 
		node *arg1 = sub2 ( exp ) ;
 197 
		node *arg1 = sub2(exp);
165 
		CHECK_change_floating_variety
 198 
		CHECK_change_floating_variety
166 
		break ;
 199 
		break;
167 
	    }
 200 
	    }
168 
	    case ENC_change_variety : {
 201 
	    case ENC_change_variety: {
169 
		node *r = sub1 ( exp ) ;
 202 
		node *r = sub1(exp);
170 
		node *arg1 = sub2 ( exp ) ;
 203 
		node *arg1 = sub2(exp);
171 
		CHECK_change_variety
 204 
		CHECK_change_variety
172 
		break ;
 205 
		break;
173 
	    }
 206 
	    }
174 
	    case ENC_change_int_to_bitfield : {
 207 
	    case ENC_change_int_to_bitfield: {
175 
		node *bv = sub0 ( exp ) ;
 208 
		node *bv = sub0(exp);
176 
		node *arg1 = sub1 ( exp ) ;
 209 
		node *arg1 = sub1(exp);
177 
		CHECK_change_int_to_bitfield
 210 
		CHECK_change_int_to_bitfield
178 
		break ;
 211 
		break;
179 
	    }
 212 
	    }
180 
	    case ENC_complex_conjugate : {
 213 
	    case ENC_complex_conjugate: {
181 
		node *c = sub0 ( exp ) ;
 214 
		node *c = sub0(exp);
182 
		CHECK_complex_conjugate
 215 
		CHECK_complex_conjugate
183 
		break ;
 216 
		break;
184 
	    }
 217 
	    }
185 
	    case ENC_component : {
 218 
	    case ENC_component: {
186 
		node *sha = sub0 ( exp ) ;
 219 
		node *sha = sub0(exp);
187 
		node *arg1 = sub1 ( exp ) ;
 220 
		node *arg1 = sub1(exp);
188 
		node *arg2 = sub2 ( exp ) ;
 221 
		node *arg2 = sub2(exp);
189 
		CHECK_component
 222 
		CHECK_component
190 
		break ;
 223 
		break;
191 
	    }
 224 
	    }
192 
	    case ENC_concat_nof : {
 225 
	    case ENC_concat_nof: {
193 
		node *arg1 = sub0 ( exp ) ;
 226 
		node *arg1 = sub0(exp);
194 
		node *arg2 = sub1 ( exp ) ;
 227 
		node *arg2 = sub1(exp);
195 
		CHECK_concat_nof
 228 
		CHECK_concat_nof
196 
		break ;
 229 
		break;
197 
	    }
 230 
	    }
198 
	    case ENC_conditional : {
 231 
	    case ENC_conditional: {
199 
		node *first = sub1 ( exp ) ;
 232 
		node *first = sub1(exp);
200 
		node *alt = sub2 ( exp ) ;
 233 
		node *alt = sub2(exp);
201 
		CHECK_conditional
 234 
		CHECK_conditional
202 
		break ;
 235 
		break;
203 
	    }
 236 
	    }
204 
	    case ENC_contents : {
 237 
	    case ENC_contents: {
205 
		node *s = sub0 ( exp ) ;
 238 
		node *s = sub0(exp);
206 
		node *arg1 = sub1 ( exp ) ;
 239 
		node *arg1 = sub1(exp);
207 
		CHECK_contents
 240 
		CHECK_contents
208 
		break ;
 241 
		break;
209 
	    }
 242 
	    }
210 
	    case ENC_contents_with_mode : {
 243 
	    case ENC_contents_with_mode: {
211 
		node *s = sub1 ( exp ) ;
 244 
		node *s = sub1(exp);
212 
		node *arg1 = sub2 ( exp ) ;
 245 
		node *arg1 = sub2(exp);
213 
		CHECK_contents_with_mode
 246 
		CHECK_contents_with_mode
214 
		break ;
 247 
		break;
215 
	    }
 248 
	    }
216 
	    case ENC_current_env : {
 249 
	    case ENC_current_env: {
217 
		CHECK_current_env
 250 
		CHECK_current_env
218 
		break ;
 251 
		break;
219 
	    }
 252 
	    }
220 
	    case ENC_div0 : {
 253 
	    case ENC_div0: {
221 
		node *arg1 = sub2 ( exp ) ;
 254 
		node *arg1 = sub2(exp);
222 
		node *arg2 = sub3 ( exp ) ;
 255 
		node *arg2 = sub3(exp);
223 
		CHECK_div0
 256 
		CHECK_div0
224 
		break ;
 257 
		break;
225 
	    }
 258 
	    }
226 
	    case ENC_div1 : {
 259 
	    case ENC_div1: {
227 
		node *arg1 = sub2 ( exp ) ;
 260 
		node *arg1 = sub2(exp);
228 
		node *arg2 = sub3 ( exp ) ;
 261 
		node *arg2 = sub3(exp);
229 
		CHECK_div1
 262 
		CHECK_div1
230 
		break ;
 263 
		break;
231 
	    }
 264 
	    }
232 
	    case ENC_div2 : {
 265 
	    case ENC_div2: {
233 
		node *arg1 = sub2 ( exp ) ;
 266 
		node *arg1 = sub2(exp);
234 
		node *arg2 = sub3 ( exp ) ;
 267 
		node *arg2 = sub3(exp);
235 
		CHECK_div2
 268 
		CHECK_div2
236 
		break ;
 269 
		break;
237 
	    }
 270 
	    }
238 
	    case ENC_env_offset : {
 271 
	    case ENC_env_offset: {
239 
		node *fa = sub0 ( exp ) ;
 272 
		node *fa = sub0(exp);
240 
		node *y = sub1 ( exp ) ;
 273 
		node *y = sub1(exp);
241 
		node *t = sub2 ( exp ) ;
 274 
		node *t = sub2(exp);
242 
		CHECK_env_offset
 275 
		CHECK_env_offset
243 
		break ;
 276 
		break;
244 
	    }
 277 
	    }
245 
	    case ENC_env_size : {
 278 
	    case ENC_env_size: {
246 
		node *proctag = sub0 ( exp ) ;
 279 
		node *proctag = sub0(exp);
247 
		CHECK_env_size
 280 
		CHECK_env_size
248 
		break ;
 281 
		break;
249 
	    }
 282 
	    }
250 
	    case ENC_fail_installer : {
 283 
	    case ENC_fail_installer: {
251 
		node *message = sub0 ( exp ) ;
 284 
		node *message = sub0(exp);
252 
		CHECK_fail_installer
 285 
		CHECK_fail_installer
253 
		break ;
 286 
		break;
254 
	    }
 287 
	    }
255 
	    case ENC_float_int : {
 288 
	    case ENC_float_int: {
256 
		node *f = sub1 ( exp ) ;
 289 
		node *f = sub1(exp);
257 
		node *arg1 = sub2 ( exp ) ;
 290 
		node *arg1 = sub2(exp);
258 
		CHECK_float_int
 291 
		CHECK_float_int
259 
		break ;
 292 
		break;
260 
	    }
 293 
	    }
261 
	    case ENC_floating_abs : {
 294 
	    case ENC_floating_abs: {
262 
		node *arg1 = sub1 ( exp ) ;
 295 
		node *arg1 = sub1(exp);
263 
		CHECK_floating_abs
 296 
		CHECK_floating_abs
264 
		break ;
 297 
		break;
265 
	    }
 298 
	    }
266 
	    case ENC_floating_div : {
 299 
	    case ENC_floating_div: {
267 
		node *arg1 = sub1 ( exp ) ;
 300 
		node *arg1 = sub1(exp);
268 
		node *arg2 = sub2 ( exp ) ;
 301 
		node *arg2 = sub2(exp);
269 
		CHECK_floating_div
 302 
		CHECK_floating_div
270 
		break ;
 303 
		break;
271 
	    }
 304 
	    }
272 
	    case ENC_floating_minus : {
 305 
	    case ENC_floating_minus: {
273 
		node *arg1 = sub1 ( exp ) ;
 306 
		node *arg1 = sub1(exp);
274 
		node *arg2 = sub2 ( exp ) ;
 307 
		node *arg2 = sub2(exp);
275 
		CHECK_floating_minus
 308 
		CHECK_floating_minus
276 
		break ;
 309 
		break;
277 
	    }
 310 
	    }
278 
	    case ENC_floating_maximum : {
 311 
	    case ENC_floating_maximum: {
279 
		node *arg1 = sub1 ( exp ) ;
 312 
		node *arg1 = sub1(exp);
280 
		node *arg2 = sub2 ( exp ) ;
 313 
		node *arg2 = sub2(exp);
281 
		CHECK_floating_maximum
 314 
		CHECK_floating_maximum
282 
		break ;
 315 
		break;
283 
	    }
 316 
	    }
284 
	    case ENC_floating_minimum : {
 317 
	    case ENC_floating_minimum: {
285 
		node *arg1 = sub1 ( exp ) ;
 318 
		node *arg1 = sub1(exp);
286 
		node *arg2 = sub2 ( exp ) ;
 319 
		node *arg2 = sub2(exp);
287 
		CHECK_floating_minimum
 320 
		CHECK_floating_minimum
288 
		break ;
 321 
		break;
289 
	    }
 322 
	    }
290 
	    case ENC_floating_mult : {
 323 
	    case ENC_floating_mult: {
291 
		node *arg1 = sub1 ( exp ) ;
 324 
		node *arg1 = sub1(exp);
292 
		CHECK_floating_mult
 325 
		CHECK_floating_mult
293 
		break ;
 326 
		break;
294 
	    }
 327 
	    }
295 
	    case ENC_floating_negate : {
 328 
	    case ENC_floating_negate: {
296 
		node *arg1 = sub1 ( exp ) ;
 329 
		node *arg1 = sub1(exp);
297 
		CHECK_floating_negate
 330 
		CHECK_floating_negate
298 
		break ;
 331 
		break;
299 
	    }
 332 
	    }
300 
	    case ENC_floating_plus : {
 333 
	    case ENC_floating_plus: {
301 
		node *arg1 = sub1 ( exp ) ;
 334 
		node *arg1 = sub1(exp);
302 
		CHECK_floating_plus
 335 
		CHECK_floating_plus
303 
		break ;
 336 
		break;
304 
	    }
 337 
	    }
305 
	    case ENC_floating_power : {
 338 
	    case ENC_floating_power: {
306 
		node *arg1 = sub1 ( exp ) ;
 339 
		node *arg1 = sub1(exp);
307 
		node *arg2 = sub2 ( exp ) ;
 340 
		node *arg2 = sub2(exp);
308 
		CHECK_floating_power
 341 
		CHECK_floating_power
309 
		break ;
 342 
		break;
310 
	    }
 343 
	    }
311 
	    case ENC_floating_test : {
 344 
	    case ENC_floating_test: {
312 
		node *arg1 = sub4 ( exp ) ;
 345 
		node *arg1 = sub4(exp);
313 
		node *arg2 = sub5 ( exp ) ;
 346 
		node *arg2 = sub5(exp);
314 
		CHECK_floating_test
 347 
		CHECK_floating_test
315 
		break ;
 348 
		break;
316 
	    }
 349 
	    }
317 
	    case ENC_goto : {
 350 
	    case ENC_goto: {
318 
		CHECK_goto
 351 
		CHECK_goto
319 
		break ;
 352 
		break;
320 
	    }
 353 
	    }
321 
	    case ENC_goto_local_lv : {
 354 
	    case ENC_goto_local_lv: {
322 
		node *arg1 = sub0 ( exp ) ;
 355 
		node *arg1 = sub0(exp);
323 
		CHECK_goto_local_lv
 356 
		CHECK_goto_local_lv
324 
		break ;
 357 
		break;
325 
	    }
 358 
	    }
326 
	    case ENC_identify : {
 359 
	    case ENC_identify: {
327 
		node *name_intro = sub1 ( exp ) ;
 360 
		node *name_intro = sub1(exp);
328 
		node *definition = sub2 ( exp ) ;
 361 
		node *definition = sub2(exp);
329 
		node *body = sub3 ( exp ) ;
 362 
		node *body = sub3(exp);
330 
		CHECK_identify
 363 
		CHECK_identify
331 
		break ;
 364 
		break;
332 
	    }
 365 
	    }
333 
	    case ENC_ignorable : {
 366 
	    case ENC_ignorable: {
334 
		node *arg1 = sub0 ( exp ) ;
 367 
		node *arg1 = sub0(exp);
335 
		CHECK_ignorable
 368 
		CHECK_ignorable
336 
		break ;
 369 
		break;
337 
	    }
 370 
	    }
338 
	    case ENC_imaginary_part : {
 371 
	    case ENC_imaginary_part: {
339 
		node *arg1 = sub0 ( exp ) ;
 372 
		node *arg1 = sub0(exp);
340 
		CHECK_imaginary_part
 373 
		CHECK_imaginary_part
341 
		break ;
 374 
		break;
342 
	    }
 375 
	    }
343 
	    case ENC_initial_value : {
 376 
	    case ENC_initial_value: {
344 
		node *init = sub0 ( exp ) ;
 377 
		node *init = sub0(exp);
345 
		CHECK_initial_value
 378 
		CHECK_initial_value
346 
		break ;
 379 
		break;
347 
	    }
 380 
	    }
348 
	    case ENC_integer_test : {
 381 
	    case ENC_integer_test: {
349 
		node *arg1 = sub3 ( exp ) ;
 382 
		node *arg1 = sub3(exp);
350 
		node *arg2 = sub4 ( exp ) ;
 383 
		node *arg2 = sub4(exp);
351 
		CHECK_integer_test
 384 
		CHECK_integer_test
352 
		break ;
 385 
		break;
353 
	    }
 386 
	    }
354 
	    case ENC_labelled : {
 387 
	    case ENC_labelled: {
355 
		node *starter = sub1 ( exp ) ;
 388 
		node *starter = sub1(exp);
356 
		node *places = sub2 ( exp ) ;
 389 
		node *places = sub2(exp);
357 
		CHECK_labelled
 390 
		CHECK_labelled
358 
		break ;
 391 
		break;
359 
	    }
 392 
	    }
360 
	    case ENC_last_local : {
 393 
	    case ENC_last_local: {
361 
		node *x = sub0 ( exp ) ;
 394 
		node *x = sub0(exp);
362 
		CHECK_last_local
 395 
		CHECK_last_local
363 
		break ;
 396 
		break;
364 
	    }
 397 
	    }
365 
	    case ENC_local_alloc : {
 398 
	    case ENC_local_alloc: {
366 
		node *arg1 = sub0 ( exp ) ;
 399 
		node *arg1 = sub0(exp);
367 
		CHECK_local_alloc
 400 
		CHECK_local_alloc
368 
		break ;
 401 
		break;
369 
	    }
 402 
	    }
370 
	    case ENC_local_alloc_check : {
 403 
	    case ENC_local_alloc_check: {
371 
		node *arg1 = sub0 ( exp ) ;
 404 
		node *arg1 = sub0(exp);
372 
		CHECK_local_alloc_check
 405 
		CHECK_local_alloc_check
373 
		break ;
 406 
		break;
374 
	    }
 407 
	    }
375 
	    case ENC_local_free : {
 408 
	    case ENC_local_free: {
376 
		node *a = sub0 ( exp ) ;
 409 
		node *a = sub0(exp);
377 
		node *p = sub1 ( exp ) ;
 410 
		node *p = sub1(exp);
378 
		CHECK_local_free
 411 
		CHECK_local_free
379 
		break ;
 412 
		break;
380 
	    }
 413 
	    }
381 
	    case ENC_local_free_all : {
 414 
	    case ENC_local_free_all: {
382 
		CHECK_local_free_all
 415 
		CHECK_local_free_all
383 
		break ;
 416 
		break;
384 
	    }
 417 
	    }
385 
	    case ENC_long_jump : {
 418 
	    case ENC_long_jump: {
386 
		node *arg1 = sub0 ( exp ) ;
 419 
		node *arg1 = sub0(exp);
387 
		node *arg2 = sub1 ( exp ) ;
 420 
		node *arg2 = sub1(exp);
388 
		CHECK_long_jump
 421 
		CHECK_long_jump
389 
		break ;
 422 
		break;
390 
	    }
 423 
	    }
391 
	    case ENC_make_complex : {
 424 
	    case ENC_make_complex: {
392 
		node *c = sub0 ( exp ) ;
 425 
		node *c = sub0(exp);
393 
		node *arg1 = sub1 ( exp ) ;
 426 
		node *arg1 = sub1(exp);
394 
		node *arg2 = sub2 ( exp ) ;
 427 
		node *arg2 = sub2(exp);
395 
		CHECK_make_complex
 428 
		CHECK_make_complex
396 
		break ;
 429 
		break;
397 
	    }
 430 
	    }
398 
	    case ENC_make_compound : {
 431 
	    case ENC_make_compound: {
399 
		node *arg1 = sub0 ( exp ) ;
 432 
		node *arg1 = sub0(exp);
400 
		node *arg2 = sub1 ( exp ) ;
 433 
		node *arg2 = sub1(exp);
401 
		CHECK_make_compound
 434 
		CHECK_make_compound
402 
		break ;
 435 
		break;
403 
	    }
 436 
	    }
404 
	    case ENC_make_floating : {
 437 
	    case ENC_make_floating: {
405 
		node *f = sub0 ( exp ) ;
 438 
		node *f = sub0(exp);
406 
		node *negative = sub2 ( exp ) ;
 439 
		node *negative = sub2(exp);
407 
		node *mantissa = sub3 ( exp ) ;
 440 
		node *mantissa = sub3(exp);
408 
		node *base = sub4 ( exp ) ;
 441 
		node *base = sub4(exp);
409 
		CHECK_make_floating
 442 
		CHECK_make_floating
410 
		break ;
 443 
		break;
411 
	    }
 444 
	    }
412 
	    case ENC_make_general_proc : {
 445 
	    case ENC_make_general_proc: {
413 
		node *result_shape = sub0 ( exp ) ;
 446 
		node *result_shape = sub0(exp);
414 
		node *body = sub4 ( exp ) ;
 447 
		node *body = sub4(exp);
415 
		CHECK_make_general_proc
 448 
		CHECK_make_general_proc
416 
		break ;
 449 
		break;
417 
	    }
 450 
	    }
418 
	    case ENC_make_int : {
 451 
	    case ENC_make_int: {
419 
		node *v = sub0 ( exp ) ;
 452 
		node *v = sub0(exp);
420 
		CHECK_make_int
 453 
		CHECK_make_int
421 
		break ;
 454 
		break;
422 
	    }
 455 
	    }
423 
	    case ENC_make_local_lv : {
 456 
	    case ENC_make_local_lv: {
424 
		CHECK_make_local_lv
 457 
		CHECK_make_local_lv
425 
		break ;
 458 
		break;
426 
	    }
 459 
	    }
427 
	    case ENC_make_nof : {
 460 
	    case ENC_make_nof: {
428 
		node *arg1 = sub0 ( exp ) ;
 461 
		node *arg1 = sub0(exp);
429 
		CHECK_make_nof
 462 
		CHECK_make_nof
430 
		break ;
 463 
		break;
431 
	    }
 464 
	    }
432 
	    case ENC_make_nof_int : {
 465 
	    case ENC_make_nof_int: {
433 
		node *v = sub0 ( exp ) ;
 466 
		node *v = sub0(exp);
434 
		node *str = sub1 ( exp ) ;
 467 
		node *str = sub1(exp);
435 
		CHECK_make_nof_int
 468 
		CHECK_make_nof_int
436 
		break ;
 469 
		break;
437 
	    }
 470 
	    }
438 
	    case ENC_make_null_local_lv : {
 471 
	    case ENC_make_null_local_lv: {
439 
		CHECK_make_null_local_lv
 472 
		CHECK_make_null_local_lv
440 
		break ;
 473 
		break;
441 
	    }
 474 
	    }
442 
	    case ENC_make_null_proc : {
 475 
	    case ENC_make_null_proc: {
443 
		CHECK_make_null_proc
 476 
		CHECK_make_null_proc
444 
		break ;
 477 
		break;
445 
	    }
 478 
	    }
446 
	    case ENC_make_null_ptr : {
 479 
	    case ENC_make_null_ptr: {
447 
		node *a = sub0 ( exp ) ;
 480 
		node *a = sub0(exp);
448 
		CHECK_make_null_ptr
 481 
		CHECK_make_null_ptr
449 
		break ;
 482 
		break;
450 
	    }
 483 
	    }
451 
	    case ENC_make_proc : {
 484 
	    case ENC_make_proc: {
452 
		node *result_shape = sub0 ( exp ) ;
 485 
		node *result_shape = sub0(exp);
453 
		node *body = sub3 ( exp ) ;
 486 
		node *body = sub3(exp);
454 
		CHECK_make_proc
 487 
		CHECK_make_proc
455 
		break ;
 488 
		break;
456 
	    }
 489 
	    }
457 
	    case ENC_make_stack_limit : {
 490 
	    case ENC_make_stack_limit: {
458 
		node *stack_base = sub0 ( exp ) ;
 491 
		node *stack_base = sub0(exp);
459 
		node *frame_size = sub1 ( exp ) ;
 492 
		node *frame_size = sub1(exp);
460 
		node *alloc_size = sub2 ( exp ) ;
 493 
		node *alloc_size = sub2(exp);
461 
		CHECK_make_stack_limit
 494 
		CHECK_make_stack_limit
462 
		break ;
 495 
		break;
463 
	    }
 496 
	    }
464 
	    case ENC_make_top : {
 497 
	    case ENC_make_top: {
465 
		CHECK_make_top
 498 
		CHECK_make_top
466 
		break ;
 499 
		break;
467 
	    }
 500 
	    }
468 
	    case ENC_make_value : {
 501 
	    case ENC_make_value: {
469 
		node *s = sub0 ( exp ) ;
 502 
		node *s = sub0(exp);
470 
		CHECK_make_value
 503 
		CHECK_make_value
471 
		break ;
 504 
		break;
472 
	    }
 505 
	    }
473 
	    case ENC_maximum : {
 506 
	    case ENC_maximum: {
474 
		node *arg1 = sub0 ( exp ) ;
 507 
		node *arg1 = sub0(exp);
475 
		node *arg2 = sub1 ( exp ) ;
 508 
		node *arg2 = sub1(exp);
476 
		CHECK_maximum
 509 
		CHECK_maximum
477 
		break ;
 510 
		break;
478 
	    }
 511 
	    }
479 
	    case ENC_minimum : {
 512 
	    case ENC_minimum: {
480 
		node *arg1 = sub0 ( exp ) ;
 513 
		node *arg1 = sub0(exp);
481 
		node *arg2 = sub1 ( exp ) ;
 514 
		node *arg2 = sub1(exp);
482 
		CHECK_minimum
 515 
		CHECK_minimum
483 
		break ;
 516 
		break;
484 
	    }
 517 
	    }
485 
	    case ENC_minus : {
 518 
	    case ENC_minus: {
486 
		node *arg1 = sub1 ( exp ) ;
 519 
		node *arg1 = sub1(exp);
487 
		node *arg2 = sub2 ( exp ) ;
 520 
		node *arg2 = sub2(exp);
488 
		CHECK_minus
 521 
		CHECK_minus
489 
		break ;
 522 
		break;
490 
	    }
 523 
	    }
491 
	    case ENC_move_some : {
 524 
	    case ENC_move_some: {
492 
		node *arg1 = sub1 ( exp ) ;
 525 
		node *arg1 = sub1(exp);
493 
		node *arg2 = sub2 ( exp ) ;
 526 
		node *arg2 = sub2(exp);
494 
		node *arg3 = sub3 ( exp ) ;
 527 
		node *arg3 = sub3(exp);
495 
		CHECK_move_some
 528 
		CHECK_move_some
496 
		break ;
 529 
		break;
497 
	    }
 530 
	    }
498 
	    case ENC_mult : {
 531 
	    case ENC_mult: {
499 
		node *arg1 = sub1 ( exp ) ;
 532 
		node *arg1 = sub1(exp);
500 
		node *arg2 = sub2 ( exp ) ;
 533 
		node *arg2 = sub2(exp);
501 
		CHECK_mult
 534 
		CHECK_mult
502 
		break ;
 535 
		break;
503 
	    }
 536 
	    }
504 
	    case ENC_n_copies : {
 537 
	    case ENC_n_copies: {
505 
		node *n = sub0 ( exp ) ;
 538 
		node *n = sub0(exp);
506 
		node *arg1 = sub1 ( exp ) ;
 539 
		node *arg1 = sub1(exp);
507 
		CHECK_n_copies
 540 
		CHECK_n_copies
508 
		break ;
 541 
		break;
509 
	    }
 542 
	    }
510 
	    case ENC_negate : {
 543 
	    case ENC_negate: {
511 
		node *arg1 = sub1 ( exp ) ;
 544 
		node *arg1 = sub1(exp);
512 
		CHECK_negate
 545 
		CHECK_negate
513 
		break ;
 546 
		break;
514 
	    }
 547 
	    }
515 
	    case ENC_not : {
 548 
	    case ENC_not: {
516 
		node *arg1 = sub0 ( exp ) ;
 549 
		node *arg1 = sub0(exp);
517 
		CHECK_not
 550 
		CHECK_not
518 
		break ;
 551 
		break;
519 
	    }
 552 
	    }
520 
	    case ENC_obtain_tag : {
 553 
	    case ENC_obtain_tag: {
521 
		node *t = sub0 ( exp ) ;
 554 
		node *t = sub0(exp);
522 
		CHECK_obtain_tag
 555 
		CHECK_obtain_tag
523 
		break ;
 556 
		break;
524 
	    }
 557 
	    }
525 
	    case ENC_offset_add : {
 558 
	    case ENC_offset_add: {
526 
		node *arg1 = sub0 ( exp ) ;
 559 
		node *arg1 = sub0(exp);
527 
		node *arg2 = sub1 ( exp ) ;
 560 
		node *arg2 = sub1(exp);
528 
		CHECK_offset_add
 561 
		CHECK_offset_add
529 
		break ;
 562 
		break;
530 
	    }
 563 
	    }
531 
	    case ENC_offset_div : {
 564 
	    case ENC_offset_div: {
532 
		node *v = sub0 ( exp ) ;
 565 
		node *v = sub0(exp);
533 
		node *arg1 = sub1 ( exp ) ;
 566 
		node *arg1 = sub1(exp);
534 
		node *arg2 = sub2 ( exp ) ;
 567 
		node *arg2 = sub2(exp);
535 
		CHECK_offset_div
 568 
		CHECK_offset_div
536 
		break ;
 569 
		break;
537 
	    }
 570 
	    }
538 
	    case ENC_offset_div_by_int : {
 571 
	    case ENC_offset_div_by_int: {
539 
		node *arg1 = sub0 ( exp ) ;
 572 
		node *arg1 = sub0(exp);
540 
		node *arg2 = sub1 ( exp ) ;
 573 
		node *arg2 = sub1(exp);
541 
		CHECK_offset_div_by_int
 574 
		CHECK_offset_div_by_int
542 
		break ;
 575 
		break;
543 
	    }
 576 
	    }
544 
	    case ENC_offset_max : {
 577 
	    case ENC_offset_max: {
545 
		node *arg1 = sub0 ( exp ) ;
 578 
		node *arg1 = sub0(exp);
546 
		node *arg2 = sub1 ( exp ) ;
 579 
		node *arg2 = sub1(exp);
547 
		CHECK_offset_max
 580 
		CHECK_offset_max
548 
		break ;
 581 
		break;
549 
	    }
 582 
	    }
550 
	    case ENC_offset_mult : {
 583 
	    case ENC_offset_mult: {
551 
		node *arg1 = sub0 ( exp ) ;
 584 
		node *arg1 = sub0(exp);
552 
		node *arg2 = sub1 ( exp ) ;
 585 
		node *arg2 = sub1(exp);
553 
		CHECK_offset_mult
 586 
		CHECK_offset_mult
554 
		break ;
 587 
		break;
555 
	    }
 588 
	    }
556 
	    case ENC_offset_negate : {
 589 
	    case ENC_offset_negate: {
557 
		node *arg1 = sub0 ( exp ) ;
 590 
		node *arg1 = sub0(exp);
558 
		CHECK_offset_negate
 591 
		CHECK_offset_negate
559 
		break ;
 592 
		break;
560 
	    }
 593 
	    }
561 
	    case ENC_offset_pad : {
 594 
	    case ENC_offset_pad: {
562 
		node *a = sub0 ( exp ) ;
 595 
		node *a = sub0(exp);
563 
		node *arg1 = sub1 ( exp ) ;
 596 
		node *arg1 = sub1(exp);
564 
		CHECK_offset_pad
 597 
		CHECK_offset_pad
565 
		break ;
 598 
		break;
566 
	    }
 599 
	    }
567 
	    case ENC_offset_subtract : {
 600 
	    case ENC_offset_subtract: {
568 
		node *arg1 = sub0 ( exp ) ;
 601 
		node *arg1 = sub0(exp);
569 
		node *arg2 = sub1 ( exp ) ;
 602 
		node *arg2 = sub1(exp);
570 
		CHECK_offset_subtract
 603 
		CHECK_offset_subtract
571 
		break ;
 604 
		break;
572 
	    }
 605 
	    }
573 
	    case ENC_offset_test : {
 606 
	    case ENC_offset_test: {
574 
		node *arg1 = sub3 ( exp ) ;
 607 
		node *arg1 = sub3(exp);
575 
		node *arg2 = sub4 ( exp ) ;
 608 
		node *arg2 = sub4(exp);
576 
		CHECK_offset_test
 609 
		CHECK_offset_test
577 
		break ;
 610 
		break;
578 
	    }
 611 
	    }
579 
	    case ENC_offset_zero : {
 612 
	    case ENC_offset_zero: {
580 
		node *a = sub0 ( exp ) ;
 613 
		node *a = sub0(exp);
581 
		CHECK_offset_zero
 614 
		CHECK_offset_zero
582 
		break ;
 615 
		break;
583 
	    }
 616 
	    }
584 
	    case ENC_or : {
 617 
	    case ENC_or: {
585 
		node *arg1 = sub0 ( exp ) ;
 618 
		node *arg1 = sub0(exp);
586 
		node *arg2 = sub1 ( exp ) ;
 619 
		node *arg2 = sub1(exp);
587 
		CHECK_or
 620 
		CHECK_or
588 
		break ;
 621 
		break;
589 
	    }
 622 
	    }
590 
	    case ENC_plus : {
 623 
	    case ENC_plus: {
591 
		node *arg1 = sub1 ( exp ) ;
 624 
		node *arg1 = sub1(exp);
592 
		node *arg2 = sub2 ( exp ) ;
 625 
		node *arg2 = sub2(exp);
593 
		CHECK_plus
 626 
		CHECK_plus
594 
		break ;
 627 
		break;
595 
	    }
 628 
	    }
596 
	    case ENC_pointer_test : {
 629 
	    case ENC_pointer_test: {
597 
		node *arg1 = sub3 ( exp ) ;
 630 
		node *arg1 = sub3(exp);
598 
		node *arg2 = sub4 ( exp ) ;
 631 
		node *arg2 = sub4(exp);
599 
		CHECK_pointer_test
 632 
		CHECK_pointer_test
600 
		break ;
 633 
		break;
601 
	    }
 634 
	    }
602 
	    case ENC_power : {
 635 
	    case ENC_power: {
603 
		node *arg1 = sub1 ( exp ) ;
 636 
		node *arg1 = sub1(exp);
604 
		node *arg2 = sub2 ( exp ) ;
 637 
		node *arg2 = sub2(exp);
605 
		CHECK_power
 638 
		CHECK_power
606 
		break ;
 639 
		break;
607 
	    }
 640 
	    }
608 
	    case ENC_proc_test : {
 641 
	    case ENC_proc_test: {
609 
		node *arg1 = sub3 ( exp ) ;
 642 
		node *arg1 = sub3(exp);
610 
		node *arg2 = sub4 ( exp ) ;
 643 
		node *arg2 = sub4(exp);
611 
		CHECK_proc_test
 644 
		CHECK_proc_test
612 
		break ;
 645 
		break;
613 
	    }
 646 
	    }
614 
	    case ENC_profile : {
 647 
	    case ENC_profile: {
615 
		node *uses = sub0 ( exp ) ;
 648 
		node *uses = sub0(exp);
616 
		CHECK_profile
 649 
		CHECK_profile
617 
		break ;
 650 
		break;
618 
	    }
 651 
	    }
619 
	    case ENC_real_part : {
 652 
	    case ENC_real_part: {
620 
		node *arg1 = sub0 ( exp ) ;
 653 
		node *arg1 = sub0(exp);
621 
		CHECK_real_part
 654 
		CHECK_real_part
622 
		break ;
 655 
		break;
623 
	    }
 656 
	    }
624 
	    case ENC_rem0 : {
 657 
	    case ENC_rem0: {
625 
		node *arg1 = sub2 ( exp ) ;
 658 
		node *arg1 = sub2(exp);
626 
		node *arg2 = sub3 ( exp ) ;
 659 
		node *arg2 = sub3(exp);
627 
		CHECK_rem0
 660 
		CHECK_rem0
628 
		break ;
 661 
		break;
629 
	    }
 662 
	    }
630 
	    case ENC_rem1 : {
 663 
	    case ENC_rem1: {
631 
		node *arg1 = sub2 ( exp ) ;
 664 
		node *arg1 = sub2(exp);
632 
		node *arg2 = sub3 ( exp ) ;
 665 
		node *arg2 = sub3(exp);
633 
		CHECK_rem1
 666 
		CHECK_rem1
634 
		break ;
 667 
		break;
635 
	    }
 668 
	    }
636 
	    case ENC_rem2 : {
 669 
	    case ENC_rem2: {
637 
		node *arg1 = sub2 ( exp ) ;
 670 
		node *arg1 = sub2(exp);
638 
		node *arg2 = sub3 ( exp ) ;
 671 
		node *arg2 = sub3(exp);
639 
		CHECK_rem2
 672 
		CHECK_rem2
640 
		break ;
 673 
		break;
641 
	    }
 674 
	    }
642 
	    case ENC_repeat : {
 675 
	    case ENC_repeat: {
643 
		node *start = sub1 ( exp ) ;
 676 
		node *start = sub1(exp);
644 
		node *body = sub2 ( exp ) ;
 677 
		node *body = sub2(exp);
645 
		CHECK_repeat
 678 
		CHECK_repeat
646 
		break ;
 679 
		break;
647 
	    }
 680 
	    }
648 
	    case ENC_return : {
 681 
	    case ENC_return: {
649 
		node *arg1 = sub0 ( exp ) ;
 682 
		node *arg1 = sub0(exp);
650 
		CHECK_return
 683 
		CHECK_return
651 
		break ;
 684 
		break;
652 
	    }
 685 
	    }
653 
	    case ENC_return_to_label : {
 686 
	    case ENC_return_to_label: {
654 
		node *lab_val = sub0 ( exp ) ;
 687 
		node *lab_val = sub0(exp);
655 
		CHECK_return_to_label
 688 
		CHECK_return_to_label
656 
		break ;
 689 
		break;
657 
	    }
 690 
	    }
658 
	    case ENC_round_with_mode : {
 691 
	    case ENC_round_with_mode: {
659 
		node *r = sub2 ( exp ) ;
 692 
		node *r = sub2(exp);
660 
		node *arg1 = sub3 ( exp ) ;
 693 
		node *arg1 = sub3(exp);
661 
		CHECK_round_with_mode
 694 
		CHECK_round_with_mode
662 
		break ;
 695 
		break;
663 
	    }
 696 
	    }
664 
	    case ENC_rotate_left : {
 697 
	    case ENC_rotate_left: {
665 
		node *arg1 = sub0 ( exp ) ;
 698 
		node *arg1 = sub0(exp);
666 
		node *arg2 = sub1 ( exp ) ;
 699 
		node *arg2 = sub1(exp);
667 
		CHECK_rotate_left
 700 
		CHECK_rotate_left
668 
		break ;
 701 
		break;
669 
	    }
 702 
	    }
670 
	    case ENC_rotate_right : {
 703 
	    case ENC_rotate_right: {
671 
		node *arg1 = sub0 ( exp ) ;
 704 
		node *arg1 = sub0(exp);
672 
		node *arg2 = sub1 ( exp ) ;
 705 
		node *arg2 = sub1(exp);
673 
		CHECK_rotate_right
 706 
		CHECK_rotate_right
674 
		break ;
 707 
		break;
675 
	    }
 708 
	    }
676 
	    case ENC_sequence : {
 709 
	    case ENC_sequence: {
677 
		node *statements = sub0 ( exp ) ;
 710 
		node *statements = sub0(exp);
678 
		node *result = sub1 ( exp ) ;
 711 
		node *result = sub1(exp);
679 
		CHECK_sequence
 712 
		CHECK_sequence
680 
		break ;
 713 
		break;
681 
	    }
 714 
	    }
682 
	    case ENC_set_stack_limit : {
 715 
	    case ENC_set_stack_limit: {
683 
		node *lim = sub0 ( exp ) ;
 716 
		node *lim = sub0(exp);
684 
		CHECK_set_stack_limit
 717 
		CHECK_set_stack_limit
685 
		break ;
 718 
		break;
686 
	    }
 719 
	    }
687 
	    case ENC_shape_offset : {
 720 
	    case ENC_shape_offset: {
688 
		node *s = sub0 ( exp ) ;
 721 
		node *s = sub0(exp);
689 
		CHECK_shape_offset
 722 
		CHECK_shape_offset
690 
		break ;
 723 
		break;
691 
	    }
 724 
	    }
692 
	    case ENC_shift_left : {
 725 
	    case ENC_shift_left: {
693 
		node *arg1 = sub1 ( exp ) ;
 726 
		node *arg1 = sub1(exp);
694 
		node *arg2 = sub2 ( exp ) ;
 727 
		node *arg2 = sub2(exp);
695 
		CHECK_shift_left
 728 
		CHECK_shift_left
696 
		break ;
 729 
		break;
697 
	    }
 730 
	    }
698 
	    case ENC_shift_right : {
 731 
	    case ENC_shift_right: {
699 
		node *arg1 = sub0 ( exp ) ;
 732 
		node *arg1 = sub0(exp);
700 
		node *arg2 = sub1 ( exp ) ;
 733 
		node *arg2 = sub1(exp);
701 
		CHECK_shift_right
 734 
		CHECK_shift_right
702 
		break ;
 735 
		break;
703 
	    }
 736 
	    }
704 
	    case ENC_subtract_ptrs : {
 737 
	    case ENC_subtract_ptrs: {
705 
		node *arg1 = sub0 ( exp ) ;
 738 
		node *arg1 = sub0(exp);
706 
		node *arg2 = sub1 ( exp ) ;
 739 
		node *arg2 = sub1(exp);
707 
		CHECK_subtract_ptrs
 740 
		CHECK_subtract_ptrs
708 
		break ;
 741 
		break;
709 
	    }
 742 
	    }
710 
	    case ENC_tail_call : {
 743 
	    case ENC_tail_call: {
711 
		node *p = sub1 ( exp ) ;
 744 
		node *p = sub1(exp);
712 
		CHECK_tail_call
 745 
		CHECK_tail_call
713 
		break ;
 746 
		break;
714 
	    }
 747 
	    }
715 
	    case ENC_untidy_return : {
 748 
	    case ENC_untidy_return: {
716 
		node *arg1 = sub0 ( exp ) ;
 749 
		node *arg1 = sub0(exp);
717 
		CHECK_untidy_return
 750 
		CHECK_untidy_return
718 
		break ;
 751 
		break;
719 
	    }
 752 
	    }
720 
	    case ENC_variable : {
 753 
	    case ENC_variable: {
721 
		node *name_intro = sub1 ( exp ) ;
 754 
		node *name_intro = sub1(exp);
722 
		node *init = sub2 ( exp ) ;
 755 
		node *init = sub2(exp);
723 
		node *body = sub3 ( exp ) ;
 756 
		node *body = sub3(exp);
724 
		CHECK_variable
 757 
		CHECK_variable
725 
		break ;
 758 
		break;
726 
	    }
 759 
	    }
727 
	    case ENC_xor : {
 760 
	    case ENC_xor: {
728 
		node *arg1 = sub0 ( exp ) ;
 761 
		node *arg1 = sub0(exp);
729 
		node *arg2 = sub1 ( exp ) ;
 762 
		node *arg2 = sub1(exp);
730 
		CHECK_xor
 763 
		CHECK_xor
731 
		break ;
 764 
		break;
732 
	    }
 765 
	    }
733 
	}
 766 
	}
734 
	exp->shape = expand_fully ( exp->shape ) ;
 767 
	exp->shape = expand_fully(exp->shape);
735 
    }
 768 
    }
736 
    return ;
 769 
    return;
737 
}
 770 
}