Révision | 148 (tree) |
---|---|
l'heure | 2018-09-23 13:33:36 |
Auteur | jakobthomsen |
compile-time stack-offsets
@@ -26,11 +26,22 @@ | ||
26 | 26 | #define RET { sb$$$ -= sz$$$; fn$$$ = stack$$$[--sb$$$]; /*fprintf(stderr, "returned to 0x%0llXLLU\n", (long long unsigned int)fn$$$);*/ sz$$$ = stack$$$[--sb$$$]; sp$$$ = stack$$$[--sb$$$]; sb$$$ = stack$$$[sb$$$ - 1]; break; } |
27 | 27 | #define ADDR stack$$$[ADDR_IDX] |
28 | 28 | |
29 | +uint64_t SP = 0; | |
30 | +void SP_TRACK() { fprintf(stdout, "// SP %llu\n", (long long unsigned int)SP); } | |
31 | +void SP_VERIFY() { fprintf(stdout, "// VERIFY SP\nif(sp$$$ != %lluLLU) { fprintf(stderr, \"verify failed, sp %cllu != %llu SP in line %cd\\n\", (long long unsigned int)sp$$$, __LINE__); exit(-1); }\n", (long long unsigned int)SP, 37, (long long unsigned int)SP, 37); } | |
32 | +uint64_t SP_SET_VERIFY(uint64_t val) { SP = val; SP_TRACK(); SP_VERIFY(); return 0; } | |
33 | +uint64_t SP_SET(uint64_t val) { SP = val; SP_TRACK(); return 0; } | |
34 | +uint64_t SP_ADD_VERIFY(uint64_t val) { SP += val; SP_TRACK(); SP_VERIFY(); return 0; } | |
35 | +uint64_t SP_ADD(uint64_t val) { SP += val; SP_TRACK(); return 0; } | |
36 | + | |
29 | 37 | int32_t main() |
30 | 38 | { |
31 | 39 | uint64_t *stack$$$ = malloc(8 * 1048576LLU); |
32 | 40 | register uint64_t sb$$$ = 17; // skip space reserved for globals |
33 | 41 | register uint64_t sp$$$ = 0; |
42 | +// SP 0 | |
43 | +// VERIFY SP | |
44 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
34 | 45 | register uint64_t sz$$$ = 0; |
35 | 46 | register uint64_t fn$$$ = 0xA1C9290000000000LLU; // main-symbol |
36 | 47 | register uint64_t c$$$; |
@@ -41,146 +52,232 @@ | ||
41 | 52 | { |
42 | 53 | // reserve space for globals |
43 | 54 | |
44 | -case /*false_____*/0x85C9EE8000000000LLU: | |
55 | +case /*false_____*/0x85C9EE8000000000LLU:// SP 0 | |
56 | +// VERIFY SP | |
57 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
45 | 58 | |
59 | + | |
46 | 60 | PUSH(0LLU); |
61 | +// SP 1 | |
62 | +// VERIFY SP | |
63 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
47 | 64 | ACCESS_RETURN = POP; |
65 | +// SP 0 | |
66 | +// VERIFY SP | |
67 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
48 | 68 | |
49 | 69 | RET; |
50 | 70 | |
51 | 71 | |
52 | -case /*true______*/0xBEDC200000000000LLU: | |
72 | +case /*true______*/0xBEDC200000000000LLU:// SP 0 | |
73 | +// VERIFY SP | |
74 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
53 | 75 | |
76 | + | |
54 | 77 | PUSH(1LLU); |
78 | +// SP 1 | |
79 | +// VERIFY SP | |
80 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
55 | 81 | ACCESS_RETURN = POP; |
82 | +// SP 0 | |
83 | +// VERIFY SP | |
84 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
56 | 85 | |
57 | 86 | RET; |
58 | 87 | |
59 | 88 | |
60 | -case /*exit______*/0x83392F0000000000LLU: | |
89 | +case /*exit______*/0x83392F0000000000LLU:// SP 0 | |
90 | +// VERIFY SP | |
91 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
61 | 92 | |
93 | + | |
62 | 94 | exit(ACCESS_ARG(0)); |
63 | 95 | RET; |
64 | 96 | |
65 | 97 | |
66 | -case /*equ_______*/0x82CC000000000000LLU: | |
98 | +case /*equ_______*/0x82CC000000000000LLU:// SP 0 | |
99 | +// VERIFY SP | |
100 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
67 | 101 | |
102 | + | |
68 | 103 | ACCESS_RETURN = ACCESS_ARG(0) == ACCESS_ARG(1); |
69 | 104 | RET; |
70 | 105 | |
71 | 106 | |
72 | -case /*geq_______*/0x8A0B000000000000LLU: | |
107 | +case /*geq_______*/0x8A0B000000000000LLU:// SP 0 | |
108 | +// VERIFY SP | |
109 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
73 | 110 | |
111 | + | |
74 | 112 | ACCESS_RETURN = ACCESS_ARG(0) >= ACCESS_ARG(1); |
75 | 113 | RET; |
76 | 114 | |
77 | 115 | |
78 | -case /*gtr_______*/0x8AFB400000000000LLU: | |
116 | +case /*gtr_______*/0x8AFB400000000000LLU:// SP 0 | |
117 | +// VERIFY SP | |
118 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
79 | 119 | |
120 | + | |
80 | 121 | ACCESS_RETURN = ACCESS_ARG(0) > ACCESS_ARG(1); |
81 | 122 | RET; |
82 | 123 | |
83 | 124 | |
84 | -case /*leq_______*/0x9E0B000000000000LLU: | |
125 | +case /*leq_______*/0x9E0B000000000000LLU:// SP 0 | |
126 | +// VERIFY SP | |
127 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
85 | 128 | |
129 | + | |
86 | 130 | ACCESS_RETURN = ACCESS_ARG(0) <= ACCESS_ARG(1); |
87 | 131 | RET; |
88 | 132 | |
89 | 133 | |
90 | -case /*lss_______*/0x9EEB800000000000LLU: | |
134 | +case /*lss_______*/0x9EEB800000000000LLU:// SP 0 | |
135 | +// VERIFY SP | |
136 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
91 | 137 | |
138 | + | |
92 | 139 | ACCESS_RETURN = ACCESS_ARG(0) < ACCESS_ARG(1); |
93 | 140 | RET; |
94 | 141 | |
95 | 142 | |
96 | -case /*neq_______*/0xA60B000000000000LLU: | |
143 | +case /*neq_______*/0xA60B000000000000LLU:// SP 0 | |
144 | +// VERIFY SP | |
145 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
97 | 146 | |
147 | + | |
98 | 148 | ACCESS_RETURN = (ACCESS_ARG(0) != ACCESS_ARG(1)); |
99 | 149 | RET; |
100 | 150 | |
101 | 151 | |
102 | -case /*and_______*/0x7297C00000000000LLU: | |
152 | +case /*and_______*/0x7297C00000000000LLU:// SP 0 | |
153 | +// VERIFY SP | |
154 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
103 | 155 | |
156 | + | |
104 | 157 | ACCESS_RETURN = (ACCESS_ARG(0) && ACCESS_ARG(1)); |
105 | 158 | RET; |
106 | 159 | |
107 | 160 | |
108 | -case /*or________*/0xAAD0000000000000LLU: | |
161 | +case /*or________*/0xAAD0000000000000LLU:// SP 0 | |
162 | +// VERIFY SP | |
163 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
109 | 164 | |
165 | + | |
110 | 166 | ACCESS_RETURN = (ACCESS_ARG(0) || ACCESS_ARG(1)); |
111 | 167 | RET; |
112 | 168 | |
113 | 169 | |
114 | -case /*not_______*/0xA6ABC00000000000LLU: | |
170 | +case /*not_______*/0xA6ABC00000000000LLU:// SP 0 | |
171 | +// VERIFY SP | |
172 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
115 | 173 | |
174 | + | |
116 | 175 | ACCESS_RETURN = !ACCESS_ARG(0); |
117 | 176 | RET; |
118 | 177 | |
119 | 178 | |
120 | -case /*id________*/0x91F0000000000000LLU: | |
179 | +case /*id________*/0x91F0000000000000LLU:// SP 0 | |
180 | +// VERIFY SP | |
181 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
121 | 182 | |
183 | + | |
122 | 184 | ACCESS_RETURN = ACCESS_ARG(0); |
123 | 185 | RET; |
124 | 186 | |
125 | 187 | |
126 | -case /*inc_______*/0x9297800000000000LLU: | |
188 | +case /*inc_______*/0x9297800000000000LLU:// SP 0 | |
189 | +// VERIFY SP | |
190 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
127 | 191 | |
192 | + | |
128 | 193 | ACCESS_RETURN = ACCESS_ARG(0) + 1; |
129 | 194 | RET; |
130 | 195 | |
131 | 196 | |
132 | -case /*dec_______*/0x7E07800000000000LLU: | |
197 | +case /*dec_______*/0x7E07800000000000LLU:// SP 0 | |
198 | +// VERIFY SP | |
199 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
133 | 200 | |
201 | + | |
134 | 202 | ACCESS_RETURN = ACCESS_ARG(0) - 1; |
135 | 203 | RET; |
136 | 204 | |
137 | 205 | |
138 | -case /*add_______*/0x71F7C00000000000LLU: | |
206 | +case /*add_______*/0x71F7C00000000000LLU:// SP 0 | |
207 | +// VERIFY SP | |
208 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
139 | 209 | |
210 | + | |
140 | 211 | ACCESS_RETURN = ACCESS_ARG(0) + ACCESS_ARG(1); |
141 | 212 | RET; |
142 | 213 | |
143 | 214 | |
144 | -case /*sub_______*/0xBB07400000000000LLU: | |
215 | +case /*sub_______*/0xBB07400000000000LLU:// SP 0 | |
216 | +// VERIFY SP | |
217 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
145 | 218 | |
219 | + | |
146 | 220 | ACCESS_RETURN = ACCESS_ARG(0) - ACCESS_ARG(1); |
147 | 221 | RET; |
148 | 222 | |
149 | 223 | |
150 | -case /*mul_______*/0xA309C00000000000LLU: | |
224 | +case /*mul_______*/0xA309C00000000000LLU:// SP 0 | |
225 | +// VERIFY SP | |
226 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
151 | 227 | |
228 | + | |
152 | 229 | ACCESS_RETURN = ACCESS_ARG(0) * ACCESS_ARG(1); |
153 | 230 | RET; |
154 | 231 | |
155 | 232 | |
156 | -case /*div_______*/0x7E4C400000000000LLU: | |
233 | +case /*div_______*/0x7E4C400000000000LLU:// SP 0 | |
234 | +// VERIFY SP | |
235 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
157 | 236 | |
237 | + | |
158 | 238 | ACCESS_RETURN = ACCESS_ARG(0) / ACCESS_ARG(1); |
159 | 239 | RET; |
160 | 240 | |
161 | 241 | |
162 | -case /*noop______*/0xA6AAAB0000000000LLU: | |
242 | +case /*noop______*/0xA6AAAB0000000000LLU:// SP 0 | |
243 | +// VERIFY SP | |
244 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
163 | 245 | |
246 | + | |
164 | 247 | fprintf(stderr,"d"); |
165 | 248 | RET; |
166 | 249 | |
167 | 250 | |
168 | -case /*skip______*/0xBA692B0000000000LLU: | |
251 | +case /*skip______*/0xBA692B0000000000LLU:// SP 0 | |
252 | +// VERIFY SP | |
253 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
169 | 254 | |
170 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFFELLU, 0x8A0BC00000000000LLU); | |
255 | + | |
256 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
257 | +// SP 5 | |
258 | +// VERIFY SP | |
259 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
260 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFFELLU, 0x8A0BC00000000000LLU); | |
171 | 261 | case 0xFFFFFFFFFFFFFFFELLU: |
262 | +// SP 1 | |
172 | 263 | |
173 | 264 | RET; |
174 | 265 | |
175 | 266 | |
176 | -case /*put_______*/0xAF0BC00000000000LLU: | |
267 | +case /*put_______*/0xAF0BC00000000000LLU:// SP 0 | |
268 | +// VERIFY SP | |
269 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
177 | 270 | |
271 | + | |
178 | 272 | ACCESS_RETURN = fputc(ACCESS_ARG(0), stdout); |
179 | 273 | RET; |
180 | 274 | |
181 | 275 | |
182 | -case /*get_______*/0x8A0BC00000000000LLU: | |
276 | +case /*get_______*/0x8A0BC00000000000LLU:// SP 0 | |
277 | +// VERIFY SP | |
278 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
183 | 279 | |
280 | + | |
184 | 281 | if('\n' == ungetc(fgetc(stdin), stdin)) |
185 | 282 | { |
186 | 283 | stack$$$[LINENR_IDX]++; |
@@ -189,44 +286,89 @@ | ||
189 | 286 | RET; |
190 | 287 | |
191 | 288 | |
192 | -case /*peek______*/0xAE08260000000000LLU: | |
289 | +case /*peek______*/0xAE08260000000000LLU:// SP 0 | |
290 | +// VERIFY SP | |
291 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
193 | 292 | |
293 | + | |
194 | 294 | ACCESS_RETURN = ungetc(fgetc(stdin), stdin); |
195 | 295 | RET; |
196 | 296 | |
197 | 297 | |
198 | -case /*echo______*/0x81E8EA0000000000LLU: | |
298 | +case /*echo______*/0x81E8EA0000000000LLU:// SP 0 | |
299 | +// VERIFY SP | |
300 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
199 | 301 | |
200 | - CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFFDLLU, 0x8A0BC00000000000LLU); | |
302 | + | |
303 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
304 | +// SP 5 | |
305 | +// VERIFY SP | |
306 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
307 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
308 | +// SP 10 | |
309 | +// VERIFY SP | |
310 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
311 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFFDLLU, 0x8A0BC00000000000LLU); | |
201 | 312 | case 0xFFFFFFFFFFFFFFFDLLU: |
313 | +// SP 6 | |
202 | 314 | CALLEND(1LLU, 0xFFFFFFFFFFFFFFFCLLU, 0xAF0BC00000000000LLU); |
203 | 315 | case 0xFFFFFFFFFFFFFFFCLLU: |
316 | +// SP 1 | |
204 | 317 | ACCESS_RETURN = POP; |
318 | +// SP 0 | |
319 | +// VERIFY SP | |
320 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
205 | 321 | |
206 | 322 | RET; |
207 | 323 | |
208 | 324 | |
209 | -case /*echonr____*/0x81E8EAA6D0000000LLU: | |
325 | +case /*echonr____*/0x81E8EAA6D0000000LLU:// SP 0 | |
326 | +// VERIFY SP | |
327 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
210 | 328 | |
329 | + | |
211 | 330 | case 0xFFFFFFFFFFFFFFFBLLU: // loop to here |
212 | 331 | // predicate |
213 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFF9LLU, 0xAE08260000000000LLU); | |
332 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
333 | +// SP 5 | |
334 | +// VERIFY SP | |
335 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
336 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
337 | +// SP 10 | |
338 | +// VERIFY SP | |
339 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
340 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFF9LLU, 0xAE08260000000000LLU); | |
214 | 341 | case 0xFFFFFFFFFFFFFFF9LLU: |
342 | +// SP 6 | |
215 | 343 | CALLEND(1LLU, 0xFFFFFFFFFFFFFFF8LLU, 0x92E7E48A4BC00000LLU); |
216 | 344 | case 0xFFFFFFFFFFFFFFF8LLU: |
217 | -if(!ACCESS_CURRENT) | |
345 | +// SP 1 | |
346 | +if(!POP) | |
347 | +// SP 0 | |
218 | 348 | JUMP(0xFFFFFFFFFFFFFFFALLU); // skip loop |
219 | 349 | // loop |
220 | 350 | |
221 | - PUSH(0); // place-holder for result of block | |
222 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
351 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
352 | +// SP 1 | |
353 | +// VERIFY SP | |
354 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
223 | 355 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
224 | 356 | |
225 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFF7LLU, 0x81E8EA0000000000LLU); | |
357 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
358 | +// SP 6 | |
359 | +// VERIFY SP | |
360 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
361 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFF7LLU, 0x81E8EA0000000000LLU); | |
226 | 362 | case 0xFFFFFFFFFFFFFFF7LLU: |
363 | +// SP 2 | |
227 | 364 | |
228 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
365 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
366 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
367 | +// SP 1 | |
229 | 368 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
369 | +// SP 0 | |
370 | +// VERIFY SP | |
371 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
230 | 372 | JUMP(0xFFFFFFFFFFFFFFFBLLU); // loop |
231 | 373 | case 0xFFFFFFFFFFFFFFFALLU: // skip to here |
232 | 374 |
@@ -233,296 +375,662 @@ | ||
233 | 375 | RET; |
234 | 376 | |
235 | 377 | |
236 | -case /*match_____*/0xA1CBDE8C00000000LLU: | |
378 | +case /*match_____*/0xA1CBDE8C00000000LLU:// SP 0 | |
379 | +// VERIFY SP | |
380 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
237 | 381 | |
382 | + | |
238 | 383 | // predicate |
239 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFF4LLU, 0x8A0BC00000000000LLU); | |
384 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
385 | +// SP 5 | |
386 | +// VERIFY SP | |
387 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
388 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
389 | +// SP 10 | |
390 | +// VERIFY SP | |
391 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
392 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFF4LLU, 0x8A0BC00000000000LLU); | |
240 | 393 | case 0xFFFFFFFFFFFFFFF4LLU: |
394 | +// SP 6 | |
241 | 395 | PUSH(ACCESS_ARG(0)); |
396 | +// SP 7 | |
397 | +// VERIFY SP | |
398 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
242 | 399 | CALLEND(2LLU, 0xFFFFFFFFFFFFFFF3LLU, 0xA60B000000000000LLU); |
243 | 400 | case 0xFFFFFFFFFFFFFFF3LLU: |
244 | -if(!ACCESS_CURRENT) | |
401 | +// SP 1 | |
402 | +if(!POP) | |
403 | +// SP 0 | |
245 | 404 | JUMP(0xFFFFFFFFFFFFFFF6LLU); // skip consequent |
246 | 405 | // consequent |
247 | 406 | |
248 | - PUSH(0); // place-holder for result of block | |
249 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
407 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
408 | +// SP 1 | |
409 | +// VERIFY SP | |
410 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
250 | 411 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
251 | 412 | |
252 | 413 | fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); |
253 | 414 | fprintf(stderr, "expected '%c' but found '%c'\n", (char)ACCESS_ARG(0), (char)c$$$); |
254 | 415 | exit(-1); |
255 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
416 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
417 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
418 | +// SP 1 | |
256 | 419 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
420 | +// SP 0 | |
421 | +// VERIFY SP | |
422 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
257 | 423 | JUMP(0xFFFFFFFFFFFFFFF5LLU); // skip alternative |
258 | 424 | case 0xFFFFFFFFFFFFFFF6LLU: // alternative |
259 | 425 | |
260 | 426 | |
261 | - PUSH(0); // place-holder for result of block | |
262 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
427 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
428 | +// SP 1 | |
429 | +// VERIFY SP | |
430 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
263 | 431 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
264 | 432 | |
265 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
433 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
434 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
435 | +// SP 1 | |
266 | 436 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
437 | +// SP 0 | |
438 | +// VERIFY SP | |
439 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
267 | 440 | case 0xFFFFFFFFFFFFFFF5LLU: // skip to here |
268 | 441 | |
269 | 442 | RET; |
270 | 443 | |
271 | 444 | |
272 | -case /*matchopt__*/0xA1CBDE8EAAEF0000LLU: | |
445 | +case /*matchopt__*/0xA1CBDE8EAAEF0000LLU:// SP 0 | |
446 | +// VERIFY SP | |
447 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
273 | 448 | |
449 | + | |
274 | 450 | // predicate |
275 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFF0LLU, 0xAE08260000000000LLU); | |
451 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
452 | +// SP 5 | |
453 | +// VERIFY SP | |
454 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
455 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
456 | +// SP 10 | |
457 | +// VERIFY SP | |
458 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
459 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFF0LLU, 0xAE08260000000000LLU); | |
276 | 460 | case 0xFFFFFFFFFFFFFFF0LLU: |
461 | +// SP 6 | |
277 | 462 | PUSH(ACCESS_ARG(0)); |
463 | +// SP 7 | |
464 | +// VERIFY SP | |
465 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
278 | 466 | CALLEND(2LLU, 0xFFFFFFFFFFFFFFEFLLU, 0x82CC000000000000LLU); |
279 | 467 | case 0xFFFFFFFFFFFFFFEFLLU: |
280 | -if(!ACCESS_CURRENT) | |
468 | +// SP 1 | |
469 | +if(!POP) | |
470 | +// SP 0 | |
281 | 471 | JUMP(0xFFFFFFFFFFFFFFF2LLU); // skip consequent |
282 | 472 | // consequent |
283 | 473 | |
284 | - PUSH(0); // place-holder for result of block | |
285 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
474 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
475 | +// SP 1 | |
476 | +// VERIFY SP | |
477 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
286 | 478 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
287 | 479 | |
288 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFEELLU, 0xBA692B0000000000LLU); | |
480 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
481 | +// SP 6 | |
482 | +// VERIFY SP | |
483 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
484 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFEELLU, 0xBA692B0000000000LLU); | |
289 | 485 | case 0xFFFFFFFFFFFFFFEELLU: |
486 | +// SP 2 | |
290 | 487 | |
291 | 488 | PUSH(1LLU); |
489 | +// SP 3 | |
490 | +// VERIFY SP | |
491 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
292 | 492 | ACCESS_RETURN = POP; |
493 | +// SP 2 | |
494 | +// VERIFY SP | |
495 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
293 | 496 | |
294 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
497 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
498 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
499 | +// SP 1 | |
295 | 500 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
501 | +// SP 0 | |
502 | +// VERIFY SP | |
503 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
296 | 504 | JUMP(0xFFFFFFFFFFFFFFF1LLU); // skip alternative |
297 | 505 | case 0xFFFFFFFFFFFFFFF2LLU: // alternative |
298 | 506 | |
299 | 507 | |
300 | - PUSH(0); // place-holder for result of block | |
301 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
508 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
509 | +// SP 1 | |
510 | +// VERIFY SP | |
511 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
302 | 512 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
303 | 513 | |
304 | 514 | PUSH(0LLU); |
515 | +// SP 2 | |
516 | +// VERIFY SP | |
517 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
305 | 518 | ACCESS_RETURN = POP; |
519 | +// SP 1 | |
520 | +// VERIFY SP | |
521 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
306 | 522 | |
307 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
523 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
524 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
525 | +// SP 1 | |
308 | 526 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
527 | +// SP 0 | |
528 | +// VERIFY SP | |
529 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
309 | 530 | case 0xFFFFFFFFFFFFFFF1LLU: // skip to here |
310 | 531 | |
311 | 532 | RET; |
312 | 533 | |
313 | 534 | |
314 | -case /*isalpha___*/0x92E727AE37000000LLU: | |
535 | +case /*isalpha___*/0x92E727AE37000000LLU:// SP 0 | |
536 | +// VERIFY SP | |
537 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
315 | 538 | |
539 | + | |
316 | 540 | ACCESS_RETURN = isalpha((char)ACCESS_ARG(0)); |
317 | 541 | RET; |
318 | 542 | |
319 | 543 | |
320 | -case /*isdigit___*/0x92E7E48A4BC00000LLU: | |
544 | +case /*isdigit___*/0x92E7E48A4BC00000LLU:// SP 0 | |
545 | +// VERIFY SP | |
546 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
321 | 547 | |
548 | + | |
322 | 549 | ACCESS_RETURN = isdigit((char)ACCESS_ARG(0)); |
323 | 550 | RET; |
324 | 551 | |
325 | 552 | |
326 | -case /*isspace___*/0x92EBAB71E8000000LLU: | |
553 | +case /*isspace___*/0x92EBAB71E8000000LLU:// SP 0 | |
554 | +// VERIFY SP | |
555 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
327 | 556 | |
557 | + | |
328 | 558 | ACCESS_RETURN = isspace((char)ACCESS_ARG(0)); |
329 | 559 | RET; |
330 | 560 | |
331 | 561 | |
332 | -case /*parseexpr_*/0xADCB6E820CEBB400LLU: | |
562 | +case /*parseexpr_*/0xADCB6E820CEBB400LLU:// SP 0 | |
563 | +// VERIFY SP | |
564 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
333 | 565 | |
334 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFEDLLU, 0xBA692B7A8A6FB800LLU); | |
566 | + | |
567 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
568 | +// SP 5 | |
569 | +// VERIFY SP | |
570 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
571 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFEDLLU, 0xBA692B7A8A6FB800LLU); | |
335 | 572 | case 0xFFFFFFFFFFFFFFEDLLU: |
573 | +// SP 1 | |
336 | 574 | |
337 | 575 | // predicate |
338 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFEALLU, 0xAE08260000000000LLU); | |
576 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
577 | +// SP 6 | |
578 | +// VERIFY SP | |
579 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
580 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
581 | +// SP 11 | |
582 | +// VERIFY SP | |
583 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
584 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFEALLU, 0xAE08260000000000LLU); | |
339 | 585 | case 0xFFFFFFFFFFFFFFEALLU: |
586 | +// SP 7 | |
340 | 587 | CALLEND(1LLU, 0xFFFFFFFFFFFFFFE9LLU, 0x92E727AE37000000LLU); |
341 | 588 | case 0xFFFFFFFFFFFFFFE9LLU: |
342 | -if(!ACCESS_CURRENT) | |
589 | +// SP 2 | |
590 | +if(!POP) | |
591 | +// SP 1 | |
343 | 592 | JUMP(0xFFFFFFFFFFFFFFECLLU); // skip consequent |
344 | 593 | // consequent |
345 | 594 | |
346 | - PUSH(0); // place-holder for result of block | |
347 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
595 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
596 | +// SP 2 | |
597 | +// VERIFY SP | |
598 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
348 | 599 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
349 | 600 | |
350 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFE8LLU, 0xADCB6E81E7279C00LLU); | |
601 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
602 | +// SP 7 | |
603 | +// VERIFY SP | |
604 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
605 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFE8LLU, 0xADCB6E81E7279C00LLU); | |
351 | 606 | case 0xFFFFFFFFFFFFFFE8LLU: |
607 | +// SP 3 | |
352 | 608 | |
353 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
609 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
610 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
611 | +// SP 2 | |
354 | 612 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
613 | +// SP 1 | |
614 | +// VERIFY SP | |
615 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
355 | 616 | JUMP(0xFFFFFFFFFFFFFFEBLLU); // skip alternative |
356 | 617 | case 0xFFFFFFFFFFFFFFECLLU: // alternative |
357 | 618 | |
358 | 619 | |
359 | - PUSH(0); // place-holder for result of block | |
360 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
620 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
621 | +// SP 2 | |
622 | +// VERIFY SP | |
623 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
361 | 624 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
362 | 625 | |
363 | 626 | // predicate |
364 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFE5LLU, 0xAE08260000000000LLU); | |
627 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
628 | +// SP 7 | |
629 | +// VERIFY SP | |
630 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
631 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
632 | +// SP 12 | |
633 | +// VERIFY SP | |
634 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
635 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFE5LLU, 0xAE08260000000000LLU); | |
365 | 636 | case 0xFFFFFFFFFFFFFFE5LLU: |
637 | +// SP 8 | |
366 | 638 | CALLEND(1LLU, 0xFFFFFFFFFFFFFFE4LLU, 0x92E7E48A4BC00000LLU); |
367 | 639 | case 0xFFFFFFFFFFFFFFE4LLU: |
368 | -if(!ACCESS_CURRENT) | |
640 | +// SP 3 | |
641 | +if(!POP) | |
642 | +// SP 2 | |
369 | 643 | JUMP(0xFFFFFFFFFFFFFFE7LLU); // skip consequent |
370 | 644 | // consequent |
371 | 645 | |
372 | - PUSH(0); // place-holder for result of block | |
373 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
646 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
647 | +// SP 3 | |
648 | +// VERIFY SP | |
649 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
374 | 650 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
375 | 651 | |
376 | 652 | fprintf(stdout, "PUSH("); |
377 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFE3LLU, 0x81E8EAA6D0000000LLU); | |
653 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
654 | +// SP 8 | |
655 | +// VERIFY SP | |
656 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
657 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFE3LLU, 0x81E8EAA6D0000000LLU); | |
378 | 658 | case 0xFFFFFFFFFFFFFFE3LLU: |
659 | +// SP 4 | |
379 | 660 | |
380 | 661 | fprintf(stdout, "LLU);\n"); |
381 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
662 | + SP_ADD_VERIFY(1); | |
663 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
664 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
665 | +// SP 3 | |
382 | 666 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
667 | +// SP 2 | |
668 | +// VERIFY SP | |
669 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
383 | 670 | JUMP(0xFFFFFFFFFFFFFFE6LLU); // skip alternative |
384 | 671 | case 0xFFFFFFFFFFFFFFE7LLU: // alternative |
385 | 672 | |
386 | 673 | |
387 | - PUSH(0); // place-holder for result of block | |
388 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
674 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
675 | +// SP 3 | |
676 | +// VERIFY SP | |
677 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
389 | 678 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
390 | 679 | |
391 | 680 | // predicate |
392 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(35LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFE0LLU, 0xA1CBDE8EAAEF0000LLU); | |
681 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
682 | +// SP 8 | |
683 | +// VERIFY SP | |
684 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
685 | +PUSH(35LLU);// SP 9 | |
686 | +// VERIFY SP | |
687 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
688 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFE0LLU, 0xA1CBDE8EAAEF0000LLU); | |
393 | 689 | case 0xFFFFFFFFFFFFFFE0LLU: |
394 | -if(!ACCESS_CURRENT) | |
690 | +// SP 4 | |
691 | +if(!POP) | |
692 | +// SP 3 | |
395 | 693 | JUMP(0xFFFFFFFFFFFFFFE2LLU); // skip consequent |
396 | 694 | // consequent |
397 | 695 | |
398 | - PUSH(0); // place-holder for result of block | |
399 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
696 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
697 | +// SP 4 | |
698 | +// VERIFY SP | |
699 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
400 | 700 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
401 | 701 | |
402 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFDFLLU, 0xAF0BA372D8800000LLU); | |
702 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 5 | |
703 | +// SP 9 | |
704 | +// VERIFY SP | |
705 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
706 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFDFLLU, 0xAF0BA372D8800000LLU); | |
403 | 707 | case 0xFFFFFFFFFFFFFFDFLLU: |
708 | +// SP 5 | |
404 | 709 | |
405 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
710 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
711 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
712 | +// SP 4 | |
406 | 713 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
714 | +// SP 3 | |
715 | +// VERIFY SP | |
716 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
407 | 717 | JUMP(0xFFFFFFFFFFFFFFE1LLU); // skip alternative |
408 | 718 | case 0xFFFFFFFFFFFFFFE2LLU: // alternative |
409 | 719 | |
410 | 720 | |
411 | - PUSH(0); // place-holder for result of block | |
412 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
721 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
722 | +// SP 4 | |
723 | +// VERIFY SP | |
724 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
413 | 725 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
414 | 726 | |
415 | 727 | // predicate |
416 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(94LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFDCLLU, 0xA1CBDE8EAAEF0000LLU); | |
728 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 5 | |
729 | +// SP 9 | |
730 | +// VERIFY SP | |
731 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
732 | +PUSH(94LLU);// SP 10 | |
733 | +// VERIFY SP | |
734 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
735 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFDCLLU, 0xA1CBDE8EAAEF0000LLU); | |
417 | 736 | case 0xFFFFFFFFFFFFFFDCLLU: |
418 | -if(!ACCESS_CURRENT) | |
737 | +// SP 5 | |
738 | +if(!POP) | |
739 | +// SP 4 | |
419 | 740 | JUMP(0xFFFFFFFFFFFFFFDELLU); // skip consequent |
420 | 741 | // consequent |
421 | 742 | |
422 | - PUSH(0); // place-holder for result of block | |
423 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
743 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
744 | +// SP 5 | |
745 | +// VERIFY SP | |
746 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
424 | 747 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
425 | 748 | |
426 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFDBLLU, 0xAF0BA38A7A9D0000LLU); | |
749 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
750 | +// SP 10 | |
751 | +// VERIFY SP | |
752 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
753 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFDBLLU, 0xAF0BA38A7A9D0000LLU); | |
427 | 754 | case 0xFFFFFFFFFFFFFFDBLLU: |
755 | +// SP 6 | |
428 | 756 | |
429 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
757 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
758 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
759 | +// SP 5 | |
430 | 760 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
761 | +// SP 4 | |
762 | +// VERIFY SP | |
763 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
431 | 764 | JUMP(0xFFFFFFFFFFFFFFDDLLU); // skip alternative |
432 | 765 | case 0xFFFFFFFFFFFFFFDELLU: // alternative |
433 | 766 | |
434 | 767 | |
435 | - PUSH(0); // place-holder for result of block | |
436 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
768 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
769 | +// SP 5 | |
770 | +// VERIFY SP | |
771 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
437 | 772 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
438 | 773 | |
439 | 774 | // predicate |
440 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(96LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFD8LLU, 0xA1CBDE8EAAEF0000LLU); | |
775 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
776 | +// SP 10 | |
777 | +// VERIFY SP | |
778 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
779 | +PUSH(96LLU);// SP 11 | |
780 | +// VERIFY SP | |
781 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
782 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFD8LLU, 0xA1CBDE8EAAEF0000LLU); | |
441 | 783 | case 0xFFFFFFFFFFFFFFD8LLU: |
442 | -if(!ACCESS_CURRENT) | |
784 | +// SP 6 | |
785 | +if(!POP) | |
786 | +// SP 5 | |
443 | 787 | JUMP(0xFFFFFFFFFFFFFFDALLU); // skip consequent |
444 | 788 | // consequent |
445 | 789 | |
446 | - PUSH(0); // place-holder for result of block | |
447 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
790 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
791 | +// SP 6 | |
792 | +// VERIFY SP | |
793 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
448 | 794 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
449 | 795 | |
450 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFD7LLU, 0xAF0BA3C5CB400000LLU); | |
796 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
797 | +// SP 11 | |
798 | +// VERIFY SP | |
799 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
800 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFD7LLU, 0xAF0BA3C5CB400000LLU); | |
451 | 801 | case 0xFFFFFFFFFFFFFFD7LLU: |
802 | +// SP 7 | |
452 | 803 | |
453 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
804 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
805 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
806 | +// SP 6 | |
454 | 807 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
808 | +// SP 5 | |
809 | +// VERIFY SP | |
810 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
455 | 811 | JUMP(0xFFFFFFFFFFFFFFD9LLU); // skip alternative |
456 | 812 | case 0xFFFFFFFFFFFFFFDALLU: // alternative |
457 | 813 | |
458 | 814 | |
459 | - PUSH(0); // place-holder for result of block | |
460 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
815 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
816 | +// SP 6 | |
817 | +// VERIFY SP | |
818 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
461 | 819 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
462 | 820 | |
463 | - fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); | |
464 | - fprintf(stderr, "unexpected '%c' in expression\n", (char)fgetc(stdin)); | |
465 | - exit(-1); | |
466 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
821 | + // predicate | |
822 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
823 | +// SP 11 | |
824 | +// VERIFY SP | |
825 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
826 | +PUSH(40LLU);// SP 12 | |
827 | +// VERIFY SP | |
828 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
829 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFD4LLU, 0xA1CBDE8EAAEF0000LLU); | |
830 | +case 0xFFFFFFFFFFFFFFD4LLU: | |
831 | +// SP 7 | |
832 | +if(!POP) | |
833 | +// SP 6 | |
834 | + JUMP(0xFFFFFFFFFFFFFFD6LLU); // skip consequent | |
835 | +// consequent | |
836 | + | |
837 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
838 | +// SP 7 | |
839 | +// VERIFY SP | |
840 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
841 | +stack$$$[BLKINF_IDX] = sp$$$; // store base of current block | |
842 | + | |
843 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
844 | +// SP 12 | |
845 | +// VERIFY SP | |
846 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
847 | +PUSH(ACCESS_ARG(0)); | |
848 | +// SP 13 | |
849 | +// VERIFY SP | |
850 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
851 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFD3LLU, 0xADCB6E820CEBB400LLU); | |
852 | +case 0xFFFFFFFFFFFFFFD3LLU: | |
853 | +// SP 8 | |
854 | + | |
855 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 9 | |
856 | +// SP 13 | |
857 | +// VERIFY SP | |
858 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
859 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFD2LLU, 0xBA692B7A8A6FB800LLU); | |
860 | +case 0xFFFFFFFFFFFFFFD2LLU: | |
861 | +// SP 9 | |
862 | + | |
863 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 10 | |
864 | +// SP 14 | |
865 | +// VERIFY SP | |
866 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
867 | +PUSH(41LLU);// SP 15 | |
868 | +// VERIFY SP | |
869 | +if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
870 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFD1LLU, 0xA1CBDE8C00000000LLU); | |
871 | +case 0xFFFFFFFFFFFFFFD1LLU: | |
872 | +// SP 10 | |
873 | + | |
874 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
875 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
876 | +// SP 7 | |
467 | 877 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
878 | +// SP 6 | |
879 | +// VERIFY SP | |
880 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
881 | + JUMP(0xFFFFFFFFFFFFFFD5LLU); // skip alternative | |
882 | +case 0xFFFFFFFFFFFFFFD6LLU: // alternative | |
883 | + | |
884 | + | |
885 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
886 | +// SP 7 | |
887 | +// VERIFY SP | |
888 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
889 | +stack$$$[BLKINF_IDX] = sp$$$; // store base of current block | |
890 | + | |
891 | + fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); | |
892 | + fprintf(stderr, "unexpected '%c' in expression\n", (char)fgetc(stdin)); | |
893 | + exit(-1); | |
894 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
895 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
896 | +// SP 7 | |
897 | +stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block | |
898 | +// SP 6 | |
899 | +// VERIFY SP | |
900 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
901 | +case 0xFFFFFFFFFFFFFFD5LLU: // skip to here | |
902 | + | |
903 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
904 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
905 | +// SP 6 | |
906 | +stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block | |
907 | +// SP 5 | |
908 | +// VERIFY SP | |
909 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
468 | 910 | case 0xFFFFFFFFFFFFFFD9LLU: // skip to here |
469 | 911 | |
470 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
912 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
913 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
914 | +// SP 5 | |
471 | 915 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
916 | +// SP 4 | |
917 | +// VERIFY SP | |
918 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
472 | 919 | case 0xFFFFFFFFFFFFFFDDLLU: // skip to here |
473 | 920 | |
474 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
921 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
922 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
923 | +// SP 4 | |
475 | 924 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
925 | +// SP 3 | |
926 | +// VERIFY SP | |
927 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
476 | 928 | case 0xFFFFFFFFFFFFFFE1LLU: // skip to here |
477 | 929 | |
478 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
930 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
931 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
932 | +// SP 3 | |
479 | 933 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
934 | +// SP 2 | |
935 | +// VERIFY SP | |
936 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
480 | 937 | case 0xFFFFFFFFFFFFFFE6LLU: // skip to here |
481 | 938 | |
482 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
939 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
940 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
941 | +// SP 2 | |
483 | 942 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
943 | +// SP 1 | |
944 | +// VERIFY SP | |
945 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
484 | 946 | case 0xFFFFFFFFFFFFFFEBLLU: // skip to here |
485 | 947 | |
486 | 948 | RET; |
487 | 949 | |
488 | 950 | |
489 | -case /*parseexpr_'*/0xADCB6E820CEBB401LLU: | |
951 | +case /*parseexpr_'*/0xADCB6E820CEBB401LLU:// SP 0 | |
952 | +// VERIFY SP | |
953 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
490 | 954 | |
491 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFD6LLU, 0xBA692B7A8A6FB800LLU); | |
492 | -case 0xFFFFFFFFFFFFFFD6LLU: | |
493 | 955 | |
494 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(61LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFD5LLU, 0xA1CBDE8C00000000LLU); | |
495 | -case 0xFFFFFFFFFFFFFFD5LLU: | |
956 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
957 | +// SP 5 | |
958 | +// VERIFY SP | |
959 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
960 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFD0LLU, 0xBA692B7A8A6FB800LLU); | |
961 | +case 0xFFFFFFFFFFFFFFD0LLU: | |
962 | +// SP 1 | |
496 | 963 | |
497 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFD4LLU, 0xADCB6E820CEBB400LLU); | |
498 | -case 0xFFFFFFFFFFFFFFD4LLU: | |
964 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
965 | +// SP 6 | |
966 | +// VERIFY SP | |
967 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
968 | +PUSH(61LLU);// SP 7 | |
969 | +// VERIFY SP | |
970 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
971 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFCFLLU, 0xA1CBDE8C00000000LLU); | |
972 | +case 0xFFFFFFFFFFFFFFCFLLU: | |
973 | +// SP 2 | |
499 | 974 | |
975 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
976 | +// SP 7 | |
977 | +// VERIFY SP | |
978 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
979 | +PUSH(ACCESS_ARG(0)); | |
980 | +// SP 8 | |
981 | +// VERIFY SP | |
982 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
983 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFCELLU, 0xADCB6E820CEBB400LLU); | |
984 | +case 0xFFFFFFFFFFFFFFCELLU: | |
985 | +// SP 3 | |
986 | + | |
500 | 987 | RET; |
501 | 988 | |
502 | 989 | |
503 | -case /*assignglob*/0x72EBA48A98A7A9D0LLU: | |
990 | +case /*assignglob*/0x72EBA48A98A7A9D0LLU:// SP 0 | |
991 | +// VERIFY SP | |
992 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
504 | 993 | |
994 | + | |
505 | 995 | ACCESS_RETURN = 0; |
506 | - case 0xFFFFFFFFFFFFFFD3LLU: // loop to here | |
996 | + case 0xFFFFFFFFFFFFFFCDLLU: // loop to here | |
507 | 997 | // predicate |
508 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFD1LLU, 0xAE08260000000000LLU); | |
509 | -case 0xFFFFFFFFFFFFFFD1LLU: | |
510 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFFD0LLU, 0x92E7E48A4BC00000LLU); | |
511 | -case 0xFFFFFFFFFFFFFFD0LLU: | |
512 | -if(!ACCESS_CURRENT) | |
513 | - JUMP(0xFFFFFFFFFFFFFFD2LLU); // skip loop | |
998 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
999 | +// SP 5 | |
1000 | +// VERIFY SP | |
1001 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1002 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
1003 | +// SP 10 | |
1004 | +// VERIFY SP | |
1005 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1006 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFCBLLU, 0xAE08260000000000LLU); | |
1007 | +case 0xFFFFFFFFFFFFFFCBLLU: | |
1008 | +// SP 6 | |
1009 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFCALLU, 0x92E7E48A4BC00000LLU); | |
1010 | +case 0xFFFFFFFFFFFFFFCALLU: | |
1011 | +// SP 1 | |
1012 | +if(!POP) | |
1013 | +// SP 0 | |
1014 | + JUMP(0xFFFFFFFFFFFFFFCCLLU); // skip loop | |
514 | 1015 | // loop |
515 | 1016 | |
516 | - PUSH(0); // place-holder for result of block | |
517 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1017 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1018 | +// SP 1 | |
1019 | +// VERIFY SP | |
1020 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
518 | 1021 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
519 | 1022 | |
520 | 1023 | ACCESS_RETURN *= 10; |
521 | 1024 | ACCESS_RETURN += fgetc(stdin) - '0'; // XXX use get |
522 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1025 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1026 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1027 | +// SP 1 | |
523 | 1028 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
524 | - JUMP(0xFFFFFFFFFFFFFFD3LLU); // loop | |
525 | -case 0xFFFFFFFFFFFFFFD2LLU: // skip to here | |
1029 | +// SP 0 | |
1030 | +// VERIFY SP | |
1031 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1032 | + JUMP(0xFFFFFFFFFFFFFFCDLLU); // loop | |
1033 | +case 0xFFFFFFFFFFFFFFCCLLU: // skip to here | |
526 | 1034 | |
527 | 1035 | if((long long unsigned int)ACCESS_RETURN >= stack$$$[GLOBMAX_IDX]) |
528 | 1036 | { |
@@ -531,288 +1039,581 @@ | ||
531 | 1039 | exit(-1); |
532 | 1040 | } |
533 | 1041 | |
534 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFCFLLU, 0xADCB6E820CEBB401LLU); | |
535 | -case 0xFFFFFFFFFFFFFFCFLLU: | |
1042 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1043 | +// SP 5 | |
1044 | +// VERIFY SP | |
1045 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1046 | +PUSH(ACCESS_ARG(0)); | |
1047 | +// SP 6 | |
1048 | +// VERIFY SP | |
1049 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1050 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFC9LLU, 0xADCB6E820CEBB401LLU); | |
1051 | +case 0xFFFFFFFFFFFFFFC9LLU: | |
1052 | +// SP 1 | |
536 | 1053 | |
537 | 1054 | |
538 | 1055 | fprintf(stdout, "stack$$$[%lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN); |
1056 | + SP_ADD_VERIFY(-1); | |
539 | 1057 | RET; |
540 | 1058 | |
541 | 1059 | |
542 | -case /*assignvar_*/0x72EBA48A9C5CB400LLU: | |
1060 | +case /*assignvar_*/0x72EBA48A9C5CB400LLU:// SP 0 | |
1061 | +// VERIFY SP | |
1062 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
543 | 1063 | |
1064 | + | |
544 | 1065 | ACCESS_RETURN = 0; |
545 | 1066 | // predicate |
546 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(96LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFCCLLU, 0xA1CBDE8EAAEF0000LLU); | |
547 | -case 0xFFFFFFFFFFFFFFCCLLU: | |
548 | -if(!ACCESS_CURRENT) | |
549 | - JUMP(0xFFFFFFFFFFFFFFCELLU); // skip consequent | |
1067 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1068 | +// SP 5 | |
1069 | +// VERIFY SP | |
1070 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1071 | +PUSH(96LLU);// SP 6 | |
1072 | +// VERIFY SP | |
1073 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1074 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFC6LLU, 0xA1CBDE8EAAEF0000LLU); | |
1075 | +case 0xFFFFFFFFFFFFFFC6LLU: | |
1076 | +// SP 1 | |
1077 | +if(!POP) | |
1078 | +// SP 0 | |
1079 | + JUMP(0xFFFFFFFFFFFFFFC8LLU); // skip consequent | |
550 | 1080 | // consequent |
551 | 1081 | |
552 | - PUSH(0); // place-holder for result of block | |
553 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1082 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1083 | +// SP 1 | |
1084 | +// VERIFY SP | |
1085 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
554 | 1086 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
555 | 1087 | |
556 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFCBLLU, 0xADCB6E820CEBB401LLU); | |
557 | -case 0xFFFFFFFFFFFFFFCBLLU: | |
1088 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
1089 | +// SP 6 | |
1090 | +// VERIFY SP | |
1091 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1092 | +PUSH(ACCESS_ARG(0)); | |
1093 | +// SP 7 | |
1094 | +// VERIFY SP | |
1095 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1096 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFC5LLU, 0xADCB6E820CEBB401LLU); | |
1097 | +case 0xFFFFFFFFFFFFFFC5LLU: | |
1098 | +// SP 2 | |
558 | 1099 | |
559 | 1100 | |
560 | 1101 | fprintf(stdout, "ACCESS_RETURN = POP;\n"); |
561 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1102 | + SP_ADD_VERIFY(-1); | |
1103 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1104 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1105 | +// SP 1 | |
562 | 1106 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
563 | - JUMP(0xFFFFFFFFFFFFFFCDLLU); // skip alternative | |
564 | -case 0xFFFFFFFFFFFFFFCELLU: // alternative | |
1107 | +// SP 0 | |
1108 | +// VERIFY SP | |
1109 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1110 | + JUMP(0xFFFFFFFFFFFFFFC7LLU); // skip alternative | |
1111 | +case 0xFFFFFFFFFFFFFFC8LLU: // alternative | |
565 | 1112 | |
566 | 1113 | |
567 | - PUSH(0); // place-holder for result of block | |
568 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1114 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1115 | +// SP 1 | |
1116 | +// VERIFY SP | |
1117 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
569 | 1118 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
570 | 1119 | |
571 | - case 0xFFFFFFFFFFFFFFCALLU: // loop to here | |
1120 | + case 0xFFFFFFFFFFFFFFC4LLU: // loop to here | |
572 | 1121 | // predicate |
573 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFC8LLU, 0xAE08260000000000LLU); | |
574 | -case 0xFFFFFFFFFFFFFFC8LLU: | |
575 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFFC7LLU, 0x92E7E48A4BC00000LLU); | |
576 | -case 0xFFFFFFFFFFFFFFC7LLU: | |
577 | -if(!ACCESS_CURRENT) | |
578 | - JUMP(0xFFFFFFFFFFFFFFC9LLU); // skip loop | |
1122 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
1123 | +// SP 6 | |
1124 | +// VERIFY SP | |
1125 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1126 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
1127 | +// SP 11 | |
1128 | +// VERIFY SP | |
1129 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1130 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFC2LLU, 0xAE08260000000000LLU); | |
1131 | +case 0xFFFFFFFFFFFFFFC2LLU: | |
1132 | +// SP 7 | |
1133 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFC1LLU, 0x92E7E48A4BC00000LLU); | |
1134 | +case 0xFFFFFFFFFFFFFFC1LLU: | |
1135 | +// SP 2 | |
1136 | +if(!POP) | |
1137 | +// SP 1 | |
1138 | + JUMP(0xFFFFFFFFFFFFFFC3LLU); // skip loop | |
579 | 1139 | // loop |
580 | 1140 | |
581 | - PUSH(0); // place-holder for result of block | |
582 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1141 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1142 | +// SP 2 | |
1143 | +// VERIFY SP | |
1144 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
583 | 1145 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
584 | 1146 | |
585 | 1147 | ACCESS_RETURN *= 10; |
586 | 1148 | ACCESS_RETURN += fgetc(stdin) - '0'; // XXX use get |
587 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1149 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1150 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1151 | +// SP 2 | |
588 | 1152 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
589 | - JUMP(0xFFFFFFFFFFFFFFCALLU); // loop | |
590 | -case 0xFFFFFFFFFFFFFFC9LLU: // skip to here | |
1153 | +// SP 1 | |
1154 | +// VERIFY SP | |
1155 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1156 | + JUMP(0xFFFFFFFFFFFFFFC4LLU); // loop | |
1157 | +case 0xFFFFFFFFFFFFFFC3LLU: // skip to here | |
591 | 1158 | |
592 | - fprintf(stdout, "if(sp$$$ != %lluLLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, \"VAR sp %cllu != %llu\\n\", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } else sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN); | |
1159 | + fprintf(stdout, "if(sp$$$ != %lluLLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, \"VAR sp %cllu != %llu\\n\", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN); | |
1160 | + SP_ADD_VERIFY(1); | |
593 | 1161 | |
594 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFC6LLU, 0xADCB6E820CEBB401LLU); | |
595 | -case 0xFFFFFFFFFFFFFFC6LLU: | |
1162 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
1163 | +// SP 6 | |
1164 | +// VERIFY SP | |
1165 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1166 | +PUSH(ACCESS_ARG(0)); | |
1167 | +// SP 7 | |
1168 | +// VERIFY SP | |
1169 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1170 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFC0LLU, 0xADCB6E820CEBB401LLU); | |
1171 | +case 0xFFFFFFFFFFFFFFC0LLU: | |
1172 | +// SP 2 | |
596 | 1173 | |
597 | 1174 | |
598 | 1175 | fprintf(stdout, "stack$$$[sb$$$ + %lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN); |
599 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1176 | + SP_ADD_VERIFY(-1); | |
1177 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1178 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1179 | +// SP 1 | |
600 | 1180 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
601 | -case 0xFFFFFFFFFFFFFFCDLLU: // skip to here | |
1181 | +// SP 0 | |
1182 | +// VERIFY SP | |
1183 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1184 | +case 0xFFFFFFFFFFFFFFC7LLU: // skip to here | |
602 | 1185 | |
603 | 1186 | RET; |
604 | 1187 | |
605 | 1188 | |
606 | -case /*assignarg_*/0x72EBA48A972D8800LLU: | |
1189 | +case /*assignarg_*/0x72EBA48A972D8800LLU:// SP 0 | |
1190 | +// VERIFY SP | |
1191 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
607 | 1192 | |
1193 | + | |
608 | 1194 | ACCESS_RETURN = 0; |
609 | 1195 | // predicate |
610 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(35LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFC3LLU, 0xA1CBDE8EAAEF0000LLU); | |
611 | -case 0xFFFFFFFFFFFFFFC3LLU: | |
612 | -if(!ACCESS_CURRENT) | |
613 | - JUMP(0xFFFFFFFFFFFFFFC5LLU); // skip consequent | |
1196 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1197 | +// SP 5 | |
1198 | +// VERIFY SP | |
1199 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1200 | +PUSH(35LLU);// SP 6 | |
1201 | +// VERIFY SP | |
1202 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1203 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFBDLLU, 0xA1CBDE8EAAEF0000LLU); | |
1204 | +case 0xFFFFFFFFFFFFFFBDLLU: | |
1205 | +// SP 1 | |
1206 | +if(!POP) | |
1207 | +// SP 0 | |
1208 | + JUMP(0xFFFFFFFFFFFFFFBFLLU); // skip consequent | |
614 | 1209 | // consequent |
615 | 1210 | |
616 | - PUSH(0); // place-holder for result of block | |
617 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1211 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1212 | +// SP 1 | |
1213 | +// VERIFY SP | |
1214 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
618 | 1215 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
619 | 1216 | |
620 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFC2LLU, 0xBA692B0000000000LLU); | |
621 | -case 0xFFFFFFFFFFFFFFC2LLU: | |
1217 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
1218 | +// SP 6 | |
1219 | +// VERIFY SP | |
1220 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1221 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFBCLLU, 0xBA692B0000000000LLU); | |
1222 | +case 0xFFFFFFFFFFFFFFBCLLU: | |
1223 | +// SP 2 | |
622 | 1224 | |
623 | 1225 | |
624 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFC1LLU, 0xADCB6E820CEBB401LLU); | |
625 | -case 0xFFFFFFFFFFFFFFC1LLU: | |
1226 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
1227 | +// SP 7 | |
1228 | +// VERIFY SP | |
1229 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1230 | +PUSH(ACCESS_ARG(0)); | |
1231 | +// SP 8 | |
1232 | +// VERIFY SP | |
1233 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1234 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFBBLLU, 0xADCB6E820CEBB401LLU); | |
1235 | +case 0xFFFFFFFFFFFFFFBBLLU: | |
1236 | +// SP 3 | |
626 | 1237 | |
627 | 1238 | |
628 | 1239 | fprintf(stdout, "ACCESS_RETURN = POP;\n"); |
629 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1240 | + SP_ADD_VERIFY(-1); | |
1241 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1242 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1243 | +// SP 1 | |
630 | 1244 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
631 | - JUMP(0xFFFFFFFFFFFFFFC4LLU); // skip alternative | |
632 | -case 0xFFFFFFFFFFFFFFC5LLU: // alternative | |
1245 | +// SP 0 | |
1246 | +// VERIFY SP | |
1247 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1248 | + JUMP(0xFFFFFFFFFFFFFFBELLU); // skip alternative | |
1249 | +case 0xFFFFFFFFFFFFFFBFLLU: // alternative | |
633 | 1250 | |
634 | 1251 | |
635 | - PUSH(0); // place-holder for result of block | |
636 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1252 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1253 | +// SP 1 | |
1254 | +// VERIFY SP | |
1255 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
637 | 1256 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
638 | 1257 | |
639 | - case 0xFFFFFFFFFFFFFFC0LLU: // loop to here | |
1258 | + case 0xFFFFFFFFFFFFFFBALLU: // loop to here | |
640 | 1259 | // predicate |
641 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFBELLU, 0xAE08260000000000LLU); | |
642 | -case 0xFFFFFFFFFFFFFFBELLU: | |
643 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFFBDLLU, 0x92E7E48A4BC00000LLU); | |
644 | -case 0xFFFFFFFFFFFFFFBDLLU: | |
645 | -if(!ACCESS_CURRENT) | |
646 | - JUMP(0xFFFFFFFFFFFFFFBFLLU); // skip loop | |
1260 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
1261 | +// SP 6 | |
1262 | +// VERIFY SP | |
1263 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1264 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
1265 | +// SP 11 | |
1266 | +// VERIFY SP | |
1267 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1268 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFB8LLU, 0xAE08260000000000LLU); | |
1269 | +case 0xFFFFFFFFFFFFFFB8LLU: | |
1270 | +// SP 7 | |
1271 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFB7LLU, 0x92E7E48A4BC00000LLU); | |
1272 | +case 0xFFFFFFFFFFFFFFB7LLU: | |
1273 | +// SP 2 | |
1274 | +if(!POP) | |
1275 | +// SP 1 | |
1276 | + JUMP(0xFFFFFFFFFFFFFFB9LLU); // skip loop | |
647 | 1277 | // loop |
648 | 1278 | |
649 | - PUSH(0); // place-holder for result of block | |
650 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1279 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1280 | +// SP 2 | |
1281 | +// VERIFY SP | |
1282 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
651 | 1283 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
652 | 1284 | |
653 | 1285 | ACCESS_RETURN *= 10; |
654 | 1286 | ACCESS_RETURN += fgetc(stdin) - '0'; // XXX use get |
655 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1287 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1288 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1289 | +// SP 2 | |
656 | 1290 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
657 | - JUMP(0xFFFFFFFFFFFFFFC0LLU); // loop | |
658 | -case 0xFFFFFFFFFFFFFFBFLLU: // skip to here | |
1291 | +// SP 1 | |
1292 | +// VERIFY SP | |
1293 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1294 | + JUMP(0xFFFFFFFFFFFFFFBALLU); // loop | |
1295 | +case 0xFFFFFFFFFFFFFFB9LLU: // skip to here | |
659 | 1296 | |
660 | - fprintf(stdout, "if(sp$$$ != %lluLLU) { fprintf(stderr, \"ARG SP %cllu != %llu\\n\", (long long unsigned int)sp$$$); exit(-1); } else sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN); | |
661 | 1297 | |
662 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFBCLLU, 0xADCB6E820CEBB401LLU); | |
663 | -case 0xFFFFFFFFFFFFFFBCLLU: | |
1298 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
1299 | +// SP 6 | |
1300 | +// VERIFY SP | |
1301 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1302 | +PUSH(ACCESS_ARG(0)); | |
1303 | +// SP 7 | |
1304 | +// VERIFY SP | |
1305 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1306 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFB6LLU, 0xADCB6E820CEBB401LLU); | |
1307 | +case 0xFFFFFFFFFFFFFFB6LLU: | |
1308 | +// SP 2 | |
664 | 1309 | |
665 | 1310 | |
666 | 1311 | fprintf(stdout, "stack$$$[sb$$$ - sz$$$ + %lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN); |
667 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1312 | + SP_ADD_VERIFY(-1); | |
1313 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1314 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1315 | +// SP 1 | |
668 | 1316 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
669 | -case 0xFFFFFFFFFFFFFFC4LLU: // skip to here | |
1317 | +// SP 0 | |
1318 | +// VERIFY SP | |
1319 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1320 | +case 0xFFFFFFFFFFFFFFBELLU: // skip to here | |
670 | 1321 | |
671 | 1322 | RET; |
672 | 1323 | |
673 | 1324 | |
674 | -case /*parseglob_*/0xADCB6E8229EA7400LLU: | |
1325 | +case /*parseglob_*/0xADCB6E8229EA7400LLU:// SP 0 | |
1326 | +// VERIFY SP | |
1327 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
675 | 1328 | |
1329 | + | |
676 | 1330 | PUSH(0LLU); |
1331 | +// SP 1 | |
1332 | +// VERIFY SP | |
1333 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
677 | 1334 | ACCESS_RETURN = POP; |
1335 | +// SP 0 | |
1336 | +// VERIFY SP | |
1337 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
678 | 1338 | |
679 | 1339 | |
680 | 1340 | fprintf(stdout, "stack$$$["); |
681 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFBBLLU, 0x81E8EAA6D0000000LLU); | |
682 | -case 0xFFFFFFFFFFFFFFBBLLU: | |
1341 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1342 | +// SP 5 | |
1343 | +// VERIFY SP | |
1344 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1345 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFB5LLU, 0x81E8EAA6D0000000LLU); | |
1346 | +case 0xFFFFFFFFFFFFFFB5LLU: | |
1347 | +// SP 1 | |
683 | 1348 | |
684 | 1349 | fprintf(stdout, "]"); |
685 | 1350 | RET; |
686 | 1351 | |
687 | 1352 | |
688 | -case /*parsevar__*/0xADCB6E83172D0000LLU: | |
1353 | +case /*parsevar__*/0xADCB6E83172D0000LLU:// SP 0 | |
1354 | +// VERIFY SP | |
1355 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
689 | 1356 | |
1357 | + | |
690 | 1358 | PUSH(0LLU); |
1359 | +// SP 1 | |
1360 | +// VERIFY SP | |
1361 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
691 | 1362 | ACCESS_RETURN = POP; |
1363 | +// SP 0 | |
1364 | +// VERIFY SP | |
1365 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
692 | 1366 | |
693 | 1367 | |
694 | 1368 | fprintf(stdout, "stack$$$[sb$$$ + "); |
695 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFBALLU, 0x81E8EAA6D0000000LLU); | |
696 | -case 0xFFFFFFFFFFFFFFBALLU: | |
1369 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1370 | +// SP 5 | |
1371 | +// VERIFY SP | |
1372 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1373 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFB4LLU, 0x81E8EAA6D0000000LLU); | |
1374 | +case 0xFFFFFFFFFFFFFFB4LLU: | |
1375 | +// SP 1 | |
697 | 1376 | |
698 | 1377 | fprintf(stdout, "]"); |
699 | 1378 | RET; |
700 | 1379 | |
701 | 1380 | |
702 | -case /*parsearg__*/0xADCB6E81CB620000LLU: | |
1381 | +case /*parsearg__*/0xADCB6E81CB620000LLU:// SP 0 | |
1382 | +// VERIFY SP | |
1383 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
703 | 1384 | |
1385 | + | |
704 | 1386 | PUSH(0LLU); |
1387 | +// SP 1 | |
1388 | +// VERIFY SP | |
1389 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
705 | 1390 | ACCESS_RETURN = POP; |
1391 | +// SP 0 | |
1392 | +// VERIFY SP | |
1393 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
706 | 1394 | |
707 | 1395 | |
708 | 1396 | fprintf(stdout, "ACCESS_ARG("); |
709 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB9LLU, 0x81E8EAA6D0000000LLU); | |
710 | -case 0xFFFFFFFFFFFFFFB9LLU: | |
1397 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1398 | +// SP 5 | |
1399 | +// VERIFY SP | |
1400 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1401 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFB3LLU, 0x81E8EAA6D0000000LLU); | |
1402 | +case 0xFFFFFFFFFFFFFFB3LLU: | |
1403 | +// SP 1 | |
711 | 1404 | |
712 | 1405 | fprintf(stdout, ")"); |
713 | 1406 | RET; |
714 | 1407 | |
715 | 1408 | |
716 | -case /*pushglob__*/0xAF0BA38A7A9D0000LLU: | |
1409 | +case /*pushglob__*/0xAF0BA38A7A9D0000LLU:// SP 0 | |
1410 | +// VERIFY SP | |
1411 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
717 | 1412 | |
1413 | + | |
718 | 1414 | PUSH(0LLU); |
1415 | +// SP 1 | |
1416 | +// VERIFY SP | |
1417 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
719 | 1418 | ACCESS_RETURN = POP; |
1419 | +// SP 0 | |
1420 | +// VERIFY SP | |
1421 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
720 | 1422 | |
721 | 1423 | |
722 | 1424 | fprintf(stdout, "PUSH("); |
723 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB8LLU, 0xADCB6E8229EA7400LLU); | |
724 | -case 0xFFFFFFFFFFFFFFB8LLU: | |
1425 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1426 | +// SP 5 | |
1427 | +// VERIFY SP | |
1428 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1429 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFB2LLU, 0xADCB6E8229EA7400LLU); | |
1430 | +case 0xFFFFFFFFFFFFFFB2LLU: | |
1431 | +// SP 1 | |
725 | 1432 | |
726 | 1433 | fprintf(stdout, ");\n"); |
1434 | + SP_ADD_VERIFY(1); | |
727 | 1435 | RET; |
728 | 1436 | |
729 | 1437 | |
730 | -case /*pushvar___*/0xAF0BA3C5CB400000LLU: | |
1438 | +case /*pushvar___*/0xAF0BA3C5CB400000LLU:// SP 0 | |
1439 | +// VERIFY SP | |
1440 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
731 | 1441 | |
1442 | + | |
732 | 1443 | PUSH(0LLU); |
1444 | +// SP 1 | |
1445 | +// VERIFY SP | |
1446 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
733 | 1447 | ACCESS_RETURN = POP; |
1448 | +// SP 0 | |
1449 | +// VERIFY SP | |
1450 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
734 | 1451 | |
735 | 1452 | |
736 | 1453 | fprintf(stdout, "PUSH("); |
737 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB7LLU, 0xADCB6E83172D0000LLU); | |
738 | -case 0xFFFFFFFFFFFFFFB7LLU: | |
1454 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1455 | +// SP 5 | |
1456 | +// VERIFY SP | |
1457 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1458 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFB1LLU, 0xADCB6E83172D0000LLU); | |
1459 | +case 0xFFFFFFFFFFFFFFB1LLU: | |
1460 | +// SP 1 | |
739 | 1461 | |
740 | 1462 | fprintf(stdout, ");\n"); |
1463 | + SP_ADD_VERIFY(1); | |
741 | 1464 | RET; |
742 | 1465 | |
743 | 1466 | |
744 | -case /*pusharg___*/0xAF0BA372D8800000LLU: | |
1467 | +case /*pusharg___*/0xAF0BA372D8800000LLU:// SP 0 | |
1468 | +// VERIFY SP | |
1469 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
745 | 1470 | |
1471 | + | |
746 | 1472 | PUSH(0LLU); |
1473 | +// SP 1 | |
1474 | +// VERIFY SP | |
1475 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
747 | 1476 | ACCESS_RETURN = POP; |
1477 | +// SP 0 | |
1478 | +// VERIFY SP | |
1479 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
748 | 1480 | |
749 | 1481 | |
750 | 1482 | fprintf(stdout, "PUSH("); |
751 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB6LLU, 0xADCB6E81CB620000LLU); | |
752 | -case 0xFFFFFFFFFFFFFFB6LLU: | |
1483 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1484 | +// SP 5 | |
1485 | +// VERIFY SP | |
1486 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1487 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFB0LLU, 0xADCB6E81CB620000LLU); | |
1488 | +case 0xFFFFFFFFFFFFFFB0LLU: | |
1489 | +// SP 1 | |
753 | 1490 | |
754 | 1491 | fprintf(stdout, ");\n"); |
1492 | + SP_ADD_VERIFY(1); | |
755 | 1493 | RET; |
756 | 1494 | |
757 | 1495 | |
758 | -case /*pushconst_*/0xAF0BA37AAA6EBC00LLU: | |
1496 | +case /*pushconst_*/0xAF0BA37AAA6EBC00LLU:// SP 0 | |
1497 | +// VERIFY SP | |
1498 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
759 | 1499 | |
1500 | + | |
760 | 1501 | PUSH(0LLU); |
1502 | +// SP 1 | |
1503 | +// VERIFY SP | |
1504 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
761 | 1505 | ACCESS_RETURN = POP; |
1506 | +// SP 0 | |
1507 | +// VERIFY SP | |
1508 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
762 | 1509 | |
763 | 1510 | |
764 | 1511 | fprintf(stdout, "PUSH("); |
765 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB5LLU, 0x81E8EAA6D0000000LLU); | |
766 | -case 0xFFFFFFFFFFFFFFB5LLU: | |
1512 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1513 | +// SP 5 | |
1514 | +// VERIFY SP | |
1515 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1516 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFAFLLU, 0x81E8EAA6D0000000LLU); | |
1517 | +case 0xFFFFFFFFFFFFFFAFLLU: | |
1518 | +// SP 1 | |
767 | 1519 | |
768 | 1520 | fputs("LLU);", stdout); |
1521 | + SP_ADD_VERIFY(1);/*SP_VERIFY();*/ | |
769 | 1522 | RET; |
770 | 1523 | |
771 | 1524 | |
772 | -case /*parsechar_*/0xADCB6E81E8DCB400LLU: | |
1525 | +case /*parsechar_*/0xADCB6E81E8DCB400LLU:// SP 0 | |
1526 | +// VERIFY SP | |
1527 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
773 | 1528 | |
774 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB4LLU, 0x8A0BC00000000000LLU); | |
775 | -case 0xFFFFFFFFFFFFFFB4LLU: | |
1529 | + | |
1530 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1531 | +// SP 5 | |
1532 | +// VERIFY SP | |
1533 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1534 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFAELLU, 0x8A0BC00000000000LLU); | |
1535 | +case 0xFFFFFFFFFFFFFFAELLU: | |
1536 | +// SP 1 | |
776 | 1537 | ACCESS_RETURN = POP; |
1538 | +// SP 0 | |
1539 | +// VERIFY SP | |
1540 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
777 | 1541 | |
778 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(39LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFB3LLU, 0xA1CBDE8C00000000LLU); | |
779 | -case 0xFFFFFFFFFFFFFFB3LLU: | |
1542 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1543 | +// SP 5 | |
1544 | +// VERIFY SP | |
1545 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1546 | +PUSH(39LLU);// SP 6 | |
1547 | +// VERIFY SP | |
1548 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1549 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFADLLU, 0xA1CBDE8C00000000LLU); | |
1550 | +case 0xFFFFFFFFFFFFFFADLLU: | |
1551 | +// SP 1 | |
780 | 1552 | |
781 | 1553 | RET; |
782 | 1554 | |
783 | 1555 | |
784 | -case /*parsenr___*/0xADCB6E829B400000LLU: | |
1556 | +case /*parsenr___*/0xADCB6E829B400000LLU:// SP 0 | |
1557 | +// VERIFY SP | |
1558 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
785 | 1559 | |
786 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFB2LLU, 0xBA692B7A8A6FB800LLU); | |
787 | -case 0xFFFFFFFFFFFFFFB2LLU: | |
788 | 1560 | |
1561 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1562 | +// SP 5 | |
1563 | +// VERIFY SP | |
1564 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1565 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFACLLU, 0xBA692B7A8A6FB800LLU); | |
1566 | +case 0xFFFFFFFFFFFFFFACLLU: | |
1567 | +// SP 1 | |
1568 | + | |
789 | 1569 | ACCESS_RETURN = 0; |
790 | - case 0xFFFFFFFFFFFFFFB1LLU: // loop to here | |
1570 | + case 0xFFFFFFFFFFFFFFABLLU: // loop to here | |
791 | 1571 | // predicate |
792 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFAFLLU, 0xAE08260000000000LLU); | |
793 | -case 0xFFFFFFFFFFFFFFAFLLU: | |
794 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFFAELLU, 0x92E7E48A4BC00000LLU); | |
795 | -case 0xFFFFFFFFFFFFFFAELLU: | |
796 | -if(!ACCESS_CURRENT) | |
797 | - JUMP(0xFFFFFFFFFFFFFFB0LLU); // skip loop | |
1572 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
1573 | +// SP 6 | |
1574 | +// VERIFY SP | |
1575 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1576 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
1577 | +// SP 11 | |
1578 | +// VERIFY SP | |
1579 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1580 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFA9LLU, 0xAE08260000000000LLU); | |
1581 | +case 0xFFFFFFFFFFFFFFA9LLU: | |
1582 | +// SP 7 | |
1583 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFA8LLU, 0x92E7E48A4BC00000LLU); | |
1584 | +case 0xFFFFFFFFFFFFFFA8LLU: | |
1585 | +// SP 2 | |
1586 | +if(!POP) | |
1587 | +// SP 1 | |
1588 | + JUMP(0xFFFFFFFFFFFFFFAALLU); // skip loop | |
798 | 1589 | // loop |
799 | 1590 | |
800 | - PUSH(0); // place-holder for result of block | |
801 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1591 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1592 | +// SP 2 | |
1593 | +// VERIFY SP | |
1594 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
802 | 1595 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
803 | 1596 | |
804 | 1597 | ACCESS_RETURN *= 10; |
805 | 1598 | ACCESS_RETURN += fgetc(stdin) - '0'; // XXX use get |
806 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1599 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1600 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1601 | +// SP 2 | |
807 | 1602 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
808 | - JUMP(0xFFFFFFFFFFFFFFB1LLU); // loop | |
809 | -case 0xFFFFFFFFFFFFFFB0LLU: // skip to here | |
1603 | +// SP 1 | |
1604 | +// VERIFY SP | |
1605 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1606 | + JUMP(0xFFFFFFFFFFFFFFABLLU); // loop | |
1607 | +case 0xFFFFFFFFFFFFFFAALLU: // skip to here | |
810 | 1608 | |
811 | 1609 | RET; |
812 | 1610 | |
813 | 1611 | |
814 | -case /*debugnr___*/0x7E07708A9B400000LLU: | |
1612 | +case /*debugnr___*/0x7E07708A9B400000LLU:// SP 0 | |
1613 | +// VERIFY SP | |
1614 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
815 | 1615 | |
1616 | + | |
816 | 1617 | ACCESS_RETURN = 0; |
817 | 1618 | for(register uint64_t i = 16; i > 0; i--) |
818 | 1619 | { |
@@ -824,26 +1625,43 @@ | ||
824 | 1625 | RET; |
825 | 1626 | |
826 | 1627 | |
827 | -case /*printnr___*/0xAED929BE9B400000LLU: | |
1628 | +case /*printnr___*/0xAED929BE9B400000LLU:// SP 0 | |
1629 | +// VERIFY SP | |
1630 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
828 | 1631 | |
1632 | + | |
829 | 1633 | ACCESS_RETURN = ACCESS_ARG(0); // pass-through argument |
830 | 1634 | fprintf(stdout, "%0lluLLU", (long long unsigned int)ACCESS_ARG(0)); |
831 | 1635 | RET; |
832 | 1636 | |
833 | 1637 | |
834 | -case /*printid___*/0xAED929BE47C00000LLU: | |
1638 | +case /*printid___*/0xAED929BE47C00000LLU:// SP 0 | |
1639 | +// VERIFY SP | |
1640 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
835 | 1641 | |
836 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(ACCESS_ARG(0)); | |
837 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFFADLLU, 0x7AAA28829BE47C00LLU); | |
838 | -case 0xFFFFFFFFFFFFFFADLLU: | |
839 | 1642 | |
1643 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1644 | +// SP 5 | |
1645 | +// VERIFY SP | |
1646 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1647 | +PUSH(ACCESS_ARG(0)); | |
1648 | +// SP 6 | |
1649 | +// VERIFY SP | |
1650 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1651 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFA7LLU, 0x7AAA28829BE47C00LLU); | |
1652 | +case 0xFFFFFFFFFFFFFFA7LLU: | |
1653 | +// SP 1 | |
1654 | + | |
840 | 1655 | ACCESS_RETURN = ACCESS_ARG(0); // pass-through argument |
841 | 1656 | fprintf(stdout, "0x%0llXLLU", (long long unsigned int)ACCESS_ARG(0)); |
842 | 1657 | RET; |
843 | 1658 | |
844 | 1659 | |
845 | -case /*debugid___*/0x7E07708A47C00000LLU: | |
1660 | +case /*debugid___*/0x7E07708A47C00000LLU:// SP 0 | |
1661 | +// VERIFY SP | |
1662 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
846 | 1663 | |
1664 | + | |
847 | 1665 | for(register uint64_t i = 10; i > 0; i--) |
848 | 1666 | { |
849 | 1667 | if(((ACCESS_ARG(0) >> (i * 6 - 2)) & 0x3F) < 1) |
@@ -863,8 +1681,11 @@ | ||
863 | 1681 | RET; |
864 | 1682 | |
865 | 1683 | |
866 | -case /*commentid_*/0x7AAA28829BE47C00LLU: | |
1684 | +case /*commentid_*/0x7AAA28829BE47C00LLU:// SP 0 | |
1685 | +// VERIFY SP | |
1686 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
867 | 1687 | |
1688 | + | |
868 | 1689 | fprintf(stdout, "/*"); |
869 | 1690 | for(register uint64_t i = 10; i > 0; i--) |
870 | 1691 | { |
@@ -886,8 +1707,11 @@ | ||
886 | 1707 | RET; |
887 | 1708 | |
888 | 1709 | |
889 | -case /*parseid___*/0xADCB6E8247C00000LLU: | |
1710 | +case /*parseid___*/0xADCB6E8247C00000LLU:// SP 0 | |
1711 | +// VERIFY SP | |
1712 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
890 | 1713 | |
1714 | + | |
891 | 1715 | c$$$ = fgetc(stdin); // XXX use get |
892 | 1716 | ACCESS_RETURN = 0; |
893 | 1717 | // A label consists of ten symbols each of which can be underscore, upper, dollar, lower, digit (this takes up 60 bits) - followed by up to 15 primes (4 bits). |
@@ -920,926 +1744,2038 @@ | ||
920 | 1744 | RET; |
921 | 1745 | |
922 | 1746 | |
923 | -case /*PARSEID___*/0x4014931491000000LLU: | |
1747 | +case /*PARSEID___*/0x4014931491000000LLU:// SP 0 | |
1748 | +// VERIFY SP | |
1749 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
924 | 1750 | |
925 | - CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFACLLU, 0xADCB6E8247C00000LLU); | |
926 | -case 0xFFFFFFFFFFFFFFACLLU: | |
927 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFFABLLU, 0xAED929BE47C00000LLU); | |
928 | -case 0xFFFFFFFFFFFFFFABLLU: | |
929 | 1751 | |
1752 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1753 | +// SP 5 | |
1754 | +// VERIFY SP | |
1755 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1756 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
1757 | +// SP 10 | |
1758 | +// VERIFY SP | |
1759 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1760 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFA6LLU, 0xADCB6E8247C00000LLU); | |
1761 | +case 0xFFFFFFFFFFFFFFA6LLU: | |
1762 | +// SP 6 | |
1763 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFFA5LLU, 0xAED929BE47C00000LLU); | |
1764 | +case 0xFFFFFFFFFFFFFFA5LLU: | |
1765 | +// SP 1 | |
1766 | + | |
930 | 1767 | fprintf(stdout, "%c", 58); |
931 | 1768 | ACCESS_RETURN = ACCESS_CURRENT; |
932 | 1769 | RET; |
933 | 1770 | |
934 | 1771 | |
935 | -case /*verbatim__*/0xC60B5D72F9280000LLU: | |
1772 | +case /*verbatim__*/0xC60B5D72F9280000LLU:// SP 0 | |
1773 | +// VERIFY SP | |
1774 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
936 | 1775 | |
937 | - case 0xFFFFFFFFFFFFFFAALLU: // loop to here | |
1776 | + | |
1777 | + case 0xFFFFFFFFFFFFFFA4LLU: // loop to here | |
938 | 1778 | // predicate |
939 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFA8LLU, 0xAE08260000000000LLU); | |
940 | -case 0xFFFFFFFFFFFFFFA8LLU: | |
941 | -PUSH(58LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFFA7LLU, 0xA60B000000000000LLU); | |
942 | -case 0xFFFFFFFFFFFFFFA7LLU: | |
943 | -if(!ACCESS_CURRENT) | |
944 | - JUMP(0xFFFFFFFFFFFFFFA9LLU); // skip loop | |
1779 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1780 | +// SP 5 | |
1781 | +// VERIFY SP | |
1782 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1783 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
1784 | +// SP 10 | |
1785 | +// VERIFY SP | |
1786 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1787 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFFA2LLU, 0xAE08260000000000LLU); | |
1788 | +case 0xFFFFFFFFFFFFFFA2LLU: | |
1789 | +// SP 6 | |
1790 | +PUSH(58LLU);// SP 7 | |
1791 | +// VERIFY SP | |
1792 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1793 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFFA1LLU, 0xA60B000000000000LLU); | |
1794 | +case 0xFFFFFFFFFFFFFFA1LLU: | |
1795 | +// SP 1 | |
1796 | +if(!POP) | |
1797 | +// SP 0 | |
1798 | + JUMP(0xFFFFFFFFFFFFFFA3LLU); // skip loop | |
945 | 1799 | // loop |
946 | 1800 | |
947 | - PUSH(0); // place-holder for result of block | |
948 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1801 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1802 | +// SP 1 | |
1803 | +// VERIFY SP | |
1804 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
949 | 1805 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
950 | 1806 | |
951 | 1807 | // predicate |
952 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFFA4LLU, 0x81E8EA0000000000LLU); | |
953 | -case 0xFFFFFFFFFFFFFFA4LLU: | |
954 | -PUSH(255LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFFA3LLU, 0x8AFB400000000000LLU); | |
955 | -case 0xFFFFFFFFFFFFFFA3LLU: | |
956 | -if(!ACCESS_CURRENT) | |
957 | - JUMP(0xFFFFFFFFFFFFFFA6LLU); // skip consequent | |
1808 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
1809 | +// SP 6 | |
1810 | +// VERIFY SP | |
1811 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1812 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
1813 | +// SP 11 | |
1814 | +// VERIFY SP | |
1815 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1816 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF9ELLU, 0x81E8EA0000000000LLU); | |
1817 | +case 0xFFFFFFFFFFFFFF9ELLU: | |
1818 | +// SP 7 | |
1819 | +PUSH(255LLU);// SP 8 | |
1820 | +// VERIFY SP | |
1821 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1822 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF9DLLU, 0x8AFB400000000000LLU); | |
1823 | +case 0xFFFFFFFFFFFFFF9DLLU: | |
1824 | +// SP 2 | |
1825 | +if(!POP) | |
1826 | +// SP 1 | |
1827 | + JUMP(0xFFFFFFFFFFFFFFA0LLU); // skip consequent | |
958 | 1828 | // consequent |
959 | 1829 | |
960 | - PUSH(0); // place-holder for result of block | |
961 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1830 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1831 | +// SP 2 | |
1832 | +// VERIFY SP | |
1833 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
962 | 1834 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
963 | 1835 | |
964 | 1836 | fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); |
965 | 1837 | fprintf(stderr, "EOF in verbatim\n"); |
966 | 1838 | exit(-1); |
967 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1839 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1840 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1841 | +// SP 2 | |
968 | 1842 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
969 | - JUMP(0xFFFFFFFFFFFFFFA5LLU); // skip alternative | |
970 | -case 0xFFFFFFFFFFFFFFA6LLU: // alternative | |
1843 | +// SP 1 | |
1844 | +// VERIFY SP | |
1845 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1846 | + JUMP(0xFFFFFFFFFFFFFF9FLLU); // skip alternative | |
1847 | +case 0xFFFFFFFFFFFFFFA0LLU: // alternative | |
971 | 1848 | |
972 | 1849 | |
973 | - PUSH(0); // place-holder for result of block | |
974 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1850 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1851 | +// SP 2 | |
1852 | +// VERIFY SP | |
1853 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
975 | 1854 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
976 | 1855 | |
977 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1856 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1857 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1858 | +// SP 2 | |
978 | 1859 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
979 | -case 0xFFFFFFFFFFFFFFA5LLU: // skip to here | |
1860 | +// SP 1 | |
1861 | +// VERIFY SP | |
1862 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1863 | +case 0xFFFFFFFFFFFFFF9FLLU: // skip to here | |
980 | 1864 | |
981 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1865 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1866 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1867 | +// SP 1 | |
982 | 1868 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
983 | - JUMP(0xFFFFFFFFFFFFFFAALLU); // loop | |
984 | -case 0xFFFFFFFFFFFFFFA9LLU: // skip to here | |
1869 | +// SP 0 | |
1870 | +// VERIFY SP | |
1871 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1872 | + JUMP(0xFFFFFFFFFFFFFFA4LLU); // loop | |
1873 | +case 0xFFFFFFFFFFFFFFA3LLU: // skip to here | |
985 | 1874 | |
986 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(58LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFA2LLU, 0xA1CBDE8C00000000LLU); | |
987 | -case 0xFFFFFFFFFFFFFFA2LLU: | |
1875 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1876 | +// SP 5 | |
1877 | +// VERIFY SP | |
1878 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1879 | +PUSH(58LLU);// SP 6 | |
1880 | +// VERIFY SP | |
1881 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1882 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF9CLLU, 0xA1CBDE8C00000000LLU); | |
1883 | +case 0xFFFFFFFFFFFFFF9CLLU: | |
1884 | +// SP 1 | |
988 | 1885 | |
989 | 1886 | RET; |
990 | 1887 | |
991 | 1888 | |
992 | -case /*comment___*/0x7AAA28829BC00000LLU: | |
1889 | +case /*comment___*/0x7AAA28829BC00000LLU:// SP 0 | |
1890 | +// VERIFY SP | |
1891 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
993 | 1892 | |
994 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFA1LLU, 0xAF0BC00000000000LLU); | |
995 | -case 0xFFFFFFFFFFFFFFA1LLU: | |
996 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFFA0LLU, 0xAF0BC00000000000LLU); | |
997 | -case 0xFFFFFFFFFFFFFFA0LLU: | |
998 | 1893 | |
999 | - case 0xFFFFFFFFFFFFFF9FLLU: // loop to here | |
1000 | - // predicate | |
1001 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); PUSH(10LLU);CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF9DLLU, 0xAE08260000000000LLU); | |
1002 | -case 0xFFFFFFFFFFFFFF9DLLU: | |
1003 | -CALLEND(2LLU, 0xFFFFFFFFFFFFFF9CLLU, 0xA60B000000000000LLU); | |
1004 | -case 0xFFFFFFFFFFFFFF9CLLU: | |
1005 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF9BLLU, 0xAE08260000000000LLU); | |
1894 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
1895 | +// SP 5 | |
1896 | +// VERIFY SP | |
1897 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1898 | +PUSH(47LLU);// SP 6 | |
1899 | +// VERIFY SP | |
1900 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1901 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF9BLLU, 0xAF0BC00000000000LLU); | |
1006 | 1902 | case 0xFFFFFFFFFFFFFF9BLLU: |
1007 | -PUSH(255LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFF9ALLU, 0x9E0B000000000000LLU); | |
1903 | +// SP 1 | |
1904 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
1905 | +// SP 6 | |
1906 | +// VERIFY SP | |
1907 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1908 | +PUSH(47LLU);// SP 7 | |
1909 | +// VERIFY SP | |
1910 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1911 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF9ALLU, 0xAF0BC00000000000LLU); | |
1008 | 1912 | case 0xFFFFFFFFFFFFFF9ALLU: |
1009 | -CALLEND(2LLU, 0xFFFFFFFFFFFFFF99LLU, 0x7297C00000000000LLU); | |
1010 | -case 0xFFFFFFFFFFFFFF99LLU: | |
1011 | -if(!ACCESS_CURRENT) | |
1012 | - JUMP(0xFFFFFFFFFFFFFF9ELLU); // skip loop | |
1913 | +// SP 2 | |
1914 | + | |
1915 | + case 0xFFFFFFFFFFFFFF99LLU: // loop to here | |
1916 | + // predicate | |
1917 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
1918 | +// SP 7 | |
1919 | +// VERIFY SP | |
1920 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1921 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
1922 | +// SP 12 | |
1923 | +// VERIFY SP | |
1924 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1925 | +PUSH(10LLU);// SP 13 | |
1926 | +// VERIFY SP | |
1927 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1928 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 14 | |
1929 | +// SP 18 | |
1930 | +// VERIFY SP | |
1931 | +if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1932 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF97LLU, 0xAE08260000000000LLU); | |
1933 | +case 0xFFFFFFFFFFFFFF97LLU: | |
1934 | +// SP 14 | |
1935 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF96LLU, 0xA60B000000000000LLU); | |
1936 | +case 0xFFFFFFFFFFFFFF96LLU: | |
1937 | +// SP 8 | |
1938 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 9 | |
1939 | +// SP 13 | |
1940 | +// VERIFY SP | |
1941 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1942 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 14 | |
1943 | +// SP 18 | |
1944 | +// VERIFY SP | |
1945 | +if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1946 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF95LLU, 0xAE08260000000000LLU); | |
1947 | +case 0xFFFFFFFFFFFFFF95LLU: | |
1948 | +// SP 14 | |
1949 | +PUSH(255LLU);// SP 15 | |
1950 | +// VERIFY SP | |
1951 | +if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1952 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF94LLU, 0x9E0B000000000000LLU); | |
1953 | +case 0xFFFFFFFFFFFFFF94LLU: | |
1954 | +// SP 9 | |
1955 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF93LLU, 0x7297C00000000000LLU); | |
1956 | +case 0xFFFFFFFFFFFFFF93LLU: | |
1957 | +// SP 3 | |
1958 | +if(!POP) | |
1959 | +// SP 2 | |
1960 | + JUMP(0xFFFFFFFFFFFFFF98LLU); // skip loop | |
1013 | 1961 | // loop |
1014 | 1962 | |
1015 | - PUSH(0); // place-holder for result of block | |
1016 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1963 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
1964 | +// SP 3 | |
1965 | +// VERIFY SP | |
1966 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1017 | 1967 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1018 | 1968 | |
1019 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF98LLU, 0x81E8EA0000000000LLU); | |
1020 | -case 0xFFFFFFFFFFFFFF98LLU: | |
1969 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
1970 | +// SP 8 | |
1971 | +// VERIFY SP | |
1972 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1973 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF92LLU, 0x81E8EA0000000000LLU); | |
1974 | +case 0xFFFFFFFFFFFFFF92LLU: | |
1975 | +// SP 4 | |
1021 | 1976 | |
1022 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1977 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
1978 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
1979 | +// SP 3 | |
1023 | 1980 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1024 | - JUMP(0xFFFFFFFFFFFFFF9FLLU); // loop | |
1025 | -case 0xFFFFFFFFFFFFFF9ELLU: // skip to here | |
1981 | +// SP 2 | |
1982 | +// VERIFY SP | |
1983 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1984 | + JUMP(0xFFFFFFFFFFFFFF99LLU); // loop | |
1985 | +case 0xFFFFFFFFFFFFFF98LLU: // skip to here | |
1026 | 1986 | |
1027 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF97LLU, 0x81E8EA0000000000LLU); | |
1028 | -case 0xFFFFFFFFFFFFFF97LLU: | |
1987 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
1988 | +// SP 7 | |
1989 | +// VERIFY SP | |
1990 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1991 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF91LLU, 0x81E8EA0000000000LLU); | |
1992 | +case 0xFFFFFFFFFFFFFF91LLU: | |
1993 | +// SP 3 | |
1029 | 1994 | |
1030 | 1995 | RET; |
1031 | 1996 | |
1032 | 1997 | |
1033 | -case /*comment___'*/0x7AAA28829BC00001LLU: | |
1998 | +case /*comment___'*/0x7AAA28829BC00001LLU:// SP 0 | |
1999 | +// VERIFY SP | |
2000 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1034 | 2001 | |
1035 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF96LLU, 0xAF0BC00000000000LLU); | |
1036 | -case 0xFFFFFFFFFFFFFF96LLU: | |
1037 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(42LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF95LLU, 0xAF0BC00000000000LLU); | |
1038 | -case 0xFFFFFFFFFFFFFF95LLU: | |
1039 | 2002 | |
1040 | - case 0xFFFFFFFFFFFFFF94LLU: // loop to here | |
1041 | - // predicate | |
1042 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); PUSH(42LLU);CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF92LLU, 0x81E8EA0000000000LLU); | |
1043 | -case 0xFFFFFFFFFFFFFF92LLU: | |
1044 | -CALLEND(2LLU, 0xFFFFFFFFFFFFFF91LLU, 0xA60B000000000000LLU); | |
1045 | -case 0xFFFFFFFFFFFFFF91LLU: | |
1046 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF90LLU, 0xAE08260000000000LLU); | |
2003 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
2004 | +// SP 5 | |
2005 | +// VERIFY SP | |
2006 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2007 | +PUSH(47LLU);// SP 6 | |
2008 | +// VERIFY SP | |
2009 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2010 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF90LLU, 0xAF0BC00000000000LLU); | |
1047 | 2011 | case 0xFFFFFFFFFFFFFF90LLU: |
1048 | -CALLEND(2LLU, 0xFFFFFFFFFFFFFF8FLLU, 0xA60B000000000000LLU); | |
2012 | +// SP 1 | |
2013 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
2014 | +// SP 6 | |
2015 | +// VERIFY SP | |
2016 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2017 | +PUSH(42LLU);// SP 7 | |
2018 | +// VERIFY SP | |
2019 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2020 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF8FLLU, 0xAF0BC00000000000LLU); | |
1049 | 2021 | case 0xFFFFFFFFFFFFFF8FLLU: |
1050 | -CALLEND(2LLU, 0xFFFFFFFFFFFFFF8ELLU, 0xAAD0000000000000LLU); | |
1051 | -case 0xFFFFFFFFFFFFFF8ELLU: | |
1052 | -if(!ACCESS_CURRENT) | |
1053 | - JUMP(0xFFFFFFFFFFFFFF93LLU); // skip loop | |
2022 | +// SP 2 | |
2023 | + | |
2024 | + case 0xFFFFFFFFFFFFFF8ELLU: // loop to here | |
2025 | + // predicate | |
2026 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
2027 | +// SP 7 | |
2028 | +// VERIFY SP | |
2029 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2030 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
2031 | +// SP 12 | |
2032 | +// VERIFY SP | |
2033 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2034 | +PUSH(42LLU);// SP 13 | |
2035 | +// VERIFY SP | |
2036 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2037 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 14 | |
2038 | +// SP 18 | |
2039 | +// VERIFY SP | |
2040 | +if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2041 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF8CLLU, 0x81E8EA0000000000LLU); | |
2042 | +case 0xFFFFFFFFFFFFFF8CLLU: | |
2043 | +// SP 14 | |
2044 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF8BLLU, 0xA60B000000000000LLU); | |
2045 | +case 0xFFFFFFFFFFFFFF8BLLU: | |
2046 | +// SP 8 | |
2047 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 9 | |
2048 | +// SP 13 | |
2049 | +// VERIFY SP | |
2050 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2051 | +PUSH(47LLU);// SP 14 | |
2052 | +// VERIFY SP | |
2053 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2054 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 15 | |
2055 | +// SP 19 | |
2056 | +// VERIFY SP | |
2057 | +if(sp$$$ != 19LLU) { fprintf(stderr, "verify failed, sp %llu != 19 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2058 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF8ALLU, 0xAE08260000000000LLU); | |
2059 | +case 0xFFFFFFFFFFFFFF8ALLU: | |
2060 | +// SP 15 | |
2061 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF89LLU, 0xA60B000000000000LLU); | |
2062 | +case 0xFFFFFFFFFFFFFF89LLU: | |
2063 | +// SP 9 | |
2064 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF88LLU, 0xAAD0000000000000LLU); | |
2065 | +case 0xFFFFFFFFFFFFFF88LLU: | |
2066 | +// SP 3 | |
2067 | +if(!POP) | |
2068 | +// SP 2 | |
2069 | + JUMP(0xFFFFFFFFFFFFFF8DLLU); // skip loop | |
1054 | 2070 | // loop |
1055 | 2071 | |
1056 | - PUSH(0); // place-holder for result of block | |
1057 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2072 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2073 | +// SP 3 | |
2074 | +// VERIFY SP | |
2075 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1058 | 2076 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1059 | 2077 | |
1060 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2078 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2079 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2080 | +// SP 3 | |
1061 | 2081 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1062 | - JUMP(0xFFFFFFFFFFFFFF94LLU); // loop | |
1063 | -case 0xFFFFFFFFFFFFFF93LLU: // skip to here | |
2082 | +// SP 2 | |
2083 | +// VERIFY SP | |
2084 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2085 | + JUMP(0xFFFFFFFFFFFFFF8ELLU); // loop | |
2086 | +case 0xFFFFFFFFFFFFFF8DLLU: // skip to here | |
1064 | 2087 | |
1065 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF8DLLU, 0x81E8EA0000000000LLU); | |
1066 | -case 0xFFFFFFFFFFFFFF8DLLU: | |
2088 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
2089 | +// SP 7 | |
2090 | +// VERIFY SP | |
2091 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2092 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF87LLU, 0x81E8EA0000000000LLU); | |
2093 | +case 0xFFFFFFFFFFFFFF87LLU: | |
2094 | +// SP 3 | |
1067 | 2095 | |
1068 | 2096 | RET; |
1069 | 2097 | |
1070 | 2098 | |
1071 | -case /*skipws____*/0xBA692BCAE0000000LLU: | |
2099 | +case /*skipws____*/0xBA692BCAE0000000LLU:// SP 0 | |
2100 | +// VERIFY SP | |
2101 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1072 | 2102 | |
1073 | - case 0xFFFFFFFFFFFFFF8CLLU: // loop to here | |
2103 | + | |
2104 | + case 0xFFFFFFFFFFFFFF86LLU: // loop to here | |
1074 | 2105 | // predicate |
1075 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF8ALLU, 0xAE08260000000000LLU); | |
1076 | -case 0xFFFFFFFFFFFFFF8ALLU: | |
1077 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFF89LLU, 0x92EBAB71E8000000LLU); | |
1078 | -case 0xFFFFFFFFFFFFFF89LLU: | |
1079 | -if(!ACCESS_CURRENT) | |
1080 | - JUMP(0xFFFFFFFFFFFFFF8BLLU); // skip loop | |
2106 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
2107 | +// SP 5 | |
2108 | +// VERIFY SP | |
2109 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2110 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
2111 | +// SP 10 | |
2112 | +// VERIFY SP | |
2113 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2114 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF84LLU, 0xAE08260000000000LLU); | |
2115 | +case 0xFFFFFFFFFFFFFF84LLU: | |
2116 | +// SP 6 | |
2117 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF83LLU, 0x92EBAB71E8000000LLU); | |
2118 | +case 0xFFFFFFFFFFFFFF83LLU: | |
2119 | +// SP 1 | |
2120 | +if(!POP) | |
2121 | +// SP 0 | |
2122 | + JUMP(0xFFFFFFFFFFFFFF85LLU); // skip loop | |
1081 | 2123 | // loop |
1082 | 2124 | |
1083 | - PUSH(0); // place-holder for result of block | |
1084 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2125 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2126 | +// SP 1 | |
2127 | +// VERIFY SP | |
2128 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1085 | 2129 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1086 | 2130 | |
1087 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF88LLU, 0x81E8EA0000000000LLU); | |
1088 | -case 0xFFFFFFFFFFFFFF88LLU: | |
2131 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
2132 | +// SP 6 | |
2133 | +// VERIFY SP | |
2134 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2135 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF82LLU, 0x81E8EA0000000000LLU); | |
2136 | +case 0xFFFFFFFFFFFFFF82LLU: | |
2137 | +// SP 2 | |
1089 | 2138 | |
1090 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2139 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2140 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2141 | +// SP 1 | |
1091 | 2142 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1092 | - JUMP(0xFFFFFFFFFFFFFF8CLLU); // loop | |
1093 | -case 0xFFFFFFFFFFFFFF8BLLU: // skip to here | |
2143 | +// SP 0 | |
2144 | +// VERIFY SP | |
2145 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2146 | + JUMP(0xFFFFFFFFFFFFFF86LLU); // loop | |
2147 | +case 0xFFFFFFFFFFFFFF85LLU: // skip to here | |
1094 | 2148 | |
1095 | 2149 | RET; |
1096 | 2150 | |
1097 | 2151 | |
1098 | 2152 | // returns 1 if comment found, 0 otherwise |
1099 | -case /*skipcmnt__*/0xBA692B7A8A6F0000LLU: | |
2153 | +case /*skipcmnt__*/0xBA692B7A8A6F0000LLU:// SP 0 | |
2154 | +// VERIFY SP | |
2155 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1100 | 2156 | |
1101 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF87LLU, 0xBA692BCAE0000000LLU); | |
1102 | -case 0xFFFFFFFFFFFFFF87LLU: | |
1103 | 2157 | |
2158 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
2159 | +// SP 5 | |
2160 | +// VERIFY SP | |
2161 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2162 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF81LLU, 0xBA692BCAE0000000LLU); | |
2163 | +case 0xFFFFFFFFFFFFFF81LLU: | |
2164 | +// SP 1 | |
1104 | 2165 | |
2166 | + | |
1105 | 2167 | // predicate |
1106 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF84LLU, 0xA1CBDE8EAAEF0000LLU); | |
1107 | -case 0xFFFFFFFFFFFFFF84LLU: | |
1108 | -if(!ACCESS_CURRENT) | |
1109 | - JUMP(0xFFFFFFFFFFFFFF86LLU); // skip consequent | |
2168 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
2169 | +// SP 6 | |
2170 | +// VERIFY SP | |
2171 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2172 | +PUSH(47LLU);// SP 7 | |
2173 | +// VERIFY SP | |
2174 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2175 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF7ELLU, 0xA1CBDE8EAAEF0000LLU); | |
2176 | +case 0xFFFFFFFFFFFFFF7ELLU: | |
2177 | +// SP 2 | |
2178 | +if(!POP) | |
2179 | +// SP 1 | |
2180 | + JUMP(0xFFFFFFFFFFFFFF80LLU); // skip consequent | |
1110 | 2181 | // consequent |
1111 | 2182 | |
1112 | - PUSH(0); // place-holder for result of block | |
1113 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2183 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2184 | +// SP 2 | |
2185 | +// VERIFY SP | |
2186 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1114 | 2187 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1115 | 2188 | |
1116 | 2189 | // predicate |
1117 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF81LLU, 0xA1CBDE8EAAEF0000LLU); | |
1118 | -case 0xFFFFFFFFFFFFFF81LLU: | |
1119 | -if(!ACCESS_CURRENT) | |
1120 | - JUMP(0xFFFFFFFFFFFFFF83LLU); // skip consequent | |
2190 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
2191 | +// SP 7 | |
2192 | +// VERIFY SP | |
2193 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2194 | +PUSH(47LLU);// SP 8 | |
2195 | +// VERIFY SP | |
2196 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2197 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF7BLLU, 0xA1CBDE8EAAEF0000LLU); | |
2198 | +case 0xFFFFFFFFFFFFFF7BLLU: | |
2199 | +// SP 3 | |
2200 | +if(!POP) | |
2201 | +// SP 2 | |
2202 | + JUMP(0xFFFFFFFFFFFFFF7DLLU); // skip consequent | |
1121 | 2203 | // consequent |
1122 | 2204 | |
1123 | - PUSH(0); // place-holder for result of block | |
1124 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2205 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2206 | +// SP 3 | |
2207 | +// VERIFY SP | |
2208 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1125 | 2209 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1126 | 2210 | |
1127 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF80LLU, 0x7AAA28829BC00000LLU); | |
1128 | -case 0xFFFFFFFFFFFFFF80LLU: | |
2211 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
2212 | +// SP 8 | |
2213 | +// VERIFY SP | |
2214 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2215 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF7ALLU, 0x7AAA28829BC00000LLU); | |
2216 | +case 0xFFFFFFFFFFFFFF7ALLU: | |
2217 | +// SP 4 | |
1129 | 2218 | |
1130 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2219 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2220 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2221 | +// SP 3 | |
1131 | 2222 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1132 | - JUMP(0xFFFFFFFFFFFFFF82LLU); // skip alternative | |
1133 | -case 0xFFFFFFFFFFFFFF83LLU: // alternative | |
2223 | +// SP 2 | |
2224 | +// VERIFY SP | |
2225 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2226 | + JUMP(0xFFFFFFFFFFFFFF7CLLU); // skip alternative | |
2227 | +case 0xFFFFFFFFFFFFFF7DLLU: // alternative | |
1134 | 2228 | |
1135 | 2229 | |
1136 | - PUSH(0); // place-holder for result of block | |
1137 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2230 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2231 | +// SP 3 | |
2232 | +// VERIFY SP | |
2233 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1138 | 2234 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1139 | 2235 | |
1140 | 2236 | // predicate |
1141 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(42LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF7DLLU, 0xA1CBDE8EAAEF0000LLU); | |
1142 | -case 0xFFFFFFFFFFFFFF7DLLU: | |
1143 | -if(!ACCESS_CURRENT) | |
1144 | - JUMP(0xFFFFFFFFFFFFFF7FLLU); // skip consequent | |
2237 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
2238 | +// SP 8 | |
2239 | +// VERIFY SP | |
2240 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2241 | +PUSH(42LLU);// SP 9 | |
2242 | +// VERIFY SP | |
2243 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2244 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF77LLU, 0xA1CBDE8EAAEF0000LLU); | |
2245 | +case 0xFFFFFFFFFFFFFF77LLU: | |
2246 | +// SP 4 | |
2247 | +if(!POP) | |
2248 | +// SP 3 | |
2249 | + JUMP(0xFFFFFFFFFFFFFF79LLU); // skip consequent | |
1145 | 2250 | // consequent |
1146 | 2251 | |
1147 | - PUSH(0); // place-holder for result of block | |
1148 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2252 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2253 | +// SP 4 | |
2254 | +// VERIFY SP | |
2255 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1149 | 2256 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1150 | 2257 | |
1151 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF7CLLU, 0x7AAA28829BC00001LLU); | |
1152 | -case 0xFFFFFFFFFFFFFF7CLLU: | |
2258 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 5 | |
2259 | +// SP 9 | |
2260 | +// VERIFY SP | |
2261 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2262 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF76LLU, 0x7AAA28829BC00001LLU); | |
2263 | +case 0xFFFFFFFFFFFFFF76LLU: | |
2264 | +// SP 5 | |
1153 | 2265 | |
1154 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2266 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2267 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2268 | +// SP 4 | |
1155 | 2269 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1156 | - JUMP(0xFFFFFFFFFFFFFF7ELLU); // skip alternative | |
1157 | -case 0xFFFFFFFFFFFFFF7FLLU: // alternative | |
2270 | +// SP 3 | |
2271 | +// VERIFY SP | |
2272 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2273 | + JUMP(0xFFFFFFFFFFFFFF78LLU); // skip alternative | |
2274 | +case 0xFFFFFFFFFFFFFF79LLU: // alternative | |
1158 | 2275 | |
1159 | 2276 | |
1160 | - PUSH(0); // place-holder for result of block | |
1161 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2277 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2278 | +// SP 4 | |
2279 | +// VERIFY SP | |
2280 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1162 | 2281 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1163 | 2282 | |
1164 | 2283 | fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); |
1165 | 2284 | fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get |
1166 | 2285 | exit(-1); |
1167 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2286 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2287 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2288 | +// SP 4 | |
1168 | 2289 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1169 | -case 0xFFFFFFFFFFFFFF7ELLU: // skip to here | |
2290 | +// SP 3 | |
2291 | +// VERIFY SP | |
2292 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2293 | +case 0xFFFFFFFFFFFFFF78LLU: // skip to here | |
1170 | 2294 | |
1171 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2295 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2296 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2297 | +// SP 3 | |
1172 | 2298 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1173 | -case 0xFFFFFFFFFFFFFF82LLU: // skip to here | |
2299 | +// SP 2 | |
2300 | +// VERIFY SP | |
2301 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2302 | +case 0xFFFFFFFFFFFFFF7CLLU: // skip to here | |
1174 | 2303 | |
1175 | 2304 | PUSH(1LLU); |
2305 | +// SP 3 | |
2306 | +// VERIFY SP | |
2307 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1176 | 2308 | ACCESS_RETURN = POP; |
2309 | +// SP 2 | |
2310 | +// VERIFY SP | |
2311 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1177 | 2312 | |
1178 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2313 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2314 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2315 | +// SP 2 | |
1179 | 2316 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1180 | - JUMP(0xFFFFFFFFFFFFFF85LLU); // skip alternative | |
1181 | -case 0xFFFFFFFFFFFFFF86LLU: // alternative | |
2317 | +// SP 1 | |
2318 | +// VERIFY SP | |
2319 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2320 | + JUMP(0xFFFFFFFFFFFFFF7FLLU); // skip alternative | |
2321 | +case 0xFFFFFFFFFFFFFF80LLU: // alternative | |
1182 | 2322 | |
1183 | 2323 | |
1184 | - PUSH(0); // place-holder for result of block | |
1185 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2324 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2325 | +// SP 2 | |
2326 | +// VERIFY SP | |
2327 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1186 | 2328 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1187 | 2329 | |
1188 | 2330 | PUSH(0LLU); |
2331 | +// SP 3 | |
2332 | +// VERIFY SP | |
2333 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1189 | 2334 | ACCESS_RETURN = POP; |
2335 | +// SP 2 | |
2336 | +// VERIFY SP | |
2337 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1190 | 2338 | |
1191 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2339 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2340 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2341 | +// SP 2 | |
1192 | 2342 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1193 | -case 0xFFFFFFFFFFFFFF85LLU: // skip to here | |
2343 | +// SP 1 | |
2344 | +// VERIFY SP | |
2345 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2346 | +case 0xFFFFFFFFFFFFFF7FLLU: // skip to here | |
1194 | 2347 | |
1195 | 2348 | RET; |
1196 | 2349 | |
1197 | 2350 | |
1198 | -case /*skipcmnts_*/0xBA692B7A8A6FB800LLU: | |
2351 | +case /*skipcmnts_*/0xBA692B7A8A6FB800LLU:// SP 0 | |
2352 | +// VERIFY SP | |
2353 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1199 | 2354 | |
1200 | - case 0xFFFFFFFFFFFFFF7BLLU: // loop to here | |
2355 | + | |
2356 | + case 0xFFFFFFFFFFFFFF75LLU: // loop to here | |
1201 | 2357 | // predicate |
1202 | -CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF79LLU, 0xBA692B7A8A6F0000LLU); | |
1203 | -case 0xFFFFFFFFFFFFFF79LLU: | |
1204 | -if(!ACCESS_CURRENT) | |
1205 | - JUMP(0xFFFFFFFFFFFFFF7ALLU); // skip loop | |
2358 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
2359 | +// SP 5 | |
2360 | +// VERIFY SP | |
2361 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2362 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF73LLU, 0xBA692B7A8A6F0000LLU); | |
2363 | +case 0xFFFFFFFFFFFFFF73LLU: | |
2364 | +// SP 1 | |
2365 | +if(!POP) | |
2366 | +// SP 0 | |
2367 | + JUMP(0xFFFFFFFFFFFFFF74LLU); // skip loop | |
1206 | 2368 | // loop |
1207 | 2369 | |
1208 | - PUSH(0); // place-holder for result of block | |
1209 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2370 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2371 | +// SP 1 | |
2372 | +// VERIFY SP | |
2373 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1210 | 2374 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1211 | 2375 | |
1212 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2376 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2377 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2378 | +// SP 1 | |
1213 | 2379 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1214 | - JUMP(0xFFFFFFFFFFFFFF7BLLU); // loop | |
1215 | -case 0xFFFFFFFFFFFFFF7ALLU: // skip to here | |
2380 | +// SP 0 | |
2381 | +// VERIFY SP | |
2382 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2383 | + JUMP(0xFFFFFFFFFFFFFF75LLU); // loop | |
2384 | +case 0xFFFFFFFFFFFFFF74LLU: // skip to here | |
1216 | 2385 | |
1217 | 2386 | RET; |
1218 | 2387 | |
1219 | 2388 | |
1220 | -case /*parsebody_*/0xADCB6E81DA9FD000LLU: | |
2389 | +case /*parsebody_*/0xADCB6E81DA9FD000LLU:// SP 0 | |
2390 | +// VERIFY SP | |
2391 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1221 | 2392 | |
1222 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF78LLU, 0xBA692B7A8A6FB800LLU); | |
1223 | -case 0xFFFFFFFFFFFFFF78LLU: | |
1224 | 2393 | |
1225 | - case 0xFFFFFFFFFFFFFF77LLU: // loop to here | |
2394 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
2395 | +// SP 5 | |
2396 | +// VERIFY SP | |
2397 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2398 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF72LLU, 0xBA692B7A8A6FB800LLU); | |
2399 | +case 0xFFFFFFFFFFFFFF72LLU: | |
2400 | +// SP 1 | |
2401 | + | |
2402 | + case 0xFFFFFFFFFFFFFF71LLU: // loop to here | |
1226 | 2403 | // predicate |
1227 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); PUSH(125LLU);CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF75LLU, 0xAE08260000000000LLU); | |
1228 | -case 0xFFFFFFFFFFFFFF75LLU: | |
1229 | -CALLEND(2LLU, 0xFFFFFFFFFFFFFF74LLU, 0xA60B000000000000LLU); | |
1230 | -case 0xFFFFFFFFFFFFFF74LLU: | |
1231 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF73LLU, 0xAE08260000000000LLU); | |
1232 | -case 0xFFFFFFFFFFFFFF73LLU: | |
1233 | -PUSH(255LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFF72LLU, 0x9E0B000000000000LLU); | |
1234 | -case 0xFFFFFFFFFFFFFF72LLU: | |
1235 | -CALLEND(2LLU, 0xFFFFFFFFFFFFFF71LLU, 0x7297C00000000000LLU); | |
1236 | -case 0xFFFFFFFFFFFFFF71LLU: | |
1237 | -if(!ACCESS_CURRENT) | |
1238 | - JUMP(0xFFFFFFFFFFFFFF76LLU); // skip loop | |
2404 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
2405 | +// SP 6 | |
2406 | +// VERIFY SP | |
2407 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2408 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
2409 | +// SP 11 | |
2410 | +// VERIFY SP | |
2411 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2412 | +PUSH(125LLU);// SP 12 | |
2413 | +// VERIFY SP | |
2414 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2415 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 13 | |
2416 | +// SP 17 | |
2417 | +// VERIFY SP | |
2418 | +if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2419 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF6FLLU, 0xAE08260000000000LLU); | |
2420 | +case 0xFFFFFFFFFFFFFF6FLLU: | |
2421 | +// SP 13 | |
2422 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF6ELLU, 0xA60B000000000000LLU); | |
2423 | +case 0xFFFFFFFFFFFFFF6ELLU: | |
2424 | +// SP 7 | |
2425 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
2426 | +// SP 12 | |
2427 | +// VERIFY SP | |
2428 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2429 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 13 | |
2430 | +// SP 17 | |
2431 | +// VERIFY SP | |
2432 | +if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2433 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF6DLLU, 0xAE08260000000000LLU); | |
2434 | +case 0xFFFFFFFFFFFFFF6DLLU: | |
2435 | +// SP 13 | |
2436 | +PUSH(255LLU);// SP 14 | |
2437 | +// VERIFY SP | |
2438 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2439 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF6CLLU, 0x9E0B000000000000LLU); | |
2440 | +case 0xFFFFFFFFFFFFFF6CLLU: | |
2441 | +// SP 8 | |
2442 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF6BLLU, 0x7297C00000000000LLU); | |
2443 | +case 0xFFFFFFFFFFFFFF6BLLU: | |
2444 | +// SP 2 | |
2445 | +if(!POP) | |
2446 | +// SP 1 | |
2447 | + JUMP(0xFFFFFFFFFFFFFF70LLU); // skip loop | |
1239 | 2448 | // loop |
1240 | 2449 | |
1241 | - PUSH(0); // place-holder for result of block | |
1242 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2450 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2451 | +// SP 2 | |
2452 | +// VERIFY SP | |
2453 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1243 | 2454 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1244 | 2455 | |
1245 | 2456 | // predicate |
1246 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF6ELLU, 0xAE08260000000000LLU); | |
1247 | -case 0xFFFFFFFFFFFFFF6ELLU: | |
1248 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFF6DLLU, 0x92E727AE37000000LLU); | |
1249 | -case 0xFFFFFFFFFFFFFF6DLLU: | |
1250 | -if(!ACCESS_CURRENT) | |
1251 | - JUMP(0xFFFFFFFFFFFFFF70LLU); // skip consequent | |
2457 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
2458 | +// SP 7 | |
2459 | +// VERIFY SP | |
2460 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2461 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
2462 | +// SP 12 | |
2463 | +// VERIFY SP | |
2464 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2465 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF68LLU, 0xAE08260000000000LLU); | |
2466 | +case 0xFFFFFFFFFFFFFF68LLU: | |
2467 | +// SP 8 | |
2468 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF67LLU, 0x92E727AE37000000LLU); | |
2469 | +case 0xFFFFFFFFFFFFFF67LLU: | |
2470 | +// SP 3 | |
2471 | +if(!POP) | |
2472 | +// SP 2 | |
2473 | + JUMP(0xFFFFFFFFFFFFFF6ALLU); // skip consequent | |
1252 | 2474 | // consequent |
1253 | 2475 | |
1254 | - PUSH(0); // place-holder for result of block | |
1255 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2476 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2477 | +// SP 3 | |
2478 | +// VERIFY SP | |
2479 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1256 | 2480 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1257 | 2481 | |
1258 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF6CLLU, 0xADCB6E81E7279C00LLU); | |
1259 | -case 0xFFFFFFFFFFFFFF6CLLU: | |
2482 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
2483 | +// SP 8 | |
2484 | +// VERIFY SP | |
2485 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2486 | +PUSH(ACCESS_ARG(0)); | |
2487 | +// SP 9 | |
2488 | +// VERIFY SP | |
2489 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2490 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF66LLU, 0xADCB6E81E7279C00LLU); | |
2491 | +case 0xFFFFFFFFFFFFFF66LLU: | |
2492 | +// SP 4 | |
1260 | 2493 | |
1261 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2494 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2495 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2496 | +// SP 3 | |
1262 | 2497 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1263 | - JUMP(0xFFFFFFFFFFFFFF6FLLU); // skip alternative | |
1264 | -case 0xFFFFFFFFFFFFFF70LLU: // alternative | |
2498 | +// SP 2 | |
2499 | +// VERIFY SP | |
2500 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2501 | + JUMP(0xFFFFFFFFFFFFFF69LLU); // skip alternative | |
2502 | +case 0xFFFFFFFFFFFFFF6ALLU: // alternative | |
1265 | 2503 | |
1266 | 2504 | |
1267 | - PUSH(0); // place-holder for result of block | |
1268 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2505 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2506 | +// SP 3 | |
2507 | +// VERIFY SP | |
2508 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1269 | 2509 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1270 | 2510 | |
1271 | 2511 | // predicate |
1272 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(58LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF69LLU, 0xA1CBDE8EAAEF0000LLU); | |
1273 | -case 0xFFFFFFFFFFFFFF69LLU: | |
1274 | -if(!ACCESS_CURRENT) | |
1275 | - JUMP(0xFFFFFFFFFFFFFF6BLLU); // skip consequent | |
2512 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
2513 | +// SP 8 | |
2514 | +// VERIFY SP | |
2515 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2516 | +PUSH(58LLU);// SP 9 | |
2517 | +// VERIFY SP | |
2518 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2519 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF63LLU, 0xA1CBDE8EAAEF0000LLU); | |
2520 | +case 0xFFFFFFFFFFFFFF63LLU: | |
2521 | +// SP 4 | |
2522 | +if(!POP) | |
2523 | +// SP 3 | |
2524 | + JUMP(0xFFFFFFFFFFFFFF65LLU); // skip consequent | |
1276 | 2525 | // consequent |
1277 | 2526 | |
1278 | - PUSH(0); // place-holder for result of block | |
1279 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2527 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2528 | +// SP 4 | |
2529 | +// VERIFY SP | |
2530 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1280 | 2531 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1281 | 2532 | |
1282 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF68LLU, 0xC60B5D72F9280000LLU); | |
1283 | -case 0xFFFFFFFFFFFFFF68LLU: | |
2533 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 5 | |
2534 | +// SP 9 | |
2535 | +// VERIFY SP | |
2536 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2537 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF62LLU, 0xC60B5D72F9280000LLU); | |
2538 | +case 0xFFFFFFFFFFFFFF62LLU: | |
2539 | +// SP 5 | |
1284 | 2540 | // escape hatch to C |
1285 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2541 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2542 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2543 | +// SP 4 | |
1286 | 2544 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1287 | - JUMP(0xFFFFFFFFFFFFFF6ALLU); // skip alternative | |
1288 | -case 0xFFFFFFFFFFFFFF6BLLU: // alternative | |
2545 | +// SP 3 | |
2546 | +// VERIFY SP | |
2547 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2548 | + JUMP(0xFFFFFFFFFFFFFF64LLU); // skip alternative | |
2549 | +case 0xFFFFFFFFFFFFFF65LLU: // alternative | |
1289 | 2550 | |
1290 | 2551 | |
1291 | - PUSH(0); // place-holder for result of block | |
1292 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2552 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2553 | +// SP 4 | |
2554 | +// VERIFY SP | |
2555 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1293 | 2556 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1294 | 2557 | |
1295 | 2558 | // predicate |
1296 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(123LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF65LLU, 0xA1CBDE8EAAEF0000LLU); | |
1297 | -case 0xFFFFFFFFFFFFFF65LLU: | |
1298 | -if(!ACCESS_CURRENT) | |
1299 | - JUMP(0xFFFFFFFFFFFFFF67LLU); // skip consequent | |
2559 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 5 | |
2560 | +// SP 9 | |
2561 | +// VERIFY SP | |
2562 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2563 | +PUSH(123LLU);// SP 10 | |
2564 | +// VERIFY SP | |
2565 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2566 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF5FLLU, 0xA1CBDE8EAAEF0000LLU); | |
2567 | +case 0xFFFFFFFFFFFFFF5FLLU: | |
2568 | +// SP 5 | |
2569 | +if(!POP) | |
2570 | +// SP 4 | |
2571 | + JUMP(0xFFFFFFFFFFFFFF61LLU); // skip consequent | |
1300 | 2572 | // consequent |
1301 | 2573 | |
1302 | - PUSH(0); // place-holder for result of block | |
1303 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2574 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2575 | +// SP 5 | |
2576 | +// VERIFY SP | |
2577 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1304 | 2578 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1305 | 2579 | |
1306 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF64LLU, 0xADCB6E81D9EA7A60LLU); | |
1307 | -case 0xFFFFFFFFFFFFFF64LLU: | |
2580 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
2581 | +// SP 10 | |
2582 | +// VERIFY SP | |
2583 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2584 | +PUSH(ACCESS_ARG(0)); | |
2585 | +// SP 11 | |
2586 | +// VERIFY SP | |
2587 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2588 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF5ELLU, 0xADCB6E81D9EA7A60LLU); | |
2589 | +case 0xFFFFFFFFFFFFFF5ELLU: | |
2590 | +// SP 6 | |
1308 | 2591 | |
1309 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2592 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2593 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2594 | +// SP 5 | |
1310 | 2595 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1311 | - JUMP(0xFFFFFFFFFFFFFF66LLU); // skip alternative | |
1312 | -case 0xFFFFFFFFFFFFFF67LLU: // alternative | |
2596 | +// SP 4 | |
2597 | +// VERIFY SP | |
2598 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2599 | + JUMP(0xFFFFFFFFFFFFFF60LLU); // skip alternative | |
2600 | +case 0xFFFFFFFFFFFFFF61LLU: // alternative | |
1313 | 2601 | |
1314 | 2602 | |
1315 | - PUSH(0); // place-holder for result of block | |
1316 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2603 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2604 | +// SP 5 | |
2605 | +// VERIFY SP | |
2606 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1317 | 2607 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1318 | 2608 | |
1319 | 2609 | // predicate |
1320 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(64LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF61LLU, 0xA1CBDE8EAAEF0000LLU); | |
1321 | -case 0xFFFFFFFFFFFFFF61LLU: | |
1322 | -if(!ACCESS_CURRENT) | |
1323 | - JUMP(0xFFFFFFFFFFFFFF63LLU); // skip consequent | |
2610 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
2611 | +// SP 10 | |
2612 | +// VERIFY SP | |
2613 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2614 | +PUSH(64LLU);// SP 11 | |
2615 | +// VERIFY SP | |
2616 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2617 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF5BLLU, 0xA1CBDE8EAAEF0000LLU); | |
2618 | +case 0xFFFFFFFFFFFFFF5BLLU: | |
2619 | +// SP 6 | |
2620 | +if(!POP) | |
2621 | +// SP 5 | |
2622 | + JUMP(0xFFFFFFFFFFFFFF5DLLU); // skip consequent | |
1324 | 2623 | // consequent |
1325 | 2624 | |
1326 | - PUSH(0); // place-holder for result of block | |
1327 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2625 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2626 | +// SP 6 | |
2627 | +// VERIFY SP | |
2628 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1328 | 2629 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1329 | 2630 | |
1330 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF60LLU, 0xADCB6E8328E49E00LLU); | |
1331 | -case 0xFFFFFFFFFFFFFF60LLU: | |
2631 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
2632 | +// SP 11 | |
2633 | +// VERIFY SP | |
2634 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2635 | +PUSH(ACCESS_ARG(0)); | |
2636 | +// SP 12 | |
2637 | +// VERIFY SP | |
2638 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2639 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF5ALLU, 0xADCB6E8328E49E00LLU); | |
2640 | +case 0xFFFFFFFFFFFFFF5ALLU: | |
2641 | +// SP 7 | |
1332 | 2642 | |
1333 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2643 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2644 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2645 | +// SP 6 | |
1334 | 2646 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1335 | - JUMP(0xFFFFFFFFFFFFFF62LLU); // skip alternative | |
1336 | -case 0xFFFFFFFFFFFFFF63LLU: // alternative | |
2647 | +// SP 5 | |
2648 | +// VERIFY SP | |
2649 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2650 | + JUMP(0xFFFFFFFFFFFFFF5CLLU); // skip alternative | |
2651 | +case 0xFFFFFFFFFFFFFF5DLLU: // alternative | |
1337 | 2652 | |
1338 | 2653 | |
1339 | - PUSH(0); // place-holder for result of block | |
1340 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2654 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2655 | +// SP 6 | |
2656 | +// VERIFY SP | |
2657 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1341 | 2658 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1342 | 2659 | |
1343 | 2660 | // predicate |
1344 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(63LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF5DLLU, 0xA1CBDE8EAAEF0000LLU); | |
1345 | -case 0xFFFFFFFFFFFFFF5DLLU: | |
1346 | -if(!ACCESS_CURRENT) | |
1347 | - JUMP(0xFFFFFFFFFFFFFF5FLLU); // skip consequent | |
2661 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
2662 | +// SP 11 | |
2663 | +// VERIFY SP | |
2664 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2665 | +PUSH(63LLU);// SP 12 | |
2666 | +// VERIFY SP | |
2667 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2668 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF57LLU, 0xA1CBDE8EAAEF0000LLU); | |
2669 | +case 0xFFFFFFFFFFFFFF57LLU: | |
2670 | +// SP 7 | |
2671 | +if(!POP) | |
2672 | +// SP 6 | |
2673 | + JUMP(0xFFFFFFFFFFFFFF59LLU); // skip consequent | |
1348 | 2674 | // consequent |
1349 | 2675 | |
1350 | - PUSH(0); // place-holder for result of block | |
1351 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2676 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2677 | +// SP 7 | |
2678 | +// VERIFY SP | |
2679 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1352 | 2680 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1353 | 2681 | |
1354 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF5CLLU, 0xADCB6E8248400000LLU); | |
1355 | -case 0xFFFFFFFFFFFFFF5CLLU: | |
2682 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
2683 | +// SP 12 | |
2684 | +// VERIFY SP | |
2685 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2686 | +PUSH(ACCESS_ARG(0)); | |
2687 | +// SP 13 | |
2688 | +// VERIFY SP | |
2689 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2690 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF56LLU, 0xADCB6E8248400000LLU); | |
2691 | +case 0xFFFFFFFFFFFFFF56LLU: | |
2692 | +// SP 8 | |
1356 | 2693 | |
1357 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2694 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2695 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2696 | +// SP 7 | |
1358 | 2697 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1359 | - JUMP(0xFFFFFFFFFFFFFF5ELLU); // skip alternative | |
1360 | -case 0xFFFFFFFFFFFFFF5FLLU: // alternative | |
2698 | +// SP 6 | |
2699 | +// VERIFY SP | |
2700 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2701 | + JUMP(0xFFFFFFFFFFFFFF58LLU); // skip alternative | |
2702 | +case 0xFFFFFFFFFFFFFF59LLU: // alternative | |
1361 | 2703 | |
1362 | 2704 | |
1363 | - PUSH(0); // place-holder for result of block | |
1364 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2705 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2706 | +// SP 7 | |
2707 | +// VERIFY SP | |
2708 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1365 | 2709 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1366 | 2710 | |
1367 | 2711 | // predicate |
1368 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(96LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF59LLU, 0xA1CBDE8EAAEF0000LLU); | |
1369 | -case 0xFFFFFFFFFFFFFF59LLU: | |
1370 | -if(!ACCESS_CURRENT) | |
1371 | - JUMP(0xFFFFFFFFFFFFFF5BLLU); // skip consequent | |
2712 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
2713 | +// SP 12 | |
2714 | +// VERIFY SP | |
2715 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2716 | +PUSH(95LLU);// SP 13 | |
2717 | +// VERIFY SP | |
2718 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2719 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF53LLU, 0xA1CBDE8EAAEF0000LLU); | |
2720 | +case 0xFFFFFFFFFFFFFF53LLU: | |
2721 | +// SP 8 | |
2722 | +if(!POP) | |
2723 | +// SP 7 | |
2724 | + JUMP(0xFFFFFFFFFFFFFF55LLU); // skip consequent | |
1372 | 2725 | // consequent |
1373 | 2726 | |
1374 | - PUSH(0); // place-holder for result of block | |
1375 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2727 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2728 | +// SP 8 | |
2729 | +// VERIFY SP | |
2730 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1376 | 2731 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1377 | 2732 | |
1378 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF58LLU, 0x72EBA48A9C5CB400LLU); | |
1379 | -case 0xFFFFFFFFFFFFFF58LLU: | |
2733 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 9 | |
2734 | +// SP 13 | |
2735 | +// VERIFY SP | |
2736 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2737 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF52LLU, 0xBA692B7A8A6FB800LLU); | |
2738 | +case 0xFFFFFFFFFFFFFF52LLU: | |
2739 | +// SP 9 | |
1380 | 2740 | |
1381 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2741 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 10 | |
2742 | +// SP 14 | |
2743 | +// VERIFY SP | |
2744 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2745 | +PUSH(61LLU);// SP 15 | |
2746 | +// VERIFY SP | |
2747 | +if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2748 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF51LLU, 0xA1CBDE8C00000000LLU); | |
2749 | +case 0xFFFFFFFFFFFFFF51LLU: | |
2750 | +// SP 10 | |
2751 | + | |
2752 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 11 | |
2753 | +// SP 15 | |
2754 | +// VERIFY SP | |
2755 | +if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2756 | +PUSH(ACCESS_ARG(0)); | |
2757 | +// SP 16 | |
2758 | +// VERIFY SP | |
2759 | +if(sp$$$ != 16LLU) { fprintf(stderr, "verify failed, sp %llu != 16 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2760 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF50LLU, 0xADCB6E820CEBB400LLU); | |
2761 | +case 0xFFFFFFFFFFFFFF50LLU: | |
2762 | +// SP 11 | |
2763 | + | |
2764 | + fprintf(stdout, "(void)POP;\n"); | |
2765 | + SP_ADD_VERIFY(-1); | |
2766 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2767 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2768 | +// SP 8 | |
1382 | 2769 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1383 | - JUMP(0xFFFFFFFFFFFFFF5ALLU); // skip alternative | |
1384 | -case 0xFFFFFFFFFFFFFF5BLLU: // alternative | |
2770 | +// SP 7 | |
2771 | +// VERIFY SP | |
2772 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2773 | + JUMP(0xFFFFFFFFFFFFFF54LLU); // skip alternative | |
2774 | +case 0xFFFFFFFFFFFFFF55LLU: // alternative | |
1385 | 2775 | |
1386 | 2776 | |
1387 | - PUSH(0); // place-holder for result of block | |
1388 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2777 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2778 | +// SP 8 | |
2779 | +// VERIFY SP | |
2780 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1389 | 2781 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1390 | 2782 | |
1391 | 2783 | // predicate |
1392 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(94LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF55LLU, 0xA1CBDE8EAAEF0000LLU); | |
1393 | -case 0xFFFFFFFFFFFFFF55LLU: | |
1394 | -if(!ACCESS_CURRENT) | |
1395 | - JUMP(0xFFFFFFFFFFFFFF57LLU); // skip consequent | |
2784 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 9 | |
2785 | +// SP 13 | |
2786 | +// VERIFY SP | |
2787 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2788 | +PUSH(96LLU);// SP 14 | |
2789 | +// VERIFY SP | |
2790 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2791 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF4DLLU, 0xA1CBDE8EAAEF0000LLU); | |
2792 | +case 0xFFFFFFFFFFFFFF4DLLU: | |
2793 | +// SP 9 | |
2794 | +if(!POP) | |
2795 | +// SP 8 | |
2796 | + JUMP(0xFFFFFFFFFFFFFF4FLLU); // skip consequent | |
1396 | 2797 | // consequent |
1397 | 2798 | |
1398 | - PUSH(0); // place-holder for result of block | |
1399 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2799 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2800 | +// SP 9 | |
2801 | +// VERIFY SP | |
2802 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1400 | 2803 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1401 | 2804 | |
1402 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF54LLU, 0x72EBA48A98A7A9D0LLU); | |
1403 | -case 0xFFFFFFFFFFFFFF54LLU: | |
2805 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 10 | |
2806 | +// SP 14 | |
2807 | +// VERIFY SP | |
2808 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2809 | +PUSH(ACCESS_ARG(0)); | |
2810 | +// SP 15 | |
2811 | +// VERIFY SP | |
2812 | +if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2813 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF4CLLU, 0x72EBA48A9C5CB400LLU); | |
2814 | +case 0xFFFFFFFFFFFFFF4CLLU: | |
2815 | +// SP 10 | |
1404 | 2816 | |
1405 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2817 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2818 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2819 | +// SP 9 | |
1406 | 2820 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1407 | - JUMP(0xFFFFFFFFFFFFFF56LLU); // skip alternative | |
1408 | -case 0xFFFFFFFFFFFFFF57LLU: // alternative | |
2821 | +// SP 8 | |
2822 | +// VERIFY SP | |
2823 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2824 | + JUMP(0xFFFFFFFFFFFFFF4ELLU); // skip alternative | |
2825 | +case 0xFFFFFFFFFFFFFF4FLLU: // alternative | |
1409 | 2826 | |
1410 | 2827 | |
1411 | - PUSH(0); // place-holder for result of block | |
1412 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2828 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2829 | +// SP 9 | |
2830 | +// VERIFY SP | |
2831 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1413 | 2832 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1414 | 2833 | |
1415 | 2834 | // predicate |
1416 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(35LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF51LLU, 0xA1CBDE8EAAEF0000LLU); | |
1417 | -case 0xFFFFFFFFFFFFFF51LLU: | |
1418 | -if(!ACCESS_CURRENT) | |
1419 | - JUMP(0xFFFFFFFFFFFFFF53LLU); // skip consequent | |
2835 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 10 | |
2836 | +// SP 14 | |
2837 | +// VERIFY SP | |
2838 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2839 | +PUSH(94LLU);// SP 15 | |
2840 | +// VERIFY SP | |
2841 | +if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2842 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF49LLU, 0xA1CBDE8EAAEF0000LLU); | |
2843 | +case 0xFFFFFFFFFFFFFF49LLU: | |
2844 | +// SP 10 | |
2845 | +if(!POP) | |
2846 | +// SP 9 | |
2847 | + JUMP(0xFFFFFFFFFFFFFF4BLLU); // skip consequent | |
1420 | 2848 | // consequent |
1421 | 2849 | |
1422 | - PUSH(0); // place-holder for result of block | |
1423 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2850 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2851 | +// SP 10 | |
2852 | +// VERIFY SP | |
2853 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1424 | 2854 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1425 | 2855 | |
1426 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF50LLU, 0x72EBA48A972D8800LLU); | |
1427 | -case 0xFFFFFFFFFFFFFF50LLU: | |
2856 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 11 | |
2857 | +// SP 15 | |
2858 | +// VERIFY SP | |
2859 | +if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2860 | +PUSH(ACCESS_ARG(0)); | |
2861 | +// SP 16 | |
2862 | +// VERIFY SP | |
2863 | +if(sp$$$ != 16LLU) { fprintf(stderr, "verify failed, sp %llu != 16 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2864 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF48LLU, 0x72EBA48A98A7A9D0LLU); | |
2865 | +case 0xFFFFFFFFFFFFFF48LLU: | |
2866 | +// SP 11 | |
1428 | 2867 | |
1429 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2868 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2869 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2870 | +// SP 10 | |
1430 | 2871 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1431 | - JUMP(0xFFFFFFFFFFFFFF52LLU); // skip alternative | |
1432 | -case 0xFFFFFFFFFFFFFF53LLU: // alternative | |
2872 | +// SP 9 | |
2873 | +// VERIFY SP | |
2874 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2875 | + JUMP(0xFFFFFFFFFFFFFF4ALLU); // skip alternative | |
2876 | +case 0xFFFFFFFFFFFFFF4BLLU: // alternative | |
1433 | 2877 | |
1434 | 2878 | |
1435 | - PUSH(0); // place-holder for result of block | |
1436 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2879 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2880 | +// SP 10 | |
2881 | +// VERIFY SP | |
2882 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1437 | 2883 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1438 | 2884 | |
1439 | 2885 | // predicate |
1440 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF4DLLU, 0xA1CBDE8EAAEF0000LLU); | |
1441 | -case 0xFFFFFFFFFFFFFF4DLLU: | |
1442 | -if(!ACCESS_CURRENT) | |
1443 | - JUMP(0xFFFFFFFFFFFFFF4FLLU); // skip consequent | |
2886 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 11 | |
2887 | +// SP 15 | |
2888 | +// VERIFY SP | |
2889 | +if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2890 | +PUSH(35LLU);// SP 16 | |
2891 | +// VERIFY SP | |
2892 | +if(sp$$$ != 16LLU) { fprintf(stderr, "verify failed, sp %llu != 16 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2893 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF45LLU, 0xA1CBDE8EAAEF0000LLU); | |
2894 | +case 0xFFFFFFFFFFFFFF45LLU: | |
2895 | +// SP 11 | |
2896 | +if(!POP) | |
2897 | +// SP 10 | |
2898 | + JUMP(0xFFFFFFFFFFFFFF47LLU); // skip consequent | |
1444 | 2899 | // consequent |
1445 | 2900 | |
1446 | - PUSH(0); // place-holder for result of block | |
1447 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2901 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2902 | +// SP 11 | |
2903 | +// VERIFY SP | |
2904 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1448 | 2905 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1449 | 2906 | |
2907 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 12 | |
2908 | +// SP 16 | |
2909 | +// VERIFY SP | |
2910 | +if(sp$$$ != 16LLU) { fprintf(stderr, "verify failed, sp %llu != 16 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2911 | +PUSH(ACCESS_ARG(0)); | |
2912 | +// SP 17 | |
2913 | +// VERIFY SP | |
2914 | +if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2915 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF44LLU, 0x72EBA48A972D8800LLU); | |
2916 | +case 0xFFFFFFFFFFFFFF44LLU: | |
2917 | +// SP 12 | |
2918 | + | |
2919 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2920 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2921 | +// SP 11 | |
2922 | +stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block | |
2923 | +// SP 10 | |
2924 | +// VERIFY SP | |
2925 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2926 | + JUMP(0xFFFFFFFFFFFFFF46LLU); // skip alternative | |
2927 | +case 0xFFFFFFFFFFFFFF47LLU: // alternative | |
2928 | + | |
2929 | + | |
2930 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2931 | +// SP 11 | |
2932 | +// VERIFY SP | |
2933 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2934 | +stack$$$[BLKINF_IDX] = sp$$$; // store base of current block | |
2935 | + | |
1450 | 2936 | // predicate |
1451 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF4ALLU, 0xA1CBDE8EAAEF0000LLU); | |
1452 | -case 0xFFFFFFFFFFFFFF4ALLU: | |
1453 | -if(!ACCESS_CURRENT) | |
1454 | - JUMP(0xFFFFFFFFFFFFFF4CLLU); // skip consequent | |
2937 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 12 | |
2938 | +// SP 16 | |
2939 | +// VERIFY SP | |
2940 | +if(sp$$$ != 16LLU) { fprintf(stderr, "verify failed, sp %llu != 16 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2941 | +PUSH(47LLU);// SP 17 | |
2942 | +// VERIFY SP | |
2943 | +if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2944 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF41LLU, 0xA1CBDE8EAAEF0000LLU); | |
2945 | +case 0xFFFFFFFFFFFFFF41LLU: | |
2946 | +// SP 12 | |
2947 | +if(!POP) | |
2948 | +// SP 11 | |
2949 | + JUMP(0xFFFFFFFFFFFFFF43LLU); // skip consequent | |
1455 | 2950 | // consequent |
1456 | 2951 | |
1457 | - PUSH(0); // place-holder for result of block | |
1458 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2952 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2953 | +// SP 12 | |
2954 | +// VERIFY SP | |
2955 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1459 | 2956 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1460 | 2957 | |
1461 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF49LLU, 0x7AAA28829BC00000LLU); | |
1462 | -case 0xFFFFFFFFFFFFFF49LLU: | |
2958 | + // predicate | |
2959 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 13 | |
2960 | +// SP 17 | |
2961 | +// VERIFY SP | |
2962 | +if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2963 | +PUSH(47LLU);// SP 18 | |
2964 | +// VERIFY SP | |
2965 | +if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2966 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF3ELLU, 0xA1CBDE8EAAEF0000LLU); | |
2967 | +case 0xFFFFFFFFFFFFFF3ELLU: | |
2968 | +// SP 13 | |
2969 | +if(!POP) | |
2970 | +// SP 12 | |
2971 | + JUMP(0xFFFFFFFFFFFFFF40LLU); // skip consequent | |
2972 | +// consequent | |
1463 | 2973 | |
1464 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2974 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2975 | +// SP 13 | |
2976 | +// VERIFY SP | |
2977 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2978 | +stack$$$[BLKINF_IDX] = sp$$$; // store base of current block | |
2979 | + | |
2980 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 14 | |
2981 | +// SP 18 | |
2982 | +// VERIFY SP | |
2983 | +if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2984 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF3DLLU, 0x7AAA28829BC00000LLU); | |
2985 | +case 0xFFFFFFFFFFFFFF3DLLU: | |
2986 | +// SP 14 | |
2987 | + | |
2988 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
2989 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
2990 | +// SP 13 | |
1465 | 2991 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1466 | - JUMP(0xFFFFFFFFFFFFFF4BLLU); // skip alternative | |
1467 | -case 0xFFFFFFFFFFFFFF4CLLU: // alternative | |
2992 | +// SP 12 | |
2993 | +// VERIFY SP | |
2994 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2995 | + JUMP(0xFFFFFFFFFFFFFF3FLLU); // skip alternative | |
2996 | +case 0xFFFFFFFFFFFFFF40LLU: // alternative | |
1468 | 2997 | |
1469 | - | |
1470 | - PUSH(0); // place-holder for result of block | |
1471 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
2998 | + | |
2999 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3000 | +// SP 13 | |
3001 | +// VERIFY SP | |
3002 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1472 | 3003 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1473 | 3004 | |
1474 | - // predicate | |
1475 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(42LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF46LLU, 0xA1CBDE8EAAEF0000LLU); | |
1476 | -case 0xFFFFFFFFFFFFFF46LLU: | |
1477 | -if(!ACCESS_CURRENT) | |
1478 | - JUMP(0xFFFFFFFFFFFFFF48LLU); // skip consequent | |
3005 | + // predicate | |
3006 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 14 | |
3007 | +// SP 18 | |
3008 | +// VERIFY SP | |
3009 | +if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3010 | +PUSH(42LLU);// SP 19 | |
3011 | +// VERIFY SP | |
3012 | +if(sp$$$ != 19LLU) { fprintf(stderr, "verify failed, sp %llu != 19 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3013 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF3ALLU, 0xA1CBDE8EAAEF0000LLU); | |
3014 | +case 0xFFFFFFFFFFFFFF3ALLU: | |
3015 | +// SP 14 | |
3016 | +if(!POP) | |
3017 | +// SP 13 | |
3018 | + JUMP(0xFFFFFFFFFFFFFF3CLLU); // skip consequent | |
1479 | 3019 | // consequent |
1480 | 3020 | |
1481 | - PUSH(0); // place-holder for result of block | |
1482 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3021 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3022 | +// SP 14 | |
3023 | +// VERIFY SP | |
3024 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1483 | 3025 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1484 | 3026 | |
1485 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF45LLU, 0x7AAA28829BC00001LLU); | |
1486 | -case 0xFFFFFFFFFFFFFF45LLU: | |
3027 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 15 | |
3028 | +// SP 19 | |
3029 | +// VERIFY SP | |
3030 | +if(sp$$$ != 19LLU) { fprintf(stderr, "verify failed, sp %llu != 19 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3031 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF39LLU, 0x7AAA28829BC00001LLU); | |
3032 | +case 0xFFFFFFFFFFFFFF39LLU: | |
3033 | +// SP 15 | |
1487 | 3034 | |
1488 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3035 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3036 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3037 | +// SP 14 | |
1489 | 3038 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1490 | - JUMP(0xFFFFFFFFFFFFFF47LLU); // skip alternative | |
1491 | -case 0xFFFFFFFFFFFFFF48LLU: // alternative | |
3039 | +// SP 13 | |
3040 | +// VERIFY SP | |
3041 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3042 | + JUMP(0xFFFFFFFFFFFFFF3BLLU); // skip alternative | |
3043 | +case 0xFFFFFFFFFFFFFF3CLLU: // alternative | |
1492 | 3044 | |
1493 | - | |
1494 | - PUSH(0); // place-holder for result of block | |
1495 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3045 | + | |
3046 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3047 | +// SP 14 | |
3048 | +// VERIFY SP | |
3049 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1496 | 3050 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1497 | 3051 | |
1498 | - fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); | |
1499 | - fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get | |
1500 | - exit(-1); | |
1501 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3052 | + fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); | |
3053 | + fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get | |
3054 | + exit(-1); | |
3055 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3056 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3057 | +// SP 14 | |
1502 | 3058 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1503 | -case 0xFFFFFFFFFFFFFF47LLU: // skip to here | |
3059 | +// SP 13 | |
3060 | +// VERIFY SP | |
3061 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3062 | +case 0xFFFFFFFFFFFFFF3BLLU: // skip to here | |
1504 | 3063 | |
1505 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3064 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3065 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3066 | +// SP 13 | |
1506 | 3067 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1507 | -case 0xFFFFFFFFFFFFFF4BLLU: // skip to here | |
3068 | +// SP 12 | |
3069 | +// VERIFY SP | |
3070 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3071 | +case 0xFFFFFFFFFFFFFF3FLLU: // skip to here | |
1508 | 3072 | |
1509 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3073 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3074 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3075 | +// SP 12 | |
1510 | 3076 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1511 | - JUMP(0xFFFFFFFFFFFFFF4ELLU); // skip alternative | |
1512 | -case 0xFFFFFFFFFFFFFF4FLLU: // alternative | |
3077 | +// SP 11 | |
3078 | +// VERIFY SP | |
3079 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3080 | + JUMP(0xFFFFFFFFFFFFFF42LLU); // skip alternative | |
3081 | +case 0xFFFFFFFFFFFFFF43LLU: // alternative | |
1513 | 3082 | |
1514 | - | |
1515 | - PUSH(0); // place-holder for result of block | |
1516 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3083 | + | |
3084 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3085 | +// SP 12 | |
3086 | +// VERIFY SP | |
3087 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1517 | 3088 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1518 | 3089 | |
1519 | - // predicate | |
1520 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(125LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF42LLU, 0xA1CBDE8EAAEF0000LLU); | |
1521 | -case 0xFFFFFFFFFFFFFF42LLU: | |
1522 | -if(!ACCESS_CURRENT) | |
1523 | - JUMP(0xFFFFFFFFFFFFFF44LLU); // skip consequent | |
3090 | + // predicate | |
3091 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 13 | |
3092 | +// SP 17 | |
3093 | +// VERIFY SP | |
3094 | +if(sp$$$ != 17LLU) { fprintf(stderr, "verify failed, sp %llu != 17 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3095 | +PUSH(125LLU);// SP 18 | |
3096 | +// VERIFY SP | |
3097 | +if(sp$$$ != 18LLU) { fprintf(stderr, "verify failed, sp %llu != 18 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3098 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF36LLU, 0xA1CBDE8EAAEF0000LLU); | |
3099 | +case 0xFFFFFFFFFFFFFF36LLU: | |
3100 | +// SP 13 | |
3101 | +if(!POP) | |
3102 | +// SP 12 | |
3103 | + JUMP(0xFFFFFFFFFFFFFF38LLU); // skip consequent | |
1524 | 3104 | // consequent |
1525 | 3105 | |
1526 | - PUSH(0); // place-holder for result of block | |
1527 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3106 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3107 | +// SP 13 | |
3108 | +// VERIFY SP | |
3109 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1528 | 3110 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1529 | 3111 | |
1530 | - fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); | |
1531 | - fprintf(stderr, "superfluous closing curly brace '}'\n"); | |
1532 | - exit(-1); | |
1533 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3112 | + fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); | |
3113 | + fprintf(stderr, "superfluous closing curly brace '}'\n"); | |
3114 | + exit(-1); | |
3115 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3116 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3117 | +// SP 13 | |
1534 | 3118 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1535 | - JUMP(0xFFFFFFFFFFFFFF43LLU); // skip alternative | |
1536 | -case 0xFFFFFFFFFFFFFF44LLU: // alternative | |
3119 | +// SP 12 | |
3120 | +// VERIFY SP | |
3121 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3122 | + JUMP(0xFFFFFFFFFFFFFF37LLU); // skip alternative | |
3123 | +case 0xFFFFFFFFFFFFFF38LLU: // alternative | |
1537 | 3124 | |
1538 | - | |
1539 | - PUSH(0); // place-holder for result of block | |
1540 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3125 | + | |
3126 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3127 | +// SP 13 | |
3128 | +// VERIFY SP | |
3129 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1541 | 3130 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1542 | 3131 | |
1543 | - fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); | |
1544 | - fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get | |
1545 | - exit(-1); | |
1546 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3132 | + fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); | |
3133 | + fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get | |
3134 | + exit(-1); | |
3135 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3136 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3137 | +// SP 13 | |
1547 | 3138 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1548 | -case 0xFFFFFFFFFFFFFF43LLU: // skip to here | |
3139 | +// SP 12 | |
3140 | +// VERIFY SP | |
3141 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3142 | +case 0xFFFFFFFFFFFFFF37LLU: // skip to here | |
1549 | 3143 | |
1550 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3144 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3145 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3146 | +// SP 12 | |
1551 | 3147 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1552 | -case 0xFFFFFFFFFFFFFF4ELLU: // skip to here | |
3148 | +// SP 11 | |
3149 | +// VERIFY SP | |
3150 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3151 | +case 0xFFFFFFFFFFFFFF42LLU: // skip to here | |
1553 | 3152 | |
1554 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3153 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3154 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3155 | +// SP 11 | |
1555 | 3156 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1556 | -case 0xFFFFFFFFFFFFFF52LLU: // skip to here | |
3157 | +// SP 10 | |
3158 | +// VERIFY SP | |
3159 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3160 | +case 0xFFFFFFFFFFFFFF46LLU: // skip to here | |
1557 | 3161 | |
1558 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3162 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3163 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3164 | +// SP 10 | |
1559 | 3165 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1560 | -case 0xFFFFFFFFFFFFFF56LLU: // skip to here | |
3166 | +// SP 9 | |
3167 | +// VERIFY SP | |
3168 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3169 | +case 0xFFFFFFFFFFFFFF4ALLU: // skip to here | |
1561 | 3170 | |
1562 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3171 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3172 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3173 | +// SP 9 | |
1563 | 3174 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1564 | -case 0xFFFFFFFFFFFFFF5ALLU: // skip to here | |
3175 | +// SP 8 | |
3176 | +// VERIFY SP | |
3177 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3178 | +case 0xFFFFFFFFFFFFFF4ELLU: // skip to here | |
1565 | 3179 | |
1566 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3180 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3181 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3182 | +// SP 8 | |
1567 | 3183 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1568 | -case 0xFFFFFFFFFFFFFF5ELLU: // skip to here | |
3184 | +// SP 7 | |
3185 | +// VERIFY SP | |
3186 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3187 | +case 0xFFFFFFFFFFFFFF54LLU: // skip to here | |
1569 | 3188 | |
1570 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3189 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3190 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3191 | +// SP 7 | |
1571 | 3192 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1572 | -case 0xFFFFFFFFFFFFFF62LLU: // skip to here | |
3193 | +// SP 6 | |
3194 | +// VERIFY SP | |
3195 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3196 | +case 0xFFFFFFFFFFFFFF58LLU: // skip to here | |
1573 | 3197 | |
1574 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3198 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3199 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3200 | +// SP 6 | |
1575 | 3201 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1576 | -case 0xFFFFFFFFFFFFFF66LLU: // skip to here | |
3202 | +// SP 5 | |
3203 | +// VERIFY SP | |
3204 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3205 | +case 0xFFFFFFFFFFFFFF5CLLU: // skip to here | |
1577 | 3206 | |
1578 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3207 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3208 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3209 | +// SP 5 | |
1579 | 3210 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1580 | -case 0xFFFFFFFFFFFFFF6ALLU: // skip to here | |
3211 | +// SP 4 | |
3212 | +// VERIFY SP | |
3213 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3214 | +case 0xFFFFFFFFFFFFFF60LLU: // skip to here | |
1581 | 3215 | |
1582 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3216 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3217 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3218 | +// SP 4 | |
1583 | 3219 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1584 | -case 0xFFFFFFFFFFFFFF6FLLU: // skip to here | |
3220 | +// SP 3 | |
3221 | +// VERIFY SP | |
3222 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3223 | +case 0xFFFFFFFFFFFFFF64LLU: // skip to here | |
1585 | 3224 | |
1586 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF41LLU, 0xBA692B7A8A6FB800LLU); | |
1587 | -case 0xFFFFFFFFFFFFFF41LLU: | |
3225 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3226 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3227 | +// SP 3 | |
3228 | +stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block | |
3229 | +// SP 2 | |
3230 | +// VERIFY SP | |
3231 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3232 | +case 0xFFFFFFFFFFFFFF69LLU: // skip to here | |
1588 | 3233 | |
1589 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3234 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
3235 | +// SP 7 | |
3236 | +// VERIFY SP | |
3237 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3238 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF35LLU, 0xBA692B7A8A6FB800LLU); | |
3239 | +case 0xFFFFFFFFFFFFFF35LLU: | |
3240 | +// SP 3 | |
3241 | + | |
3242 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3243 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3244 | +// SP 2 | |
1590 | 3245 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1591 | - JUMP(0xFFFFFFFFFFFFFF77LLU); // loop | |
1592 | -case 0xFFFFFFFFFFFFFF76LLU: // skip to here | |
3246 | +// SP 1 | |
3247 | +// VERIFY SP | |
3248 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3249 | + JUMP(0xFFFFFFFFFFFFFF71LLU); // loop | |
3250 | +case 0xFFFFFFFFFFFFFF70LLU: // skip to here | |
1593 | 3251 | |
1594 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(125LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF40LLU, 0xA1CBDE8C00000000LLU); | |
1595 | -case 0xFFFFFFFFFFFFFF40LLU: | |
3252 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
3253 | +// SP 6 | |
3254 | +// VERIFY SP | |
3255 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3256 | +PUSH(125LLU);// SP 7 | |
3257 | +// VERIFY SP | |
3258 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3259 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF34LLU, 0xA1CBDE8C00000000LLU); | |
3260 | +case 0xFFFFFFFFFFFFFF34LLU: | |
3261 | +// SP 2 | |
1596 | 3262 | |
1597 | 3263 | RET; |
1598 | 3264 | |
1599 | 3265 | |
1600 | -case /*parseblock*/0xADCB6E81D9EA7A60LLU: | |
3266 | +case /*parseblock*/0xADCB6E81D9EA7A60LLU:// SP 0 | |
3267 | +// VERIFY SP | |
3268 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1601 | 3269 | |
1602 | - fprintf(stdout, "PUSH(0); // place-holder for result of block\n"); | |
3270 | + | |
3271 | + //:fprintf(stdout, "PUSH(0); // place-holder for result of block\n");: | |
3272 | + //:SP_ADD_VERIFY(1);: | |
1603 | 3273 | fprintf(stdout, "PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block\n"); |
3274 | + SP_ADD_VERIFY(1); | |
3275 | + ACCESS_RETURN = SP; // HACK store estimate in return | |
1604 | 3276 | fprintf(stdout, "stack$$$[BLKINF_IDX] = sp$$$; // store base of current block\n"); |
1605 | 3277 | //fprintf(stdout, "fprintf(stderr, \"STORE %llu\\\n\", (long long unsigned int)sp$$$);\n"); |
1606 | 3278 | |
1607 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF3FLLU, 0xADCB6E81DA9FD000LLU); | |
1608 | -case 0xFFFFFFFFFFFFFF3FLLU: | |
3279 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
3280 | +// SP 5 | |
3281 | +// VERIFY SP | |
3282 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3283 | +PUSH(ACCESS_ARG(0)); | |
3284 | +// SP 6 | |
3285 | +// VERIFY SP | |
3286 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3287 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF33LLU, 0xADCB6E81DA9FD000LLU); | |
3288 | +case 0xFFFFFFFFFFFFFF33LLU: | |
3289 | +// SP 1 | |
1609 | 3290 | |
1610 | 3291 | |
1611 | - fprintf(stdout, "if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, \"INTERNAL ERROR closing block\\n\"); exit(-1); }"); | |
3292 | + fprintf(stdout, "if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, \"INTERNAL ERROR closing block\\n\"); exit(-1); }\n"); | |
1612 | 3293 | fprintf(stdout, "sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block\n"); |
3294 | + SP_SET(ACCESS_RETURN); | |
1613 | 3295 | //fprintf(stdout, "fprintf(stderr, "RETRIEVE %llu\n", (long long unsigned int)sp$$$);\n"); |
1614 | 3296 | fprintf(stdout, "stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block\n"); |
3297 | + SP_ADD_VERIFY(-1); | |
1615 | 3298 | RET; |
1616 | 3299 | |
1617 | 3300 | |
1618 | -case /*parsefnnew*/0xADCB6E821A698320LLU: | |
3301 | +case /*parsefnnew*/0xADCB6E821A698320LLU:// SP 0 | |
3302 | +// VERIFY SP | |
3303 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1619 | 3304 | |
1620 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF3ELLU, 0xBA692B7A8A6FB800LLU); | |
1621 | -case 0xFFFFFFFFFFFFFF3ELLU: | |
1622 | 3305 | |
3306 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
3307 | +// SP 5 | |
3308 | +// VERIFY SP | |
3309 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3310 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF32LLU, 0xBA692B7A8A6FB800LLU); | |
3311 | +case 0xFFFFFFFFFFFFFF32LLU: | |
3312 | +// SP 1 | |
3313 | + | |
1623 | 3314 | // predicate |
1624 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF3BLLU, 0xAE08260000000000LLU); | |
1625 | -case 0xFFFFFFFFFFFFFF3BLLU: | |
1626 | -PUSH(255LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFF3ALLU, 0x9E0B000000000000LLU); | |
1627 | -case 0xFFFFFFFFFFFFFF3ALLU: | |
1628 | -if(!ACCESS_CURRENT) | |
1629 | - JUMP(0xFFFFFFFFFFFFFF3DLLU); // skip consequent | |
3315 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
3316 | +// SP 6 | |
3317 | +// VERIFY SP | |
3318 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3319 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
3320 | +// SP 11 | |
3321 | +// VERIFY SP | |
3322 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3323 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF2FLLU, 0xAE08260000000000LLU); | |
3324 | +case 0xFFFFFFFFFFFFFF2FLLU: | |
3325 | +// SP 7 | |
3326 | +PUSH(255LLU);// SP 8 | |
3327 | +// VERIFY SP | |
3328 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3329 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF2ELLU, 0x9E0B000000000000LLU); | |
3330 | +case 0xFFFFFFFFFFFFFF2ELLU: | |
3331 | +// SP 2 | |
3332 | +if(!POP) | |
3333 | +// SP 1 | |
3334 | + JUMP(0xFFFFFFFFFFFFFF31LLU); // skip consequent | |
1630 | 3335 | // consequent |
1631 | 3336 | |
1632 | - PUSH(0); // place-holder for result of block | |
1633 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3337 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3338 | +// SP 2 | |
3339 | +// VERIFY SP | |
3340 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1634 | 3341 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1635 | 3342 | |
1636 | 3343 | fputs("case ", stdout); |
1637 | - CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF39LLU, 0x4014931491000000LLU); | |
1638 | -case 0xFFFFFFFFFFFFFF39LLU: | |
1639 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFF38LLU, 0xADCB6E821A400000LLU); | |
1640 | -case 0xFFFFFFFFFFFFFF38LLU: | |
3344 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
3345 | +// SP 7 | |
3346 | +// VERIFY SP | |
3347 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3348 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
3349 | +// SP 12 | |
3350 | +// VERIFY SP | |
3351 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3352 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF2DLLU, 0x4014931491000000LLU); | |
3353 | +case 0xFFFFFFFFFFFFFF2DLLU: | |
3354 | +// SP 8 | |
3355 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF2CLLU, 0xADCB6E821A400000LLU); | |
3356 | +case 0xFFFFFFFFFFFFFF2CLLU: | |
3357 | +// SP 3 | |
1641 | 3358 | |
1642 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3359 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3360 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3361 | +// SP 2 | |
1643 | 3362 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1644 | - JUMP(0xFFFFFFFFFFFFFF3CLLU); // skip alternative | |
1645 | -case 0xFFFFFFFFFFFFFF3DLLU: // alternative | |
3363 | +// SP 1 | |
3364 | +// VERIFY SP | |
3365 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3366 | + JUMP(0xFFFFFFFFFFFFFF30LLU); // skip alternative | |
3367 | +case 0xFFFFFFFFFFFFFF31LLU: // alternative | |
1646 | 3368 | |
1647 | 3369 | |
1648 | - PUSH(0); // place-holder for result of block | |
1649 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3370 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3371 | +// SP 2 | |
3372 | +// VERIFY SP | |
3373 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1650 | 3374 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1651 | 3375 | |
1652 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3376 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3377 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3378 | +// SP 2 | |
1653 | 3379 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1654 | -case 0xFFFFFFFFFFFFFF3CLLU: // skip to here | |
3380 | +// SP 1 | |
3381 | +// VERIFY SP | |
3382 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3383 | +case 0xFFFFFFFFFFFFFF30LLU: // skip to here | |
1655 | 3384 | |
1656 | 3385 | RET; |
1657 | 3386 | |
1658 | 3387 | |
1659 | -case /*parsefn___*/0xADCB6E821A400000LLU: | |
3388 | +case /*parsefn___*/0xADCB6E821A400000LLU:// SP 0 | |
3389 | +// VERIFY SP | |
3390 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1660 | 3391 | |
1661 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF37LLU, 0xBA692B7A8A6FB800LLU); | |
1662 | -case 0xFFFFFFFFFFFFFF37LLU: | |
1663 | 3392 | |
1664 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(123LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF36LLU, 0xA1CBDE8C00000000LLU); | |
1665 | -case 0xFFFFFFFFFFFFFF36LLU: | |
3393 | + SP_SET_VERIFY(0); | |
3394 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
3395 | +// SP 5 | |
3396 | +// VERIFY SP | |
3397 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3398 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF2BLLU, 0xBA692B7A8A6FB800LLU); | |
3399 | +case 0xFFFFFFFFFFFFFF2BLLU: | |
3400 | +// SP 1 | |
1666 | 3401 | |
1667 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF35LLU, 0xADCB6E81DA9FD000LLU); | |
1668 | -case 0xFFFFFFFFFFFFFF35LLU: | |
3402 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
3403 | +// SP 6 | |
3404 | +// VERIFY SP | |
3405 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3406 | +PUSH(123LLU);// SP 7 | |
3407 | +// VERIFY SP | |
3408 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3409 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF2ALLU, 0xA1CBDE8C00000000LLU); | |
3410 | +case 0xFFFFFFFFFFFFFF2ALLU: | |
3411 | +// SP 2 | |
1669 | 3412 | |
3413 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
3414 | +// SP 7 | |
3415 | +// VERIFY SP | |
3416 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3417 | +PUSH(0LLU);// SP 8 | |
3418 | +// VERIFY SP | |
3419 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3420 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF29LLU, 0xADCB6E81DA9FD000LLU); | |
3421 | +case 0xFFFFFFFFFFFFFF29LLU: | |
3422 | +// SP 3 | |
3423 | + | |
1670 | 3424 | fputs("RET;\n", stdout); |
1671 | 3425 | RET; |
1672 | 3426 | |
1673 | 3427 | |
1674 | -case /*parsefns__*/0xADCB6E821A6E0000LLU: | |
3428 | +case /*parsefns__*/0xADCB6E821A6E0000LLU:// SP 0 | |
3429 | +// VERIFY SP | |
3430 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1675 | 3431 | |
1676 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF34LLU, 0xBA692B7A8A6FB800LLU); | |
1677 | -case 0xFFFFFFFFFFFFFF34LLU: | |
1678 | 3432 | |
1679 | - case 0xFFFFFFFFFFFFFF33LLU: // loop to here | |
3433 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
3434 | +// SP 5 | |
3435 | +// VERIFY SP | |
3436 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3437 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF28LLU, 0xBA692B7A8A6FB800LLU); | |
3438 | +case 0xFFFFFFFFFFFFFF28LLU: | |
3439 | +// SP 1 | |
3440 | + | |
3441 | + case 0xFFFFFFFFFFFFFF27LLU: // loop to here | |
1680 | 3442 | // predicate |
1681 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF31LLU, 0xAE08260000000000LLU); | |
1682 | -case 0xFFFFFFFFFFFFFF31LLU: | |
1683 | -PUSH(255LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFF30LLU, 0x9E0B000000000000LLU); | |
1684 | -case 0xFFFFFFFFFFFFFF30LLU: | |
1685 | -if(!ACCESS_CURRENT) | |
1686 | - JUMP(0xFFFFFFFFFFFFFF32LLU); // skip loop | |
3443 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
3444 | +// SP 6 | |
3445 | +// VERIFY SP | |
3446 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3447 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
3448 | +// SP 11 | |
3449 | +// VERIFY SP | |
3450 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3451 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF25LLU, 0xAE08260000000000LLU); | |
3452 | +case 0xFFFFFFFFFFFFFF25LLU: | |
3453 | +// SP 7 | |
3454 | +PUSH(255LLU);// SP 8 | |
3455 | +// VERIFY SP | |
3456 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3457 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFF24LLU, 0x9E0B000000000000LLU); | |
3458 | +case 0xFFFFFFFFFFFFFF24LLU: | |
3459 | +// SP 2 | |
3460 | +if(!POP) | |
3461 | +// SP 1 | |
3462 | + JUMP(0xFFFFFFFFFFFFFF26LLU); // skip loop | |
1687 | 3463 | // loop |
1688 | 3464 | |
1689 | - PUSH(0); // place-holder for result of block | |
1690 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3465 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3466 | +// SP 2 | |
3467 | +// VERIFY SP | |
3468 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1691 | 3469 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1692 | 3470 | |
1693 | 3471 | // predicate |
1694 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF2DLLU, 0xAE08260000000000LLU); | |
1695 | -case 0xFFFFFFFFFFFFFF2DLLU: | |
1696 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFF2CLLU, 0x92E727AE37000000LLU); | |
1697 | -case 0xFFFFFFFFFFFFFF2CLLU: | |
1698 | -if(!ACCESS_CURRENT) | |
1699 | - JUMP(0xFFFFFFFFFFFFFF2FLLU); // skip consequent | |
3472 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
3473 | +// SP 7 | |
3474 | +// VERIFY SP | |
3475 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3476 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
3477 | +// SP 12 | |
3478 | +// VERIFY SP | |
3479 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3480 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF21LLU, 0xAE08260000000000LLU); | |
3481 | +case 0xFFFFFFFFFFFFFF21LLU: | |
3482 | +// SP 8 | |
3483 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF20LLU, 0x92E727AE37000000LLU); | |
3484 | +case 0xFFFFFFFFFFFFFF20LLU: | |
3485 | +// SP 3 | |
3486 | +if(!POP) | |
3487 | +// SP 2 | |
3488 | + JUMP(0xFFFFFFFFFFFFFF23LLU); // skip consequent | |
1700 | 3489 | // consequent |
1701 | 3490 | |
1702 | - PUSH(0); // place-holder for result of block | |
1703 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3491 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3492 | +// SP 3 | |
3493 | +// VERIFY SP | |
3494 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1704 | 3495 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1705 | 3496 | |
1706 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF2BLLU, 0xADCB6E821A698320LLU); | |
1707 | -case 0xFFFFFFFFFFFFFF2BLLU: | |
3497 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
3498 | +// SP 8 | |
3499 | +// VERIFY SP | |
3500 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3501 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF1FLLU, 0xADCB6E821A698320LLU); | |
3502 | +case 0xFFFFFFFFFFFFFF1FLLU: | |
3503 | +// SP 4 | |
1708 | 3504 | |
1709 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3505 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3506 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3507 | +// SP 3 | |
1710 | 3508 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1711 | - JUMP(0xFFFFFFFFFFFFFF2ELLU); // skip alternative | |
1712 | -case 0xFFFFFFFFFFFFFF2FLLU: // alternative | |
3509 | +// SP 2 | |
3510 | +// VERIFY SP | |
3511 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3512 | + JUMP(0xFFFFFFFFFFFFFF22LLU); // skip alternative | |
3513 | +case 0xFFFFFFFFFFFFFF23LLU: // alternative | |
1713 | 3514 | |
1714 | 3515 | |
1715 | - PUSH(0); // place-holder for result of block | |
1716 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3516 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3517 | +// SP 3 | |
3518 | +// VERIFY SP | |
3519 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1717 | 3520 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1718 | 3521 | |
1719 | 3522 | // predicate |
1720 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF28LLU, 0xA1CBDE8EAAEF0000LLU); | |
1721 | -case 0xFFFFFFFFFFFFFF28LLU: | |
1722 | -if(!ACCESS_CURRENT) | |
1723 | - JUMP(0xFFFFFFFFFFFFFF2ALLU); // skip consequent | |
3523 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
3524 | +// SP 8 | |
3525 | +// VERIFY SP | |
3526 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3527 | +PUSH(47LLU);// SP 9 | |
3528 | +// VERIFY SP | |
3529 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3530 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF1CLLU, 0xA1CBDE8EAAEF0000LLU); | |
3531 | +case 0xFFFFFFFFFFFFFF1CLLU: | |
3532 | +// SP 4 | |
3533 | +if(!POP) | |
3534 | +// SP 3 | |
3535 | + JUMP(0xFFFFFFFFFFFFFF1ELLU); // skip consequent | |
1724 | 3536 | // consequent |
1725 | 3537 | |
1726 | - PUSH(0); // place-holder for result of block | |
1727 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3538 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3539 | +// SP 4 | |
3540 | +// VERIFY SP | |
3541 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1728 | 3542 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1729 | 3543 | |
1730 | 3544 | // predicate |
1731 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(47LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF25LLU, 0xA1CBDE8EAAEF0000LLU); | |
1732 | -case 0xFFFFFFFFFFFFFF25LLU: | |
1733 | -if(!ACCESS_CURRENT) | |
1734 | - JUMP(0xFFFFFFFFFFFFFF27LLU); // skip consequent | |
3545 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 5 | |
3546 | +// SP 9 | |
3547 | +// VERIFY SP | |
3548 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3549 | +PUSH(47LLU);// SP 10 | |
3550 | +// VERIFY SP | |
3551 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3552 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF19LLU, 0xA1CBDE8EAAEF0000LLU); | |
3553 | +case 0xFFFFFFFFFFFFFF19LLU: | |
3554 | +// SP 5 | |
3555 | +if(!POP) | |
3556 | +// SP 4 | |
3557 | + JUMP(0xFFFFFFFFFFFFFF1BLLU); // skip consequent | |
1735 | 3558 | // consequent |
1736 | 3559 | |
1737 | - PUSH(0); // place-holder for result of block | |
1738 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3560 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3561 | +// SP 5 | |
3562 | +// VERIFY SP | |
3563 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1739 | 3564 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1740 | 3565 | |
1741 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF24LLU, 0x7AAA28829BC00000LLU); | |
1742 | -case 0xFFFFFFFFFFFFFF24LLU: | |
3566 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
3567 | +// SP 10 | |
3568 | +// VERIFY SP | |
3569 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3570 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF18LLU, 0x7AAA28829BC00000LLU); | |
3571 | +case 0xFFFFFFFFFFFFFF18LLU: | |
3572 | +// SP 6 | |
1743 | 3573 | |
1744 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3574 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3575 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3576 | +// SP 5 | |
1745 | 3577 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1746 | - JUMP(0xFFFFFFFFFFFFFF26LLU); // skip alternative | |
1747 | -case 0xFFFFFFFFFFFFFF27LLU: // alternative | |
3578 | +// SP 4 | |
3579 | +// VERIFY SP | |
3580 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3581 | + JUMP(0xFFFFFFFFFFFFFF1ALLU); // skip alternative | |
3582 | +case 0xFFFFFFFFFFFFFF1BLLU: // alternative | |
1748 | 3583 | |
1749 | 3584 | |
1750 | - PUSH(0); // place-holder for result of block | |
1751 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3585 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3586 | +// SP 5 | |
3587 | +// VERIFY SP | |
3588 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1752 | 3589 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1753 | 3590 | |
1754 | 3591 | // predicate |
1755 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(42LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF21LLU, 0xA1CBDE8EAAEF0000LLU); | |
1756 | -case 0xFFFFFFFFFFFFFF21LLU: | |
1757 | -if(!ACCESS_CURRENT) | |
1758 | - JUMP(0xFFFFFFFFFFFFFF23LLU); // skip consequent | |
3592 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
3593 | +// SP 10 | |
3594 | +// VERIFY SP | |
3595 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3596 | +PUSH(42LLU);// SP 11 | |
3597 | +// VERIFY SP | |
3598 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3599 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF15LLU, 0xA1CBDE8EAAEF0000LLU); | |
3600 | +case 0xFFFFFFFFFFFFFF15LLU: | |
3601 | +// SP 6 | |
3602 | +if(!POP) | |
3603 | +// SP 5 | |
3604 | + JUMP(0xFFFFFFFFFFFFFF17LLU); // skip consequent | |
1759 | 3605 | // consequent |
1760 | 3606 | |
1761 | - PUSH(0); // place-holder for result of block | |
1762 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3607 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3608 | +// SP 6 | |
3609 | +// VERIFY SP | |
3610 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1763 | 3611 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1764 | 3612 | |
1765 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF20LLU, 0x7AAA28829BC00001LLU); | |
1766 | -case 0xFFFFFFFFFFFFFF20LLU: | |
3613 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
3614 | +// SP 11 | |
3615 | +// VERIFY SP | |
3616 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3617 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF14LLU, 0x7AAA28829BC00001LLU); | |
3618 | +case 0xFFFFFFFFFFFFFF14LLU: | |
3619 | +// SP 7 | |
1767 | 3620 | |
1768 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3621 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3622 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3623 | +// SP 6 | |
1769 | 3624 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1770 | - JUMP(0xFFFFFFFFFFFFFF22LLU); // skip alternative | |
1771 | -case 0xFFFFFFFFFFFFFF23LLU: // alternative | |
3625 | +// SP 5 | |
3626 | +// VERIFY SP | |
3627 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3628 | + JUMP(0xFFFFFFFFFFFFFF16LLU); // skip alternative | |
3629 | +case 0xFFFFFFFFFFFFFF17LLU: // alternative | |
1772 | 3630 | |
1773 | 3631 | |
1774 | - PUSH(0); // place-holder for result of block | |
1775 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3632 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3633 | +// SP 6 | |
3634 | +// VERIFY SP | |
3635 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1776 | 3636 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1777 | 3637 | |
1778 | 3638 | fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); |
1779 | 3639 | fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin)); // XXX use get |
1780 | 3640 | exit(-1); |
1781 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3641 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3642 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3643 | +// SP 6 | |
1782 | 3644 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1783 | -case 0xFFFFFFFFFFFFFF22LLU: // skip to here | |
3645 | +// SP 5 | |
3646 | +// VERIFY SP | |
3647 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3648 | +case 0xFFFFFFFFFFFFFF16LLU: // skip to here | |
1784 | 3649 | |
1785 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3650 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3651 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3652 | +// SP 5 | |
1786 | 3653 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1787 | -case 0xFFFFFFFFFFFFFF26LLU: // skip to here | |
3654 | +// SP 4 | |
3655 | +// VERIFY SP | |
3656 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3657 | +case 0xFFFFFFFFFFFFFF1ALLU: // skip to here | |
1788 | 3658 | |
1789 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3659 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3660 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3661 | +// SP 4 | |
1790 | 3662 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1791 | - JUMP(0xFFFFFFFFFFFFFF29LLU); // skip alternative | |
1792 | -case 0xFFFFFFFFFFFFFF2ALLU: // alternative | |
3663 | +// SP 3 | |
3664 | +// VERIFY SP | |
3665 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3666 | + JUMP(0xFFFFFFFFFFFFFF1DLLU); // skip alternative | |
3667 | +case 0xFFFFFFFFFFFFFF1ELLU: // alternative | |
1793 | 3668 | |
1794 | 3669 | |
1795 | - PUSH(0); // place-holder for result of block | |
1796 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3670 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3671 | +// SP 4 | |
3672 | +// VERIFY SP | |
3673 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1797 | 3674 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1798 | 3675 | |
1799 | 3676 | fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); |
1800 | 3677 | fprintf(stderr, "expected function definition but found unexpected '%c' (%d)\n", ungetc(fgetc(stdin), stdin), (int)ungetc(fgetc(stdin), stdin)); |
1801 | 3678 | exit(-1); |
1802 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3679 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3680 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3681 | +// SP 4 | |
1803 | 3682 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1804 | -case 0xFFFFFFFFFFFFFF29LLU: // skip to here | |
3683 | +// SP 3 | |
3684 | +// VERIFY SP | |
3685 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3686 | +case 0xFFFFFFFFFFFFFF1DLLU: // skip to here | |
1805 | 3687 | |
1806 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3688 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3689 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3690 | +// SP 3 | |
1807 | 3691 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1808 | -case 0xFFFFFFFFFFFFFF2ELLU: // skip to here | |
3692 | +// SP 2 | |
3693 | +// VERIFY SP | |
3694 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3695 | +case 0xFFFFFFFFFFFFFF22LLU: // skip to here | |
1809 | 3696 | |
1810 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF1FLLU, 0xBA692B7A8A6FB800LLU); | |
1811 | -case 0xFFFFFFFFFFFFFF1FLLU: | |
3697 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
3698 | +// SP 7 | |
3699 | +// VERIFY SP | |
3700 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3701 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF13LLU, 0xBA692B7A8A6FB800LLU); | |
3702 | +case 0xFFFFFFFFFFFFFF13LLU: | |
3703 | +// SP 3 | |
1812 | 3704 | |
1813 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3705 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3706 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3707 | +// SP 2 | |
1814 | 3708 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1815 | - JUMP(0xFFFFFFFFFFFFFF33LLU); // loop | |
1816 | -case 0xFFFFFFFFFFFFFF32LLU: // skip to here | |
3709 | +// SP 1 | |
3710 | +// VERIFY SP | |
3711 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3712 | + JUMP(0xFFFFFFFFFFFFFF27LLU); // loop | |
3713 | +case 0xFFFFFFFFFFFFFF26LLU: // skip to here | |
1817 | 3714 | |
1818 | 3715 | RET; |
1819 | 3716 | |
1820 | 3717 | |
1821 | -case /*parsewhile*/0xADCB6E8328E49E00LLU: | |
3718 | +case /*parsewhile*/0xADCB6E8328E49E00LLU:// SP 0 | |
3719 | +// VERIFY SP | |
3720 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1822 | 3721 | |
3722 | + | |
1823 | 3723 | fprintf(stdout, "case 0x%0llXLLU%c // loop to here\n", (long long unsigned int)--ADDR, 58); |
1824 | 3724 | ACCESS_RETURN = --ADDR; // HACK store addr in return |
1825 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF1ELLU, 0xBA692B7A8A6FB800LLU); | |
1826 | -case 0xFFFFFFFFFFFFFF1ELLU: | |
3725 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
3726 | +// SP 5 | |
3727 | +// VERIFY SP | |
3728 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3729 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF12LLU, 0xBA692B7A8A6FB800LLU); | |
3730 | +case 0xFFFFFFFFFFFFFF12LLU: | |
3731 | +// SP 1 | |
1827 | 3732 | |
1828 | 3733 | fprintf(stdout, "// predicate\n"); |
1829 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF1DLLU, 0xADCB6E820CEBB400LLU); | |
1830 | -case 0xFFFFFFFFFFFFFF1DLLU: | |
3734 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
3735 | +// SP 6 | |
3736 | +// VERIFY SP | |
3737 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3738 | +PUSH(ACCESS_ARG(0)); | |
3739 | +// SP 7 | |
3740 | +// VERIFY SP | |
3741 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3742 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF11LLU, 0xADCB6E820CEBB400LLU); | |
3743 | +case 0xFFFFFFFFFFFFFF11LLU: | |
3744 | +// SP 2 | |
1831 | 3745 | |
1832 | - fprintf(stdout, "if(!ACCESS_CURRENT)\n"); | |
3746 | + fprintf(stdout, "if(!POP)\n"); SP_ADD(-1); // XXX VERIFY CRASHES HERE XXX | |
1833 | 3747 | fprintf(stdout, " JUMP(0x%0llXLLU); // skip loop\n", (long long unsigned int)ACCESS_RETURN); |
1834 | 3748 | fprintf(stdout, "// loop\n"); |
1835 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF1CLLU, 0xBA692B7A8A6FB800LLU); | |
1836 | -case 0xFFFFFFFFFFFFFF1CLLU: | |
3749 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
3750 | +// SP 7 | |
3751 | +// VERIFY SP | |
3752 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3753 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF10LLU, 0xBA692B7A8A6FB800LLU); | |
3754 | +case 0xFFFFFFFFFFFFFF10LLU: | |
3755 | +// SP 3 | |
1837 | 3756 | |
1838 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(123LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF1BLLU, 0xA1CBDE8C00000000LLU); | |
1839 | -case 0xFFFFFFFFFFFFFF1BLLU: | |
3757 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
3758 | +// SP 8 | |
3759 | +// VERIFY SP | |
3760 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3761 | +PUSH(123LLU);// SP 9 | |
3762 | +// VERIFY SP | |
3763 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3764 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF0FLLU, 0xA1CBDE8C00000000LLU); | |
3765 | +case 0xFFFFFFFFFFFFFF0FLLU: | |
3766 | +// SP 4 | |
1840 | 3767 | |
1841 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF1ALLU, 0xADCB6E81D9EA7A60LLU); | |
1842 | -case 0xFFFFFFFFFFFFFF1ALLU: | |
3768 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 5 | |
3769 | +// SP 9 | |
3770 | +// VERIFY SP | |
3771 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3772 | +PUSH(ACCESS_ARG(0)); | |
3773 | +// SP 10 | |
3774 | +// VERIFY SP | |
3775 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3776 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF0ELLU, 0xADCB6E81D9EA7A60LLU); | |
3777 | +case 0xFFFFFFFFFFFFFF0ELLU: | |
3778 | +// SP 5 | |
1843 | 3779 | |
1844 | 3780 | fprintf(stdout, " JUMP(0x%0llXLLU); // loop\n", (long long unsigned int)ACCESS_RETURN + 1); |
1845 | 3781 | fprintf(stdout, "case 0x%0llXLLU%c // skip to here\n", (long long unsigned int)ACCESS_RETURN, 58); |
@@ -1846,37 +3782,86 @@ | ||
1846 | 3782 | RET; |
1847 | 3783 | |
1848 | 3784 | |
1849 | -case /*parseif___*/0xADCB6E8248400000LLU: | |
3785 | +case /*parseif___*/0xADCB6E8248400000LLU:// SP 0 | |
3786 | +// VERIFY SP | |
3787 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1850 | 3788 | |
3789 | + | |
1851 | 3790 | --ADDR; // reserve label |
1852 | 3791 | --ADDR; // reserve label |
1853 | 3792 | ACCESS_RETURN = ADDR; // HACK store addr in return |
1854 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF19LLU, 0xBA692B7A8A6FB800LLU); | |
1855 | -case 0xFFFFFFFFFFFFFF19LLU: | |
3793 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
3794 | +// SP 5 | |
3795 | +// VERIFY SP | |
3796 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3797 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF0DLLU, 0xBA692B7A8A6FB800LLU); | |
3798 | +case 0xFFFFFFFFFFFFFF0DLLU: | |
3799 | +// SP 1 | |
1856 | 3800 | |
1857 | 3801 | fprintf(stdout, "// predicate\n"); |
1858 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF18LLU, 0xADCB6E820CEBB400LLU); | |
1859 | -case 0xFFFFFFFFFFFFFF18LLU: | |
3802 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
3803 | +// SP 6 | |
3804 | +// VERIFY SP | |
3805 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3806 | +PUSH(ACCESS_ARG(0)); | |
3807 | +// SP 7 | |
3808 | +// VERIFY SP | |
3809 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3810 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF0CLLU, 0xADCB6E820CEBB400LLU); | |
3811 | +case 0xFFFFFFFFFFFFFF0CLLU: | |
3812 | +// SP 2 | |
1860 | 3813 | |
1861 | - fprintf(stdout, "if(!ACCESS_CURRENT)\n"); | |
3814 | + fprintf(stdout, "if(!POP)\n"); SP_ADD(-1); // XXX VERIFY CRASHES HERE XXX | |
1862 | 3815 | fprintf(stdout, " JUMP(0x%0llXLLU); // skip consequent\n", (long long unsigned int)ACCESS_RETURN + 1); |
1863 | 3816 | fprintf(stdout, "// consequent\n"); |
1864 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF17LLU, 0xBA692B7A8A6FB800LLU); | |
1865 | -case 0xFFFFFFFFFFFFFF17LLU: | |
3817 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
3818 | +// SP 7 | |
3819 | +// VERIFY SP | |
3820 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3821 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF0BLLU, 0xBA692B7A8A6FB800LLU); | |
3822 | +case 0xFFFFFFFFFFFFFF0BLLU: | |
3823 | +// SP 3 | |
1866 | 3824 | |
1867 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(123LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF16LLU, 0xA1CBDE8C00000000LLU); | |
1868 | -case 0xFFFFFFFFFFFFFF16LLU: | |
3825 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
3826 | +// SP 8 | |
3827 | +// VERIFY SP | |
3828 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3829 | +PUSH(123LLU);// SP 9 | |
3830 | +// VERIFY SP | |
3831 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3832 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF0ALLU, 0xA1CBDE8C00000000LLU); | |
3833 | +case 0xFFFFFFFFFFFFFF0ALLU: | |
3834 | +// SP 4 | |
1869 | 3835 | |
1870 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF15LLU, 0xADCB6E81D9EA7A60LLU); | |
1871 | -case 0xFFFFFFFFFFFFFF15LLU: | |
3836 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 5 | |
3837 | +// SP 9 | |
3838 | +// VERIFY SP | |
3839 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3840 | +PUSH(ACCESS_ARG(0)); | |
3841 | +// SP 10 | |
3842 | +// VERIFY SP | |
3843 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3844 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF09LLU, 0xADCB6E81D9EA7A60LLU); | |
3845 | +case 0xFFFFFFFFFFFFFF09LLU: | |
3846 | +// SP 5 | |
1872 | 3847 | |
1873 | 3848 | fprintf(stdout, " JUMP(0x%0llXLLU); // skip alternative\n", (long long unsigned int)ACCESS_RETURN); |
1874 | 3849 | fprintf(stdout, "case 0x%0llXLLU%c // alternative\n", (long long unsigned int)ACCESS_RETURN + 1, 58); |
1875 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF14LLU, 0xBA692B7A8A6FB800LLU); | |
1876 | -case 0xFFFFFFFFFFFFFF14LLU: | |
3850 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
3851 | +// SP 10 | |
3852 | +// VERIFY SP | |
3853 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3854 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF08LLU, 0xBA692B7A8A6FB800LLU); | |
3855 | +case 0xFFFFFFFFFFFFFF08LLU: | |
3856 | +// SP 6 | |
1877 | 3857 | |
1878 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF13LLU, 0xADCB6E8247C00000LLU); | |
1879 | -case 0xFFFFFFFFFFFFFF13LLU: | |
3858 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
3859 | +// SP 11 | |
3860 | +// VERIFY SP | |
3861 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3862 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF07LLU, 0xADCB6E8247C00000LLU); | |
3863 | +case 0xFFFFFFFFFFFFFF07LLU: | |
3864 | +// SP 7 | |
1880 | 3865 | |
1881 | 3866 | if(0x827BA00000000000LLU != ACCESS_CURRENT) |
1882 | 3867 | { |
@@ -1884,36 +3869,73 @@ | ||
1884 | 3869 | fprintf(stderr, "missing keyword \"else\"\n"); |
1885 | 3870 | exit(-1); |
1886 | 3871 | } |
1887 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF12LLU, 0xBA692B7A8A6FB800LLU); | |
1888 | -case 0xFFFFFFFFFFFFFF12LLU: | |
3872 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
3873 | +// SP 12 | |
3874 | +// VERIFY SP | |
3875 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3876 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF06LLU, 0xBA692B7A8A6FB800LLU); | |
3877 | +case 0xFFFFFFFFFFFFFF06LLU: | |
3878 | +// SP 8 | |
1889 | 3879 | |
1890 | 3880 | // predicate |
1891 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(123LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF0FLLU, 0xA1CBDE8EAAEF0000LLU); | |
1892 | -case 0xFFFFFFFFFFFFFF0FLLU: | |
1893 | -if(!ACCESS_CURRENT) | |
1894 | - JUMP(0xFFFFFFFFFFFFFF11LLU); // skip consequent | |
3881 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 9 | |
3882 | +// SP 13 | |
3883 | +// VERIFY SP | |
3884 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3885 | +PUSH(123LLU);// SP 14 | |
3886 | +// VERIFY SP | |
3887 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3888 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF03LLU, 0xA1CBDE8EAAEF0000LLU); | |
3889 | +case 0xFFFFFFFFFFFFFF03LLU: | |
3890 | +// SP 9 | |
3891 | +if(!POP) | |
3892 | +// SP 8 | |
3893 | + JUMP(0xFFFFFFFFFFFFFF05LLU); // skip consequent | |
1895 | 3894 | // consequent |
1896 | 3895 | |
1897 | - PUSH(0); // place-holder for result of block | |
1898 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3896 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3897 | +// SP 9 | |
3898 | +// VERIFY SP | |
3899 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1899 | 3900 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1900 | 3901 | |
1901 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF0ELLU, 0xADCB6E81D9EA7A60LLU); | |
1902 | -case 0xFFFFFFFFFFFFFF0ELLU: | |
3902 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 10 | |
3903 | +// SP 14 | |
3904 | +// VERIFY SP | |
3905 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3906 | +PUSH(ACCESS_ARG(0)); | |
3907 | +// SP 15 | |
3908 | +// VERIFY SP | |
3909 | +if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3910 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFF02LLU, 0xADCB6E81D9EA7A60LLU); | |
3911 | +case 0xFFFFFFFFFFFFFF02LLU: | |
3912 | +// SP 10 | |
1903 | 3913 | |
1904 | 3914 | fprintf(stdout, "case 0x%0llXLLU%c // skip to here\n", (long long unsigned int)ACCESS_RETURN, 58); |
1905 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3915 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3916 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3917 | +// SP 9 | |
1906 | 3918 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1907 | - JUMP(0xFFFFFFFFFFFFFF10LLU); // skip alternative | |
1908 | -case 0xFFFFFFFFFFFFFF11LLU: // alternative | |
3919 | +// SP 8 | |
3920 | +// VERIFY SP | |
3921 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3922 | + JUMP(0xFFFFFFFFFFFFFF04LLU); // skip alternative | |
3923 | +case 0xFFFFFFFFFFFFFF05LLU: // alternative | |
1909 | 3924 | |
1910 | 3925 | |
1911 | - PUSH(0); // place-holder for result of block | |
1912 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3926 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
3927 | +// SP 9 | |
3928 | +// VERIFY SP | |
3929 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1913 | 3930 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1914 | 3931 | |
1915 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF0DLLU, 0xADCB6E8247C00000LLU); | |
1916 | -case 0xFFFFFFFFFFFFFF0DLLU: | |
3932 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 10 | |
3933 | +// SP 14 | |
3934 | +// VERIFY SP | |
3935 | +if(sp$$$ != 14LLU) { fprintf(stderr, "verify failed, sp %llu != 14 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3936 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF01LLU, 0xADCB6E8247C00000LLU); | |
3937 | +case 0xFFFFFFFFFFFFFF01LLU: | |
3938 | +// SP 10 | |
1917 | 3939 | |
1918 | 3940 | if(10524912329164849152LLU != ACCESS_CURRENT) // XXX omitting block in case of else-if is broken XXX |
1919 | 3941 | { |
@@ -1921,284 +3943,589 @@ | ||
1921 | 3943 | fprintf(stdout, "expected either keyword \"if\" or open block '{'\n"); |
1922 | 3944 | exit(-1); |
1923 | 3945 | } |
1924 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF0CLLU, 0xADCB6E8248400000LLU); | |
1925 | -case 0xFFFFFFFFFFFFFF0CLLU: | |
3946 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 11 | |
3947 | +// SP 15 | |
3948 | +// VERIFY SP | |
3949 | +if(sp$$$ != 15LLU) { fprintf(stderr, "verify failed, sp %llu != 15 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3950 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFF00LLU, 0xADCB6E8248400000LLU); | |
3951 | +case 0xFFFFFFFFFFFFFF00LLU: | |
3952 | +// SP 11 | |
1926 | 3953 | |
1927 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3954 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
3955 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
3956 | +// SP 9 | |
1928 | 3957 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1929 | -case 0xFFFFFFFFFFFFFF10LLU: // skip to here | |
3958 | +// SP 8 | |
3959 | +// VERIFY SP | |
3960 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3961 | +case 0xFFFFFFFFFFFFFF04LLU: // skip to here | |
1930 | 3962 | |
1931 | 3963 | RET; |
1932 | 3964 | |
1933 | 3965 | |
1934 | -case /*parsecall_*/0xADCB6E81E7279C00LLU: | |
3966 | +case /*parsecall_*/0xADCB6E81E7279C00LLU:// SP 0 | |
3967 | +// VERIFY SP | |
3968 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1935 | 3969 | |
1936 | - CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF0BLLU, 0xADCB6E8247C00000LLU); | |
1937 | -case 0xFFFFFFFFFFFFFF0BLLU: | |
1938 | -PUSH(0LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFF0ALLU, 0xADCB6E81E7279F80LLU); | |
1939 | -case 0xFFFFFFFFFFFFFF0ALLU: | |
1940 | 3970 | |
3971 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
3972 | +// SP 5 | |
3973 | +// VERIFY SP | |
3974 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3975 | +PUSH(ACCESS_ARG(0)); | |
3976 | +// SP 6 | |
3977 | +// VERIFY SP | |
3978 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3979 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
3980 | +// SP 11 | |
3981 | +// VERIFY SP | |
3982 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3983 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFEFFLLU, 0xADCB6E8247C00000LLU); | |
3984 | +case 0xFFFFFFFFFFFFFEFFLLU: | |
3985 | +// SP 7 | |
3986 | +PUSH(0LLU);// SP 8 | |
3987 | +// VERIFY SP | |
3988 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
3989 | +CALLEND(3LLU, 0xFFFFFFFFFFFFFEFELLU, 0xADCB6E81E7279F80LLU); | |
3990 | +case 0xFFFFFFFFFFFFFEFELLU: | |
3991 | +// SP 1 | |
3992 | + | |
1941 | 3993 | RET; |
1942 | 3994 | |
1943 | 3995 | |
1944 | -case /*parsecall2*/0xADCB6E81E7279F80LLU: | |
3996 | +case /*parsecall2*/0xADCB6E81E7279F80LLU:// SP 0 | |
3997 | +// VERIFY SP | |
3998 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1945 | 3999 | |
1946 | - ACCESS_RETURN = ACCESS_ARG(0); // HACK store id in return value | |
1947 | 4000 | |
4001 | + ACCESS_RETURN = ACCESS_ARG(1); // HACK store id in return value | |
4002 | + | |
1948 | 4003 | fputs("CALLBEGIN(1/*nr of chunks returned*/); ", stdout); // NOTE do NOT enclose in block because a case-label can appear inbetween if nested call |
4004 | + SP_ADD(1); | |
4005 | + ACCESS_ARG(0) = SP; // XXX HACK store estimate in argument XXX | |
4006 | + SP_ADD_VERIFY(4); | |
1949 | 4007 | |
1950 | 4008 | // predicate |
1951 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(40LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFF07LLU, 0xA1CBDE8EAAEF0000LLU); | |
1952 | -case 0xFFFFFFFFFFFFFF07LLU: | |
1953 | -if(!ACCESS_CURRENT) | |
1954 | - JUMP(0xFFFFFFFFFFFFFF09LLU); // skip consequent | |
4009 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
4010 | +// SP 5 | |
4011 | +// VERIFY SP | |
4012 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4013 | +PUSH(40LLU);// SP 6 | |
4014 | +// VERIFY SP | |
4015 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4016 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFEFBLLU, 0xA1CBDE8EAAEF0000LLU); | |
4017 | +case 0xFFFFFFFFFFFFFEFBLLU: | |
4018 | +// SP 1 | |
4019 | +if(!POP) | |
4020 | +// SP 0 | |
4021 | + JUMP(0xFFFFFFFFFFFFFEFDLLU); // skip consequent | |
1955 | 4022 | // consequent |
1956 | 4023 | |
1957 | - PUSH(0); // place-holder for result of block | |
1958 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4024 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4025 | +// SP 1 | |
4026 | +// VERIFY SP | |
4027 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1959 | 4028 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1960 | 4029 | |
1961 | - case 0xFFFFFFFFFFFFFF06LLU: // loop to here | |
4030 | + case 0xFFFFFFFFFFFFFEFALLU: // loop to here | |
1962 | 4031 | // predicate |
1963 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(41LLU);CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF04LLU, 0xAE08260000000000LLU); | |
1964 | -case 0xFFFFFFFFFFFFFF04LLU: | |
1965 | -CALLEND(2LLU, 0xFFFFFFFFFFFFFF03LLU, 0xA60B000000000000LLU); | |
1966 | -case 0xFFFFFFFFFFFFFF03LLU: | |
1967 | -if(!ACCESS_CURRENT) | |
1968 | - JUMP(0xFFFFFFFFFFFFFF05LLU); // skip loop | |
4032 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
4033 | +// SP 6 | |
4034 | +// VERIFY SP | |
4035 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4036 | +PUSH(41LLU);// SP 7 | |
4037 | +// VERIFY SP | |
4038 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4039 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
4040 | +// SP 12 | |
4041 | +// VERIFY SP | |
4042 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4043 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFEF8LLU, 0xAE08260000000000LLU); | |
4044 | +case 0xFFFFFFFFFFFFFEF8LLU: | |
4045 | +// SP 8 | |
4046 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFEF7LLU, 0xA60B000000000000LLU); | |
4047 | +case 0xFFFFFFFFFFFFFEF7LLU: | |
4048 | +// SP 2 | |
4049 | +if(!POP) | |
4050 | +// SP 1 | |
4051 | + JUMP(0xFFFFFFFFFFFFFEF9LLU); // skip loop | |
1969 | 4052 | // loop |
1970 | 4053 | |
1971 | - PUSH(0); // place-holder for result of block | |
1972 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4054 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4055 | +// SP 2 | |
4056 | +// VERIFY SP | |
4057 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1973 | 4058 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1974 | 4059 | |
1975 | 4060 | // predicate |
1976 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFF00LLU, 0xAE08260000000000LLU); | |
1977 | -case 0xFFFFFFFFFFFFFF00LLU: | |
1978 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFEFFLLU, 0x92E7E48A4BC00000LLU); | |
1979 | -case 0xFFFFFFFFFFFFFEFFLLU: | |
1980 | -if(!ACCESS_CURRENT) | |
1981 | - JUMP(0xFFFFFFFFFFFFFF02LLU); // skip consequent | |
4061 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
4062 | +// SP 7 | |
4063 | +// VERIFY SP | |
4064 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4065 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
4066 | +// SP 12 | |
4067 | +// VERIFY SP | |
4068 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4069 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFEF4LLU, 0xAE08260000000000LLU); | |
4070 | +case 0xFFFFFFFFFFFFFEF4LLU: | |
4071 | +// SP 8 | |
4072 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFEF3LLU, 0x92E7E48A4BC00000LLU); | |
4073 | +case 0xFFFFFFFFFFFFFEF3LLU: | |
4074 | +// SP 3 | |
4075 | +if(!POP) | |
4076 | +// SP 2 | |
4077 | + JUMP(0xFFFFFFFFFFFFFEF6LLU); // skip consequent | |
1982 | 4078 | // consequent |
1983 | 4079 | |
1984 | - PUSH(0); // place-holder for result of block | |
1985 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4080 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4081 | +// SP 3 | |
4082 | +// VERIFY SP | |
4083 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
1986 | 4084 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
1987 | 4085 | |
1988 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(ACCESS_ARG(1)); | |
1989 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFEFELLU, 0xAF0BA37AAA6EBC00LLU); | |
1990 | -case 0xFFFFFFFFFFFFFEFELLU: | |
4086 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
4087 | +// SP 8 | |
4088 | +// VERIFY SP | |
4089 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4090 | +PUSH(ACCESS_ARG(2)); | |
4091 | +// SP 9 | |
4092 | +// VERIFY SP | |
4093 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4094 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFEF2LLU, 0xAF0BA37AAA6EBC00LLU); | |
4095 | +case 0xFFFFFFFFFFFFFEF2LLU: | |
4096 | +// SP 4 | |
1991 | 4097 | |
1992 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4098 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4099 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4100 | +// SP 3 | |
1993 | 4101 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
1994 | - JUMP(0xFFFFFFFFFFFFFF01LLU); // skip alternative | |
1995 | -case 0xFFFFFFFFFFFFFF02LLU: // alternative | |
4102 | +// SP 2 | |
4103 | +// VERIFY SP | |
4104 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4105 | + JUMP(0xFFFFFFFFFFFFFEF5LLU); // skip alternative | |
4106 | +case 0xFFFFFFFFFFFFFEF6LLU: // alternative | |
1996 | 4107 | |
1997 | 4108 | |
1998 | - PUSH(0); // place-holder for result of block | |
1999 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4109 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4110 | +// SP 3 | |
4111 | +// VERIFY SP | |
4112 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2000 | 4113 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2001 | 4114 | |
2002 | 4115 | // predicate |
2003 | -CALLBEGIN(1/*nr of chunks returned*/); CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEFBLLU, 0xAE08260000000000LLU); | |
2004 | -case 0xFFFFFFFFFFFFFEFBLLU: | |
2005 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFEFALLU, 0x92E727AE37000000LLU); | |
2006 | -case 0xFFFFFFFFFFFFFEFALLU: | |
2007 | -if(!ACCESS_CURRENT) | |
2008 | - JUMP(0xFFFFFFFFFFFFFEFDLLU); // skip consequent | |
4116 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
4117 | +// SP 8 | |
4118 | +// VERIFY SP | |
4119 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4120 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 9 | |
4121 | +// SP 13 | |
4122 | +// VERIFY SP | |
4123 | +if(sp$$$ != 13LLU) { fprintf(stderr, "verify failed, sp %llu != 13 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4124 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFEEFLLU, 0xAE08260000000000LLU); | |
4125 | +case 0xFFFFFFFFFFFFFEEFLLU: | |
4126 | +// SP 9 | |
4127 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFEEELLU, 0x92E727AE37000000LLU); | |
4128 | +case 0xFFFFFFFFFFFFFEEELLU: | |
4129 | +// SP 4 | |
4130 | +if(!POP) | |
4131 | +// SP 3 | |
4132 | + JUMP(0xFFFFFFFFFFFFFEF1LLU); // skip consequent | |
2009 | 4133 | // consequent |
2010 | 4134 | |
2011 | - PUSH(0); // place-holder for result of block | |
2012 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4135 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4136 | +// SP 4 | |
4137 | +// VERIFY SP | |
4138 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2013 | 4139 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2014 | 4140 | |
2015 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEF9LLU, 0xADCB6E81E7279C00LLU); | |
2016 | -case 0xFFFFFFFFFFFFFEF9LLU: | |
4141 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 5 | |
4142 | +// SP 9 | |
4143 | +// VERIFY SP | |
4144 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4145 | +PUSH(ACCESS_ARG(0)); | |
4146 | +// SP 10 | |
4147 | +// VERIFY SP | |
4148 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4149 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFEEDLLU, 0xADCB6E81E7279C00LLU); | |
4150 | +case 0xFFFFFFFFFFFFFEEDLLU: | |
4151 | +// SP 5 | |
2017 | 4152 | |
2018 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4153 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4154 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4155 | +// SP 4 | |
2019 | 4156 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2020 | - JUMP(0xFFFFFFFFFFFFFEFCLLU); // skip alternative | |
2021 | -case 0xFFFFFFFFFFFFFEFDLLU: // alternative | |
4157 | +// SP 3 | |
4158 | +// VERIFY SP | |
4159 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4160 | + JUMP(0xFFFFFFFFFFFFFEF0LLU); // skip alternative | |
4161 | +case 0xFFFFFFFFFFFFFEF1LLU: // alternative | |
2022 | 4162 | |
2023 | 4163 | |
2024 | - PUSH(0); // place-holder for result of block | |
2025 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4164 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4165 | +// SP 4 | |
4166 | +// VERIFY SP | |
4167 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2026 | 4168 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2027 | 4169 | |
2028 | 4170 | // predicate |
2029 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(35LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFEF6LLU, 0xA1CBDE8EAAEF0000LLU); | |
2030 | -case 0xFFFFFFFFFFFFFEF6LLU: | |
2031 | -if(!ACCESS_CURRENT) | |
2032 | - JUMP(0xFFFFFFFFFFFFFEF8LLU); // skip consequent | |
4171 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 5 | |
4172 | +// SP 9 | |
4173 | +// VERIFY SP | |
4174 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4175 | +PUSH(35LLU);// SP 10 | |
4176 | +// VERIFY SP | |
4177 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4178 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFEEALLU, 0xA1CBDE8EAAEF0000LLU); | |
4179 | +case 0xFFFFFFFFFFFFFEEALLU: | |
4180 | +// SP 5 | |
4181 | +if(!POP) | |
4182 | +// SP 4 | |
4183 | + JUMP(0xFFFFFFFFFFFFFEECLLU); // skip consequent | |
2033 | 4184 | // consequent |
2034 | 4185 | |
2035 | - PUSH(0); // place-holder for result of block | |
2036 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4186 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4187 | +// SP 5 | |
4188 | +// VERIFY SP | |
4189 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2037 | 4190 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2038 | 4191 | |
2039 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEF5LLU, 0xAF0BA372D8800000LLU); | |
2040 | -case 0xFFFFFFFFFFFFFEF5LLU: | |
4192 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
4193 | +// SP 10 | |
4194 | +// VERIFY SP | |
4195 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4196 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFEE9LLU, 0xAF0BA372D8800000LLU); | |
4197 | +case 0xFFFFFFFFFFFFFEE9LLU: | |
4198 | +// SP 6 | |
2041 | 4199 | |
2042 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4200 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4201 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4202 | +// SP 5 | |
2043 | 4203 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2044 | - JUMP(0xFFFFFFFFFFFFFEF7LLU); // skip alternative | |
2045 | -case 0xFFFFFFFFFFFFFEF8LLU: // alternative | |
4204 | +// SP 4 | |
4205 | +// VERIFY SP | |
4206 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4207 | + JUMP(0xFFFFFFFFFFFFFEEBLLU); // skip alternative | |
4208 | +case 0xFFFFFFFFFFFFFEECLLU: // alternative | |
2046 | 4209 | |
2047 | 4210 | |
2048 | - PUSH(0); // place-holder for result of block | |
2049 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4211 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4212 | +// SP 5 | |
4213 | +// VERIFY SP | |
4214 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2050 | 4215 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2051 | 4216 | |
2052 | 4217 | // predicate |
2053 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(94LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFEF2LLU, 0xA1CBDE8EAAEF0000LLU); | |
2054 | -case 0xFFFFFFFFFFFFFEF2LLU: | |
2055 | -if(!ACCESS_CURRENT) | |
2056 | - JUMP(0xFFFFFFFFFFFFFEF4LLU); // skip consequent | |
4218 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 6 | |
4219 | +// SP 10 | |
4220 | +// VERIFY SP | |
4221 | +if(sp$$$ != 10LLU) { fprintf(stderr, "verify failed, sp %llu != 10 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4222 | +PUSH(94LLU);// SP 11 | |
4223 | +// VERIFY SP | |
4224 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4225 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFEE6LLU, 0xA1CBDE8EAAEF0000LLU); | |
4226 | +case 0xFFFFFFFFFFFFFEE6LLU: | |
4227 | +// SP 6 | |
4228 | +if(!POP) | |
4229 | +// SP 5 | |
4230 | + JUMP(0xFFFFFFFFFFFFFEE8LLU); // skip consequent | |
2057 | 4231 | // consequent |
2058 | 4232 | |
2059 | - PUSH(0); // place-holder for result of block | |
2060 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4233 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4234 | +// SP 6 | |
4235 | +// VERIFY SP | |
4236 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2061 | 4237 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2062 | 4238 | |
2063 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEF1LLU, 0xAF0BA38A7A9D0000LLU); | |
2064 | -case 0xFFFFFFFFFFFFFEF1LLU: | |
4239 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
4240 | +// SP 11 | |
4241 | +// VERIFY SP | |
4242 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4243 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFEE5LLU, 0xAF0BA38A7A9D0000LLU); | |
4244 | +case 0xFFFFFFFFFFFFFEE5LLU: | |
4245 | +// SP 7 | |
2065 | 4246 | |
2066 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4247 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4248 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4249 | +// SP 6 | |
2067 | 4250 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2068 | - JUMP(0xFFFFFFFFFFFFFEF3LLU); // skip alternative | |
2069 | -case 0xFFFFFFFFFFFFFEF4LLU: // alternative | |
4251 | +// SP 5 | |
4252 | +// VERIFY SP | |
4253 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4254 | + JUMP(0xFFFFFFFFFFFFFEE7LLU); // skip alternative | |
4255 | +case 0xFFFFFFFFFFFFFEE8LLU: // alternative | |
2070 | 4256 | |
2071 | 4257 | |
2072 | - PUSH(0); // place-holder for result of block | |
2073 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4258 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4259 | +// SP 6 | |
4260 | +// VERIFY SP | |
4261 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2074 | 4262 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2075 | 4263 | |
2076 | 4264 | // predicate |
2077 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(96LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFEEELLU, 0xA1CBDE8EAAEF0000LLU); | |
2078 | -case 0xFFFFFFFFFFFFFEEELLU: | |
2079 | -if(!ACCESS_CURRENT) | |
2080 | - JUMP(0xFFFFFFFFFFFFFEF0LLU); // skip consequent | |
4265 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 7 | |
4266 | +// SP 11 | |
4267 | +// VERIFY SP | |
4268 | +if(sp$$$ != 11LLU) { fprintf(stderr, "verify failed, sp %llu != 11 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4269 | +PUSH(96LLU);// SP 12 | |
4270 | +// VERIFY SP | |
4271 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4272 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFEE2LLU, 0xA1CBDE8EAAEF0000LLU); | |
4273 | +case 0xFFFFFFFFFFFFFEE2LLU: | |
4274 | +// SP 7 | |
4275 | +if(!POP) | |
4276 | +// SP 6 | |
4277 | + JUMP(0xFFFFFFFFFFFFFEE4LLU); // skip consequent | |
2081 | 4278 | // consequent |
2082 | 4279 | |
2083 | - PUSH(0); // place-holder for result of block | |
2084 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4280 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4281 | +// SP 7 | |
4282 | +// VERIFY SP | |
4283 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2085 | 4284 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2086 | 4285 | |
2087 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEEDLLU, 0xAF0BA3C5CB400000LLU); | |
2088 | -case 0xFFFFFFFFFFFFFEEDLLU: | |
4286 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 8 | |
4287 | +// SP 12 | |
4288 | +// VERIFY SP | |
4289 | +if(sp$$$ != 12LLU) { fprintf(stderr, "verify failed, sp %llu != 12 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4290 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFEE1LLU, 0xAF0BA3C5CB400000LLU); | |
4291 | +case 0xFFFFFFFFFFFFFEE1LLU: | |
4292 | +// SP 8 | |
2089 | 4293 | |
2090 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4294 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4295 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4296 | +// SP 7 | |
2091 | 4297 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2092 | - JUMP(0xFFFFFFFFFFFFFEEFLLU); // skip alternative | |
2093 | -case 0xFFFFFFFFFFFFFEF0LLU: // alternative | |
4298 | +// SP 6 | |
4299 | +// VERIFY SP | |
4300 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4301 | + JUMP(0xFFFFFFFFFFFFFEE3LLU); // skip alternative | |
4302 | +case 0xFFFFFFFFFFFFFEE4LLU: // alternative | |
2094 | 4303 | |
2095 | 4304 | |
2096 | - PUSH(0); // place-holder for result of block | |
2097 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4305 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4306 | +// SP 7 | |
4307 | +// VERIFY SP | |
4308 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2098 | 4309 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2099 | 4310 | |
2100 | 4311 | fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); |
2101 | 4312 | fprintf(stderr, "missing ')' in call???\n"); |
2102 | 4313 | exit(-1); |
2103 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4314 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4315 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4316 | +// SP 7 | |
2104 | 4317 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2105 | -case 0xFFFFFFFFFFFFFEEFLLU: // skip to here | |
4318 | +// SP 6 | |
4319 | +// VERIFY SP | |
4320 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4321 | +case 0xFFFFFFFFFFFFFEE3LLU: // skip to here | |
2106 | 4322 | |
2107 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4323 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4324 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4325 | +// SP 6 | |
2108 | 4326 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2109 | -case 0xFFFFFFFFFFFFFEF3LLU: // skip to here | |
4327 | +// SP 5 | |
4328 | +// VERIFY SP | |
4329 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4330 | +case 0xFFFFFFFFFFFFFEE7LLU: // skip to here | |
2110 | 4331 | |
2111 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4332 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4333 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4334 | +// SP 5 | |
2112 | 4335 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2113 | -case 0xFFFFFFFFFFFFFEF7LLU: // skip to here | |
4336 | +// SP 4 | |
4337 | +// VERIFY SP | |
4338 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4339 | +case 0xFFFFFFFFFFFFFEEBLLU: // skip to here | |
2114 | 4340 | |
2115 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4341 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4342 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4343 | +// SP 4 | |
2116 | 4344 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2117 | -case 0xFFFFFFFFFFFFFEFCLLU: // skip to here | |
4345 | +// SP 3 | |
4346 | +// VERIFY SP | |
4347 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4348 | +case 0xFFFFFFFFFFFFFEF0LLU: // skip to here | |
2118 | 4349 | |
2119 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4350 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4351 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4352 | +// SP 3 | |
2120 | 4353 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2121 | -case 0xFFFFFFFFFFFFFF01LLU: // skip to here | |
4354 | +// SP 2 | |
4355 | +// VERIFY SP | |
4356 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4357 | +case 0xFFFFFFFFFFFFFEF5LLU: // skip to here | |
2122 | 4358 | |
2123 | - ACCESS_ARG(1)++; | |
2124 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEECLLU, 0xBA692B7A8A6FB800LLU); | |
2125 | -case 0xFFFFFFFFFFFFFEECLLU: | |
4359 | + ACCESS_ARG(2)++; | |
4360 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
4361 | +// SP 7 | |
4362 | +// VERIFY SP | |
4363 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4364 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFEE0LLU, 0xBA692B7A8A6FB800LLU); | |
4365 | +case 0xFFFFFFFFFFFFFEE0LLU: | |
4366 | +// SP 3 | |
2126 | 4367 | |
2127 | 4368 | // predicate |
2128 | -CALLBEGIN(1/*nr of chunks returned*/); PUSH(44LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFEE9LLU, 0xA1CBDE8EAAEF0000LLU); | |
2129 | -case 0xFFFFFFFFFFFFFEE9LLU: | |
2130 | -if(!ACCESS_CURRENT) | |
2131 | - JUMP(0xFFFFFFFFFFFFFEEBLLU); // skip consequent | |
4369 | +CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
4370 | +// SP 8 | |
4371 | +// VERIFY SP | |
4372 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4373 | +PUSH(44LLU);// SP 9 | |
4374 | +// VERIFY SP | |
4375 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4376 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFEDDLLU, 0xA1CBDE8EAAEF0000LLU); | |
4377 | +case 0xFFFFFFFFFFFFFEDDLLU: | |
4378 | +// SP 4 | |
4379 | +if(!POP) | |
4380 | +// SP 3 | |
4381 | + JUMP(0xFFFFFFFFFFFFFEDFLLU); // skip consequent | |
2132 | 4382 | // consequent |
2133 | 4383 | |
2134 | - PUSH(0); // place-holder for result of block | |
2135 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4384 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4385 | +// SP 4 | |
4386 | +// VERIFY SP | |
4387 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2136 | 4388 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2137 | 4389 | |
2138 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE8LLU, 0xBA692B7A8A6FB800LLU); | |
2139 | -case 0xFFFFFFFFFFFFFEE8LLU: | |
4390 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 5 | |
4391 | +// SP 9 | |
4392 | +// VERIFY SP | |
4393 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4394 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFEDCLLU, 0xBA692B7A8A6FB800LLU); | |
4395 | +case 0xFFFFFFFFFFFFFEDCLLU: | |
4396 | +// SP 5 | |
2140 | 4397 | |
2141 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4398 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4399 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4400 | +// SP 4 | |
2142 | 4401 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2143 | - JUMP(0xFFFFFFFFFFFFFEEALLU); // skip alternative | |
2144 | -case 0xFFFFFFFFFFFFFEEBLLU: // alternative | |
4402 | +// SP 3 | |
4403 | +// VERIFY SP | |
4404 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4405 | + JUMP(0xFFFFFFFFFFFFFEDELLU); // skip alternative | |
4406 | +case 0xFFFFFFFFFFFFFEDFLLU: // alternative | |
2145 | 4407 | |
2146 | 4408 | |
2147 | - PUSH(0); // place-holder for result of block | |
2148 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4409 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4410 | +// SP 4 | |
4411 | +// VERIFY SP | |
4412 | +if(sp$$$ != 4LLU) { fprintf(stderr, "verify failed, sp %llu != 4 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2149 | 4413 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2150 | 4414 | |
2151 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4415 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4416 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4417 | +// SP 4 | |
2152 | 4418 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2153 | -case 0xFFFFFFFFFFFFFEEALLU: // skip to here | |
4419 | +// SP 3 | |
4420 | +// VERIFY SP | |
4421 | +if(sp$$$ != 3LLU) { fprintf(stderr, "verify failed, sp %llu != 3 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4422 | +case 0xFFFFFFFFFFFFFEDELLU: // skip to here | |
2154 | 4423 | |
2155 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4424 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4425 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4426 | +// SP 2 | |
2156 | 4427 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2157 | - JUMP(0xFFFFFFFFFFFFFF06LLU); // loop | |
2158 | -case 0xFFFFFFFFFFFFFF05LLU: // skip to here | |
4428 | +// SP 1 | |
4429 | +// VERIFY SP | |
4430 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4431 | + JUMP(0xFFFFFFFFFFFFFEFALLU); // loop | |
4432 | +case 0xFFFFFFFFFFFFFEF9LLU: // skip to here | |
2159 | 4433 | |
2160 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4434 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4435 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4436 | +// SP 1 | |
2161 | 4437 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2162 | - JUMP(0xFFFFFFFFFFFFFF08LLU); // skip alternative | |
2163 | -case 0xFFFFFFFFFFFFFF09LLU: // alternative | |
4438 | +// SP 0 | |
4439 | +// VERIFY SP | |
4440 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4441 | + JUMP(0xFFFFFFFFFFFFFEFCLLU); // skip alternative | |
4442 | +case 0xFFFFFFFFFFFFFEFDLLU: // alternative | |
2164 | 4443 | |
2165 | 4444 | |
2166 | - PUSH(0); // place-holder for result of block | |
2167 | -PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4445 | + PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block | |
4446 | +// SP 1 | |
4447 | +// VERIFY SP | |
4448 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2168 | 4449 | stack$$$[BLKINF_IDX] = sp$$$; // store base of current block |
2169 | 4450 | |
2170 | 4451 | fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]); |
2171 | 4452 | fprintf(stderr, "missing '(' in call\n"); |
2172 | 4453 | exit(-1); |
2173 | - if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); }sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4454 | + if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, "INTERNAL ERROR closing block\n"); exit(-1); } | |
4455 | +sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block | |
4456 | +// SP 1 | |
2174 | 4457 | stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block |
2175 | -case 0xFFFFFFFFFFFFFF08LLU: // skip to here | |
4458 | +// SP 0 | |
4459 | +// VERIFY SP | |
4460 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4461 | +case 0xFFFFFFFFFFFFFEFCLLU: // skip to here | |
2176 | 4462 | |
2177 | 4463 | |
2178 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE7LLU, 0xBA692B0000000000LLU); | |
2179 | -case 0xFFFFFFFFFFFFFEE7LLU: | |
4464 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
4465 | +// SP 5 | |
4466 | +// VERIFY SP | |
4467 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4468 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFEDBLLU, 0xBA692B0000000000LLU); | |
4469 | +case 0xFFFFFFFFFFFFFEDBLLU: | |
4470 | +// SP 1 | |
2180 | 4471 | |
4472 | + | |
2181 | 4473 | fprintf(stdout, "CALLEND("); |
2182 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(ACCESS_ARG(1)); | |
2183 | -CALLEND(1LLU, 0xFFFFFFFFFFFFFEE6LLU, 0xAED929BE9B400000LLU); | |
2184 | -case 0xFFFFFFFFFFFFFEE6LLU: | |
4474 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
4475 | +// SP 6 | |
4476 | +// VERIFY SP | |
4477 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4478 | +PUSH(ACCESS_ARG(2)); | |
4479 | +// SP 7 | |
4480 | +// VERIFY SP | |
4481 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4482 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFEDALLU, 0xAED929BE9B400000LLU); | |
4483 | +case 0xFFFFFFFFFFFFFEDALLU: | |
4484 | +// SP 2 | |
2185 | 4485 | // number of arguments |
2186 | 4486 | fprintf(stdout, ", 0x%0llXLLU, 0x%0llXLLU);\n", (long long unsigned int)ADDR - 1, (long long unsigned int)ACCESS_RETURN); // HACK label stored in return value |
4487 | + // SP is zero here but no need to use & can't verify - position not reached (because of break): | |
2187 | 4488 | fprintf(stdout, "case 0x%0llXLLU%c\n", (long long unsigned int)--ADDR, 58); |
4489 | + SP_SET(ACCESS_ARG(0)); // restore stack to pre-call state | |
2188 | 4490 | RET; |
2189 | 4491 | |
2190 | 4492 | |
2191 | -case /*prologue__*/0xAEDAA7AA2C200000LLU: | |
4493 | +case /*prologue__*/0xAEDAA7AA2C200000LLU:// SP 0 | |
4494 | +// VERIFY SP | |
4495 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2192 | 4496 | |
2193 | - if(sp$$$ != 0LLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, "VAR sp %llu != 0\n", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } else sp$$$++; | |
2194 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE5LLU, 0xADCB6E829B400000LLU); | |
2195 | -case 0xFFFFFFFFFFFFFEE5LLU: | |
4497 | + | |
4498 | + if(sp$$$ != 0LLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, "VAR sp %llu != 0\n", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } sp$$$++; | |
4499 | +// SP 1 | |
4500 | +// VERIFY SP | |
4501 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4502 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
4503 | +// SP 6 | |
4504 | +// VERIFY SP | |
4505 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4506 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFED9LLU, 0xADCB6E829B400000LLU); | |
4507 | +case 0xFFFFFFFFFFFFFED9LLU: | |
4508 | +// SP 2 | |
2196 | 4509 | stack$$$[sb$$$ + 0LLU] = POP; |
4510 | +// SP 1 | |
4511 | +// VERIFY SP | |
4512 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2197 | 4513 | // memory size |
2198 | - if(sp$$$ != 1LLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, "VAR sp %llu != 1\n", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } else sp$$$++; | |
2199 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE4LLU, 0xADCB6E829B400000LLU); | |
2200 | -case 0xFFFFFFFFFFFFFEE4LLU: | |
4514 | + if(sp$$$ != 1LLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, "VAR sp %llu != 1\n", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } sp$$$++; | |
4515 | +// SP 2 | |
4516 | +// VERIFY SP | |
4517 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4518 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
4519 | +// SP 7 | |
4520 | +// VERIFY SP | |
4521 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4522 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFED8LLU, 0xADCB6E829B400000LLU); | |
4523 | +case 0xFFFFFFFFFFFFFED8LLU: | |
4524 | +// SP 3 | |
2201 | 4525 | stack$$$[sb$$$ + 1LLU] = POP; |
4526 | +// SP 2 | |
4527 | +// VERIFY SP | |
4528 | +if(sp$$$ != 2LLU) { fprintf(stderr, "verify failed, sp %llu != 2 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2202 | 4529 | // global count |
2203 | 4530 | |
2204 | 4531 | stack$$$[GLOBMAX_IDX] = ACCESS_VAR(1); |
@@ -2231,11 +4558,20 @@ | ||
2231 | 4558 | fputs("#define RET { sb$$$ -= sz$$$; fn$$$ = stack$$$[--sb$$$]; /*fprintf(stderr, \"returned to 0x%0llXLLU\\n\", (long long unsigned int)fn$$$);*/ sz$$$ = stack$$$[--sb$$$]; sp$$$ = stack$$$[--sb$$$]; sb$$$ = stack$$$[sb$$$ - 1]; break; }\n", stdout); |
2232 | 4559 | fputs("#define ADDR stack$$$[ADDR_IDX]\n", stdout); |
2233 | 4560 | fputs("\n", stdout); |
4561 | + fputs("uint64_t SP = 0;\n", stdout); | |
4562 | + fputs("void SP_TRACK() { fprintf(stdout, \"// SP %llu\\n\", (long long unsigned int)SP); }\n", stdout); | |
4563 | + fputs("void SP_VERIFY() { fprintf(stdout, \"// VERIFY SP\\nif(sp$$$ != %lluLLU) { fprintf(stderr, \\\"verify failed, sp %cllu != %llu SP in line %cd\\\\n\\\", (long long unsigned int)sp$$$, __LINE__); exit(-1); }\\n\", (long long unsigned int)SP, 37, (long long unsigned int)SP, 37); }\n", stdout); | |
4564 | + fputs("uint64_t SP_SET_VERIFY(uint64_t val) { SP = val; SP_TRACK(); SP_VERIFY(); return 0; }\n", stdout); | |
4565 | + fputs("uint64_t SP_SET(uint64_t val) { SP = val; SP_TRACK(); return 0; }\n", stdout); | |
4566 | + fputs("uint64_t SP_ADD_VERIFY(uint64_t val) { SP += val; SP_TRACK(); SP_VERIFY(); return 0; }\n", stdout); | |
4567 | + fputs("uint64_t SP_ADD(uint64_t val) { SP += val; SP_TRACK(); return 0; }\n", stdout); | |
4568 | + fputs("\n", stdout); | |
2234 | 4569 | fputs("int32_t main()\n", stdout); |
2235 | 4570 | fputs("{\n", stdout); |
2236 | 4571 | fprintf(stdout, " uint64_t *stack$$$ = malloc(8 * %lluLLU);\n", (long long unsigned int)ACCESS_VAR(0)); |
2237 | 4572 | fprintf(stdout, " register uint64_t sb$$$ = %llu; // skip space reserved for globals\n", (long long unsigned int)stack$$$[GLOBMAX_IDX]); // stack base |
2238 | 4573 | fputs(" register uint64_t sp$$$ = 0;\n", stdout); // function-LOCAL stack pointer |
4574 | + SP_SET_VERIFY(0); | |
2239 | 4575 | fputs(" register uint64_t sz$$$ = 0;\n", stdout); // number of arguments (without return-value) |
2240 | 4576 | fputs(" register uint64_t fn$$$ = 0xA1C9290000000000LLU; // main-symbol\n", stdout); |
2241 | 4577 | fputs(" register uint64_t c$$$;\n", stdout); |
@@ -2248,8 +4584,11 @@ | ||
2248 | 4584 | RET; |
2249 | 4585 | |
2250 | 4586 | |
2251 | -case /*epilogue__*/0x82B927AA2C200000LLU: | |
4587 | +case /*epilogue__*/0x82B927AA2C200000LLU:// SP 0 | |
4588 | +// VERIFY SP | |
4589 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2252 | 4590 | |
4591 | + | |
2253 | 4592 | |
2254 | 4593 | fprintf(stdout, " default%c\n", 58); |
2255 | 4594 | fputs(" fn$$$ = ~0;\n", stdout); |
@@ -2265,36 +4604,88 @@ | ||
2265 | 4604 | RET; |
2266 | 4605 | |
2267 | 4606 | |
2268 | -case /*main______*/0xA1C9290000000000LLU: | |
4607 | +case /*main______*/0xA1C9290000000000LLU:// SP 0 | |
4608 | +// VERIFY SP | |
4609 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2269 | 4610 | |
4611 | + | |
2270 | 4612 | // initialize globals |
2271 | 4613 | // ^0 DON'T touch limit of global variables - stack-pointer already set! |
2272 | 4614 | //^1=0 // XXX THIS FAILS - WHY?! XXX |
2273 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(0LLU);PUSH(1LLU);CALLEND(2LLU, 0xFFFFFFFFFFFFFEE3LLU, 0xBB07400000000000LLU); | |
2274 | -case 0xFFFFFFFFFFFFFEE3LLU: | |
4615 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
4616 | +// SP 5 | |
4617 | +// VERIFY SP | |
4618 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4619 | +PUSH(0LLU);// SP 6 | |
4620 | +// VERIFY SP | |
4621 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4622 | +PUSH(1LLU);// SP 7 | |
4623 | +// VERIFY SP | |
4624 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4625 | +CALLEND(2LLU, 0xFFFFFFFFFFFFFED7LLU, 0xBB07400000000000LLU); | |
4626 | +case 0xFFFFFFFFFFFFFED7LLU: | |
4627 | +// SP 1 | |
2275 | 4628 | stack$$$[1LLU] = POP; |
4629 | +// SP 0 | |
4630 | +// VERIFY SP | |
4631 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2276 | 4632 | // internal address counter for automatically generated labels (marks) starting from highest inaccessible label FFFFFFFFFFFFFFFF encoding "9999999999" counting down to smallest inaccessible label D800000000000000 encoding "0000000000" decrementing without check because we will run out of memory long before we run out of labels |
2277 | 4633 | PUSH(0LLU); |
4634 | +// SP 1 | |
4635 | +// VERIFY SP | |
4636 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2278 | 4637 | stack$$$[2LLU] = POP; |
4638 | +// SP 0 | |
4639 | +// VERIFY SP | |
4640 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2279 | 4641 | // information of current block |
2280 | 4642 | PUSH(0LLU); |
4643 | +// SP 1 | |
4644 | +// VERIFY SP | |
4645 | +if(sp$$$ != 1LLU) { fprintf(stderr, "verify failed, sp %llu != 1 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2281 | 4646 | stack$$$[3LLU] = POP; |
4647 | +// SP 0 | |
4648 | +// VERIFY SP | |
4649 | +if(sp$$$ != 0LLU) { fprintf(stderr, "verify failed, sp %llu != 0 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
2282 | 4650 | // line-number |
2283 | 4651 | |
2284 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE2LLU, 0xAEDAA7AA2C200000LLU); | |
2285 | -case 0xFFFFFFFFFFFFFEE2LLU: | |
4652 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 1 | |
4653 | +// SP 5 | |
4654 | +// VERIFY SP | |
4655 | +if(sp$$$ != 5LLU) { fprintf(stderr, "verify failed, sp %llu != 5 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4656 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFED6LLU, 0xAEDAA7AA2C200000LLU); | |
4657 | +case 0xFFFFFFFFFFFFFED6LLU: | |
4658 | +// SP 1 | |
2286 | 4659 | |
2287 | 4660 | |
2288 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE1LLU, 0xADCB6E821A6E0000LLU); | |
2289 | -case 0xFFFFFFFFFFFFFEE1LLU: | |
4661 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 2 | |
4662 | +// SP 6 | |
4663 | +// VERIFY SP | |
4664 | +if(sp$$$ != 6LLU) { fprintf(stderr, "verify failed, sp %llu != 6 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4665 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFED5LLU, 0xADCB6E821A6E0000LLU); | |
4666 | +case 0xFFFFFFFFFFFFFED5LLU: | |
4667 | +// SP 2 | |
2290 | 4668 | |
2291 | 4669 | |
2292 | - CALLBEGIN(1/*nr of chunks returned*/); CALLEND(0LLU, 0xFFFFFFFFFFFFFEE0LLU, 0x82B927AA2C200000LLU); | |
2293 | -case 0xFFFFFFFFFFFFFEE0LLU: | |
4670 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 3 | |
4671 | +// SP 7 | |
4672 | +// VERIFY SP | |
4673 | +if(sp$$$ != 7LLU) { fprintf(stderr, "verify failed, sp %llu != 7 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4674 | +CALLEND(0LLU, 0xFFFFFFFFFFFFFED4LLU, 0x82B927AA2C200000LLU); | |
4675 | +case 0xFFFFFFFFFFFFFED4LLU: | |
4676 | +// SP 3 | |
2294 | 4677 | |
2295 | 4678 | |
2296 | - CALLBEGIN(1/*nr of chunks returned*/); PUSH(0LLU);CALLEND(1LLU, 0xFFFFFFFFFFFFFEDFLLU, 0x83392F0000000000LLU); | |
2297 | -case 0xFFFFFFFFFFFFFEDFLLU: | |
4679 | + CALLBEGIN(1/*nr of chunks returned*/); // SP 4 | |
4680 | +// SP 8 | |
4681 | +// VERIFY SP | |
4682 | +if(sp$$$ != 8LLU) { fprintf(stderr, "verify failed, sp %llu != 8 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4683 | +PUSH(0LLU);// SP 9 | |
4684 | +// VERIFY SP | |
4685 | +if(sp$$$ != 9LLU) { fprintf(stderr, "verify failed, sp %llu != 9 SP in line %d\n", (long long unsigned int)sp$$$, __LINE__); exit(-1); } | |
4686 | +CALLEND(1LLU, 0xFFFFFFFFFFFFFED3LLU, 0x83392F0000000000LLU); | |
4687 | +case 0xFFFFFFFFFFFFFED3LLU: | |
4688 | +// SP 4 | |
2298 | 4689 | |
2299 | 4690 | RET; |
2300 | 4691 |
@@ -195,6 +195,7 @@ | ||
195 | 195 | :fprintf(stdout, "PUSH(");: |
196 | 196 | echonr() |
197 | 197 | :fprintf(stdout, "LLU);\n");: |
198 | + :SP_ADD_VERIFY(1);: | |
198 | 199 | } |
199 | 200 | else |
200 | 201 | { |
@@ -216,9 +217,18 @@ | ||
216 | 217 | } |
217 | 218 | else |
218 | 219 | { |
219 | - :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);: | |
220 | - :fprintf(stderr, "unexpected '%c' in expression\n", (char)fgetc(stdin));: | |
221 | - :exit(-1);: | |
220 | + ? matchopt(40) | |
221 | + { | |
222 | + parseexpr(#0) | |
223 | + skipcmnts() | |
224 | + match(41) | |
225 | + } | |
226 | + else | |
227 | + { | |
228 | + :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);: | |
229 | + :fprintf(stderr, "unexpected '%c' in expression\n", (char)fgetc(stdin));: | |
230 | + :exit(-1);: | |
231 | + } | |
222 | 232 | } |
223 | 233 | } |
224 | 234 | } |
@@ -230,7 +240,7 @@ | ||
230 | 240 | { |
231 | 241 | skipcmnts() |
232 | 242 | match(61) |
233 | - parseexpr() | |
243 | + parseexpr(#0) | |
234 | 244 | } |
235 | 245 | |
236 | 246 | assignglob |
@@ -248,9 +258,10 @@ | ||
248 | 258 | exit(-1); |
249 | 259 | }: |
250 | 260 | |
251 | - parseexpr'() | |
261 | + parseexpr'(#0) | |
252 | 262 | |
253 | 263 | :fprintf(stdout, "stack$$$[%lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN);: |
264 | + :SP_ADD_VERIFY(-1);: | |
254 | 265 | } |
255 | 266 | |
256 | 267 | assignvar |
@@ -258,9 +269,10 @@ | ||
258 | 269 | :ACCESS_RETURN = 0;: |
259 | 270 | ? matchopt(96) |
260 | 271 | { |
261 | - parseexpr'() | |
272 | + parseexpr'(#0) | |
262 | 273 | |
263 | 274 | :fprintf(stdout, "ACCESS_RETURN = POP;\n");: |
275 | + :SP_ADD_VERIFY(-1);: | |
264 | 276 | } |
265 | 277 | else |
266 | 278 | { |
@@ -269,11 +281,13 @@ | ||
269 | 281 | :ACCESS_RETURN *= 10;: |
270 | 282 | :ACCESS_RETURN += fgetc(stdin) - '0';: // XXX use get |
271 | 283 | } |
272 | - :fprintf(stdout, "if(sp$$$ != %lluLLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, \"VAR sp %cllu != %llu\\n\", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } else sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN);: | |
284 | + :fprintf(stdout, "if(sp$$$ != %lluLLU + stack$$$[BLKINF_IDX]) { fprintf(stderr, \"VAR sp %cllu != %llu\\n\", (long long unsigned int)sp$$$ - stack$$$[BLKINF_IDX]); exit(-1); } sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN);: | |
285 | + :SP_ADD_VERIFY(1);: | |
273 | 286 | |
274 | - parseexpr'() | |
287 | + parseexpr'(#0) | |
275 | 288 | |
276 | 289 | :fprintf(stdout, "stack$$$[sb$$$ + %lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN);: |
290 | + :SP_ADD_VERIFY(-1);: | |
277 | 291 | } |
278 | 292 | } |
279 | 293 |
@@ -284,9 +298,10 @@ | ||
284 | 298 | { |
285 | 299 | skip() |
286 | 300 | |
287 | - parseexpr'() | |
301 | + parseexpr'(#0) | |
288 | 302 | |
289 | 303 | :fprintf(stdout, "ACCESS_RETURN = POP;\n");: |
304 | + :SP_ADD_VERIFY(-1);: | |
290 | 305 | } |
291 | 306 | else |
292 | 307 | { |
@@ -295,11 +310,11 @@ | ||
295 | 310 | :ACCESS_RETURN *= 10;: |
296 | 311 | :ACCESS_RETURN += fgetc(stdin) - '0';: // XXX use get |
297 | 312 | } |
298 | - :fprintf(stdout, "if(sp$$$ != %lluLLU) { fprintf(stderr, \"ARG SP %cllu != %llu\\n\", (long long unsigned int)sp$$$); exit(-1); } else sp$$$++;\n", (long long unsigned int)ACCESS_RETURN, 37, (long long unsigned int)ACCESS_RETURN);: | |
299 | 313 | |
300 | - parseexpr'() | |
314 | + parseexpr'(#0) | |
301 | 315 | |
302 | 316 | :fprintf(stdout, "stack$$$[sb$$$ - sz$$$ + %lluLLU] = POP;\n", (long long unsigned int)ACCESS_RETURN);: |
317 | + :SP_ADD_VERIFY(-1);: | |
303 | 318 | } |
304 | 319 | } |
305 | 320 |
@@ -337,6 +352,7 @@ | ||
337 | 352 | :fprintf(stdout, "PUSH(");: |
338 | 353 | parseglob() |
339 | 354 | :fprintf(stdout, ");\n");: |
355 | + :SP_ADD_VERIFY(1);: | |
340 | 356 | } |
341 | 357 | |
342 | 358 | pushvar |
@@ -346,6 +362,7 @@ | ||
346 | 362 | :fprintf(stdout, "PUSH(");: |
347 | 363 | parsevar() |
348 | 364 | :fprintf(stdout, ");\n");: |
365 | + :SP_ADD_VERIFY(1);: | |
349 | 366 | } |
350 | 367 | |
351 | 368 | pusharg |
@@ -355,6 +372,7 @@ | ||
355 | 372 | :fprintf(stdout, "PUSH(");: |
356 | 373 | parsearg() |
357 | 374 | :fprintf(stdout, ");\n");: |
375 | + :SP_ADD_VERIFY(1);: | |
358 | 376 | } |
359 | 377 | |
360 | 378 | pushconst |
@@ -364,6 +382,7 @@ | ||
364 | 382 | :fprintf(stdout, "PUSH(");: |
365 | 383 | echonr() |
366 | 384 | :fputs("LLU);", stdout);: |
385 | + :SP_ADD_VERIFY(1);/*SP_VERIFY();*/: | |
367 | 386 | } |
368 | 387 | |
369 | 388 | parsechar |
@@ -580,7 +599,7 @@ | ||
580 | 599 | { |
581 | 600 | ? isalpha(peek()) |
582 | 601 | { |
583 | - parsecall() | |
602 | + parsecall(#0) | |
584 | 603 | } |
585 | 604 | else |
586 | 605 | { |
@@ -592,51 +611,77 @@ | ||
592 | 611 | { |
593 | 612 | ? matchopt(123) |
594 | 613 | { |
595 | - parseblock() | |
614 | + parseblock(#0) | |
596 | 615 | } |
597 | 616 | else |
598 | 617 | { |
599 | 618 | ? matchopt(64) |
600 | 619 | { |
601 | - parsewhile() | |
620 | + parsewhile(#0) | |
602 | 621 | } |
603 | 622 | else |
604 | 623 | { |
605 | 624 | ? matchopt(63) |
606 | 625 | { |
607 | - parseif() | |
626 | + parseif(#0) | |
608 | 627 | } |
609 | 628 | else |
610 | 629 | { |
611 | - ? matchopt(96) | |
630 | + ? matchopt(95) | |
612 | 631 | { |
613 | - assignvar() | |
632 | + skipcmnts() | |
633 | + match(61) | |
634 | + parseexpr(#0) | |
635 | + :fprintf(stdout, "(void)POP;\n");: | |
636 | + :SP_ADD_VERIFY(-1);: | |
614 | 637 | } |
615 | 638 | else |
616 | 639 | { |
617 | - ? matchopt(94) | |
640 | + ? matchopt(96) | |
618 | 641 | { |
619 | - assignglob() | |
642 | + assignvar(#0) | |
620 | 643 | } |
621 | 644 | else |
622 | 645 | { |
623 | - ? matchopt(35) | |
646 | + ? matchopt(94) | |
624 | 647 | { |
625 | - assignarg() | |
648 | + assignglob(#0) | |
626 | 649 | } |
627 | 650 | else |
628 | 651 | { |
629 | - ? matchopt(47) | |
652 | + ? matchopt(35) | |
630 | 653 | { |
654 | + assignarg(#0) | |
655 | + } | |
656 | + else | |
657 | + { | |
631 | 658 | ? matchopt(47) |
632 | 659 | { |
633 | - comment() | |
660 | + ? matchopt(47) | |
661 | + { | |
662 | + comment() | |
663 | + } | |
664 | + else | |
665 | + { | |
666 | + ? matchopt(42) | |
667 | + { | |
668 | + comment'() | |
669 | + } | |
670 | + else | |
671 | + { | |
672 | + :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);: | |
673 | + :fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin));: // XXX use get | |
674 | + :exit(-1);: | |
675 | + } | |
676 | + } | |
634 | 677 | } |
635 | 678 | else |
636 | 679 | { |
637 | - ? matchopt(42) | |
680 | + ? matchopt(125) | |
638 | 681 | { |
639 | - comment'() | |
682 | + :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);: | |
683 | + :fprintf(stderr, "superfluous closing curly brace '}'\n");: | |
684 | + :exit(-1);: | |
640 | 685 | } |
641 | 686 | else |
642 | 687 | { |
@@ -646,21 +691,6 @@ | ||
646 | 691 | } |
647 | 692 | } |
648 | 693 | } |
649 | - else | |
650 | - { | |
651 | - ? matchopt(125) | |
652 | - { | |
653 | - :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);: | |
654 | - :fprintf(stderr, "superfluous closing curly brace '}'\n");: | |
655 | - :exit(-1);: | |
656 | - } | |
657 | - else | |
658 | - { | |
659 | - :fprintf(stderr, "[line %llu]", (long long unsigned int)stack$$$[LINENR_IDX]);: | |
660 | - :fprintf(stderr, "unexpected '%c'\n", (char)fgetc(stdin));: // XXX use get | |
661 | - :exit(-1);: | |
662 | - } | |
663 | - } | |
664 | 694 | } |
665 | 695 | } |
666 | 696 | } |
@@ -676,17 +706,22 @@ | ||
676 | 706 | |
677 | 707 | parseblock |
678 | 708 | { |
679 | - :fprintf(stdout, "PUSH(0); // place-holder for result of block\n");: | |
709 | + //:fprintf(stdout, "PUSH(0); // place-holder for result of block\n");: | |
710 | + //:SP_ADD_VERIFY(1);: | |
680 | 711 | :fprintf(stdout, "PUSH(stack$$$[BLKINF_IDX]); // store base of enclosing block\n");: |
712 | + :SP_ADD_VERIFY(1);: | |
713 | + :ACCESS_RETURN = SP;: // HACK store estimate in return | |
681 | 714 | :fprintf(stdout, "stack$$$[BLKINF_IDX] = sp$$$; // store base of current block\n");: |
682 | 715 | ://fprintf(stdout, "fprintf(stderr, \"STORE %llu\\\n\", (long long unsigned int)sp$$$);\n");: |
683 | 716 | |
684 | - parsebody() | |
717 | + parsebody(#0) | |
685 | 718 | |
686 | - :fprintf(stdout, "if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, \"INTERNAL ERROR closing block\\n\"); exit(-1); }");: | |
719 | + :fprintf(stdout, "if(stack$$$[BLKINF_IDX] == 0) { fprintf(stderr, \"INTERNAL ERROR closing block\\n\"); exit(-1); }\n");: | |
687 | 720 | :fprintf(stdout, "sp$$$ = stack$$$[BLKINF_IDX]; // restore stack pointer to state before block\n");: |
721 | + :SP_SET(ACCESS_RETURN);: | |
688 | 722 | ://fprintf(stdout, "fprintf(stderr, "RETRIEVE %llu\n", (long long unsigned int)sp$$$);\n");: |
689 | 723 | :fprintf(stdout, "stack$$$[BLKINF_IDX] = POP; // enclosing block becomes current block\n");: |
724 | + :SP_ADD_VERIFY(-1);: | |
690 | 725 | } |
691 | 726 | |
692 | 727 | parsefnnew |
@@ -704,9 +739,10 @@ | ||
704 | 739 | |
705 | 740 | parsefn |
706 | 741 | { |
742 | + :SP_SET_VERIFY(0);: | |
707 | 743 | skipcmnts() |
708 | 744 | match(123) |
709 | - parsebody() | |
745 | + parsebody(0) | |
710 | 746 | :fputs("RET;\n", stdout);: |
711 | 747 | } |
712 | 748 |
@@ -758,13 +794,13 @@ | ||
758 | 794 | :ACCESS_RETURN = --ADDR; // HACK store addr in return: |
759 | 795 | skipcmnts() |
760 | 796 | :fprintf(stdout, "// predicate\n");: |
761 | - parseexpr() | |
762 | - :fprintf(stdout, "if(!ACCESS_CURRENT)\n");: | |
797 | + parseexpr(#0) | |
798 | + :fprintf(stdout, "if(!POP)\n");: :SP_ADD(-1);: // XXX VERIFY CRASHES HERE XXX | |
763 | 799 | :fprintf(stdout, " JUMP(0x%0llXLLU); // skip loop\n", (long long unsigned int)ACCESS_RETURN);: |
764 | 800 | :fprintf(stdout, "// loop\n");: |
765 | 801 | skipcmnts() |
766 | 802 | match(123) |
767 | - parseblock() | |
803 | + parseblock(#0) | |
768 | 804 | :fprintf(stdout, " JUMP(0x%0llXLLU); // loop\n", (long long unsigned int)ACCESS_RETURN + 1);: |
769 | 805 | :fprintf(stdout, "case 0x%0llXLLU%c // skip to here\n", (long long unsigned int)ACCESS_RETURN, 58);: |
770 | 806 | } |
@@ -776,13 +812,13 @@ | ||
776 | 812 | :ACCESS_RETURN = ADDR; // HACK store addr in return: |
777 | 813 | skipcmnts() |
778 | 814 | :fprintf(stdout, "// predicate\n");: |
779 | - parseexpr() | |
780 | - :fprintf(stdout, "if(!ACCESS_CURRENT)\n");: | |
815 | + parseexpr(#0) | |
816 | + :fprintf(stdout, "if(!POP)\n");: :SP_ADD(-1);: // XXX VERIFY CRASHES HERE XXX | |
781 | 817 | :fprintf(stdout, " JUMP(0x%0llXLLU); // skip consequent\n", (long long unsigned int)ACCESS_RETURN + 1);: |
782 | 818 | :fprintf(stdout, "// consequent\n");: |
783 | 819 | skipcmnts() |
784 | 820 | match(123) |
785 | - parseblock() | |
821 | + parseblock(#0) | |
786 | 822 | :fprintf(stdout, " JUMP(0x%0llXLLU); // skip alternative\n", (long long unsigned int)ACCESS_RETURN);: |
787 | 823 | :fprintf(stdout, "case 0x%0llXLLU%c // alternative\n", (long long unsigned int)ACCESS_RETURN + 1, 58);: |
788 | 824 | skipcmnts() |
@@ -796,7 +832,7 @@ | ||
796 | 832 | skipcmnts() |
797 | 833 | ? matchopt(123) |
798 | 834 | { |
799 | - parseblock() | |
835 | + parseblock(#0) | |
800 | 836 | :fprintf(stdout, "case 0x%0llXLLU%c // skip to here\n", (long long unsigned int)ACCESS_RETURN, 58);: |
801 | 837 | } |
802 | 838 | else |
@@ -814,14 +850,17 @@ | ||
814 | 850 | |
815 | 851 | parsecall |
816 | 852 | { |
817 | - parsecall2(parseid(),0) | |
853 | + parsecall2(#0,parseid(),0) | |
818 | 854 | } |
819 | 855 | |
820 | 856 | parsecall2 |
821 | 857 | { |
822 | - :ACCESS_RETURN = ACCESS_ARG(0); // HACK store id in return value: | |
858 | + :ACCESS_RETURN = ACCESS_ARG(1); // HACK store id in return value: | |
823 | 859 | |
824 | 860 | :fputs("CALLBEGIN(1/*nr of chunks returned*/); ", stdout); // NOTE do NOT enclose in block because a case-label can appear inbetween if nested call: |
861 | + :SP_ADD(1);: | |
862 | + :ACCESS_ARG(0) = SP; // XXX HACK store estimate in argument XXX: | |
863 | + :SP_ADD_VERIFY(4);: | |
825 | 864 | |
826 | 865 | ? matchopt(40) |
827 | 866 | { |
@@ -829,13 +868,13 @@ | ||
829 | 868 | { |
830 | 869 | ? isdigit(peek()) |
831 | 870 | { |
832 | - pushconst(#1) | |
871 | + pushconst(#2) | |
833 | 872 | } |
834 | 873 | else |
835 | 874 | { |
836 | 875 | ? isalpha(peek()) |
837 | 876 | { |
838 | - parsecall() | |
877 | + parsecall(#0) | |
839 | 878 | } |
840 | 879 | else |
841 | 880 | { |
@@ -865,7 +904,7 @@ | ||
865 | 904 | } |
866 | 905 | } |
867 | 906 | } |
868 | - :ACCESS_ARG(1)++;: | |
907 | + :ACCESS_ARG(2)++;: | |
869 | 908 | skipcmnts() |
870 | 909 | ? matchopt(44) |
871 | 910 | { |
@@ -884,10 +923,13 @@ | ||
884 | 923 | } |
885 | 924 | |
886 | 925 | skip() |
926 | + | |
887 | 927 | :fprintf(stdout, "CALLEND(");: |
888 | - printnr(#1) // number of arguments | |
889 | - :fprintf(stdout, ", 0x%0llXLLU, 0x%0llXLLU);\n", (long long unsigned int)ADDR - 1, (long long unsigned int)ACCESS_RETURN); // HACK label stored in return value | |
890 | - fprintf(stdout, "case 0x%0llXLLU%c\n", (long long unsigned int)--ADDR, 58);: | |
928 | + printnr(#2) // number of arguments | |
929 | + :fprintf(stdout, ", 0x%0llXLLU, 0x%0llXLLU);\n", (long long unsigned int)ADDR - 1, (long long unsigned int)ACCESS_RETURN); // HACK label stored in return value: | |
930 | + // SP is zero here but no need to use & can't verify - position not reached (because of break): | |
931 | + :fprintf(stdout, "case 0x%0llXLLU%c\n", (long long unsigned int)--ADDR, 58);: | |
932 | + :SP_SET(ACCESS_ARG(0)); // restore stack to pre-call state: | |
891 | 933 | } |
892 | 934 | |
893 | 935 | prologue |
@@ -925,11 +967,20 @@ | ||
925 | 967 | fputs("#define RET { sb$$$ -= sz$$$; fn$$$ = stack$$$[--sb$$$]; /*fprintf(stderr, \"returned to 0x%0llXLLU\\n\", (long long unsigned int)fn$$$);*/ sz$$$ = stack$$$[--sb$$$]; sp$$$ = stack$$$[--sb$$$]; sb$$$ = stack$$$[sb$$$ - 1]; break; }\n", stdout); |
926 | 968 | fputs("#define ADDR stack$$$[ADDR_IDX]\n", stdout); |
927 | 969 | fputs("\n", stdout); |
970 | + fputs("uint64_t SP = 0;\n", stdout); | |
971 | + fputs("void SP_TRACK() { fprintf(stdout, \"// SP %llu\\n\", (long long unsigned int)SP); }\n", stdout); | |
972 | + fputs("void SP_VERIFY() { fprintf(stdout, \"// VERIFY SP\\nif(sp$$$ != %lluLLU) { fprintf(stderr, \\\"verify failed, sp %cllu != %llu SP in line %cd\\\\n\\\", (long long unsigned int)sp$$$, __LINE__); exit(-1); }\\n\", (long long unsigned int)SP, 37, (long long unsigned int)SP, 37); }\n", stdout); | |
973 | + fputs("uint64_t SP_SET_VERIFY(uint64_t val) { SP = val; SP_TRACK(); SP_VERIFY(); return 0; }\n", stdout); | |
974 | + fputs("uint64_t SP_SET(uint64_t val) { SP = val; SP_TRACK(); return 0; }\n", stdout); | |
975 | + fputs("uint64_t SP_ADD_VERIFY(uint64_t val) { SP += val; SP_TRACK(); SP_VERIFY(); return 0; }\n", stdout); | |
976 | + fputs("uint64_t SP_ADD(uint64_t val) { SP += val; SP_TRACK(); return 0; }\n", stdout); | |
977 | + fputs("\n", stdout); | |
928 | 978 | fputs("int32_t main()\n", stdout); |
929 | 979 | fputs("{\n", stdout); |
930 | 980 | fprintf(stdout, " uint64_t *stack$$$ = malloc(8 * %lluLLU);\n", (long long unsigned int)ACCESS_VAR(0)); |
931 | 981 | fprintf(stdout, " register uint64_t sb$$$ = %llu; // skip space reserved for globals\n", (long long unsigned int)stack$$$[GLOBMAX_IDX]); // stack base |
932 | 982 | fputs(" register uint64_t sp$$$ = 0;\n", stdout); // function-LOCAL stack pointer |
983 | + SP_SET_VERIFY(0); | |
933 | 984 | fputs(" register uint64_t sz$$$ = 0;\n", stdout); // number of arguments (without return-value) |
934 | 985 | fputs(" register uint64_t fn$$$ = 0xA1C9290000000000LLU; // main-symbol\n", stdout); |
935 | 986 | fputs(" register uint64_t c$$$;\n", stdout); |