aboutsummaryrefslogtreecommitdiffstats
path: root/src/uxn.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/uxn.c')
-rw-r--r--src/uxn.c3956
1 files changed, 3956 insertions, 0 deletions
diff --git a/src/uxn.c b/src/uxn.c
new file mode 100644
index 0000000..d6da3b9
--- /dev/null
+++ b/src/uxn.c
@@ -0,0 +1,3956 @@
1#include <stdio.h>
2#include "uxn.h"
3
4#define NO_STACK_CHECKS
5
6/*
7Copyright (u) 2021 Devine Lu Linvega
8Copyright (u) 2021 Andrew Alderwick
9
10Permission to use, copy, modify, and distribute this software for any
11purpose with or without fee is hereby granted, provided that the above
12copyright notice and this permission notice appear in all copies.
13
14THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
15WITH REGARD TO THIS SOFTWARE.
16*/
17
18IWRAM_CODE
19int
20evaluxn(Uxn *u, u16 vec)
21{
22 u8 instr;
23 u->ram.ptr = vec;
24 while(u->ram.ptr) {
25 instr = u->ram.dat[u->ram.ptr++];
26 switch(instr) {
27#pragma GCC diagnostic push
28#pragma GCC diagnostic ignored "-Wunused-value"
29#pragma GCC diagnostic ignored "-Wunused-variable"
30 case 0x00: /* BRK */
31 case 0x20: /* BRK2 */
32 case 0x40: /* BRKr */
33 case 0x60: /* BRK2r */
34 case 0x80: /* BRKk */
35 case 0xa0: /* BRK2k */
36 case 0xc0: /* BRKkr */
37 case 0xe0: /* BRK2kr */
38 __asm__( "evaluxn_00_BRK:" );
39 {
40 u->ram.ptr = 0;
41 }
42 break;
43 case 0x01: /* LIT */
44 case 0x81: /* LITk */
45 __asm__( "evaluxn_01_LIT:" );
46 {
47 u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++);
48#ifndef NO_STACK_CHECKS
49 if(__builtin_expect(u->wst.ptr > 254, 0)) {
50 u->wst.error = 2;
51 goto error;
52 }
53#endif
54 u->wst.ptr += 1;
55 }
56 break;
57 case 0x02: /* NOP */
58 case 0x22: /* NOP2 */
59 case 0x42: /* NOPr */
60 case 0x62: /* NOP2r */
61 case 0x82: /* NOPk */
62 case 0xa2: /* NOP2k */
63 case 0xc2: /* NOPkr */
64 case 0xe2: /* NOP2kr */
65 __asm__( "evaluxn_02_NOP:" );
66 {
67 (void)u;
68 }
69 break;
70 case 0x03: /* POP */
71 __asm__( "evaluxn_03_POP:" );
72 {
73 u->wst.dat[u->wst.ptr - 1];
74#ifndef NO_STACK_CHECKS
75 if(__builtin_expect(u->wst.ptr < 1, 0)) {
76 u->wst.error = 1;
77 goto error;
78 }
79#endif
80 u->wst.ptr -= 1;
81 }
82 break;
83 case 0x04: /* DUP */
84 __asm__( "evaluxn_04_DUP:" );
85 {
86 u8 a = u->wst.dat[u->wst.ptr - 1];
87 u->wst.dat[u->wst.ptr] = a;
88#ifndef NO_STACK_CHECKS
89 if(__builtin_expect(u->wst.ptr < 1, 0)) {
90 u->wst.error = 1;
91 goto error;
92 }
93 if(__builtin_expect(u->wst.ptr > 254, 0)) {
94 u->wst.error = 2;
95 goto error;
96 }
97#endif
98 u->wst.ptr += 1;
99 }
100 break;
101 case 0x05: /* SWP */
102 __asm__( "evaluxn_05_SWP:" );
103 {
104 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
105 u->wst.dat[u->wst.ptr - 2] = a;
106 u->wst.dat[u->wst.ptr - 1] = b;
107#ifndef NO_STACK_CHECKS
108 if(__builtin_expect(u->wst.ptr < 2, 0)) {
109 u->wst.error = 1;
110 goto error;
111 }
112#endif
113 }
114 break;
115 case 0x06: /* OVR */
116 __asm__( "evaluxn_06_OVR:" );
117 {
118 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
119 u->wst.dat[u->wst.ptr] = b;
120#ifndef NO_STACK_CHECKS
121 if(__builtin_expect(u->wst.ptr < 2, 0)) {
122 u->wst.error = 1;
123 goto error;
124 }
125 if(__builtin_expect(u->wst.ptr > 254, 0)) {
126 u->wst.error = 2;
127 goto error;
128 }
129#endif
130 u->wst.ptr += 1;
131 }
132 break;
133 case 0x07: /* ROT */
134 __asm__( "evaluxn_07_ROT:" );
135 {
136 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3];
137 u->wst.dat[u->wst.ptr - 3] = b;
138 u->wst.dat[u->wst.ptr - 2] = a;
139 u->wst.dat[u->wst.ptr - 1] = c;
140#ifndef NO_STACK_CHECKS
141 if(__builtin_expect(u->wst.ptr < 3, 0)) {
142 u->wst.error = 1;
143 goto error;
144 }
145#endif
146 }
147 break;
148 case 0x08: /* EQU */
149 __asm__( "evaluxn_08_EQU:" );
150 {
151 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
152 u->wst.dat[u->wst.ptr - 2] = b == a;
153#ifndef NO_STACK_CHECKS
154 if(__builtin_expect(u->wst.ptr < 2, 0)) {
155 u->wst.error = 1;
156 goto error;
157 }
158#endif
159 u->wst.ptr -= 1;
160 }
161 break;
162 case 0x09: /* NEQ */
163 __asm__( "evaluxn_09_NEQ:" );
164 {
165 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
166 u->wst.dat[u->wst.ptr - 2] = b != a;
167#ifndef NO_STACK_CHECKS
168 if(__builtin_expect(u->wst.ptr < 2, 0)) {
169 u->wst.error = 1;
170 goto error;
171 }
172#endif
173 u->wst.ptr -= 1;
174 }
175 break;
176 case 0x0a: /* GTH */
177 __asm__( "evaluxn_0a_GTH:" );
178 {
179 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
180 u->wst.dat[u->wst.ptr - 2] = b > a;
181#ifndef NO_STACK_CHECKS
182 if(__builtin_expect(u->wst.ptr < 2, 0)) {
183 u->wst.error = 1;
184 goto error;
185 }
186#endif
187 u->wst.ptr -= 1;
188 }
189 break;
190 case 0x0b: /* LTH */
191 __asm__( "evaluxn_0b_LTH:" );
192 {
193 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
194 u->wst.dat[u->wst.ptr - 2] = b < a;
195#ifndef NO_STACK_CHECKS
196 if(__builtin_expect(u->wst.ptr < 2, 0)) {
197 u->wst.error = 1;
198 goto error;
199 }
200#endif
201 u->wst.ptr -= 1;
202 }
203 break;
204 case 0x0c: /* JMP */
205 __asm__( "evaluxn_0c_JMP:" );
206 {
207 u8 a = u->wst.dat[u->wst.ptr - 1];
208 u->ram.ptr += (s8)a;
209#ifndef NO_STACK_CHECKS
210 if(__builtin_expect(u->wst.ptr < 1, 0)) {
211 u->wst.error = 1;
212 goto error;
213 }
214#endif
215 u->wst.ptr -= 1;
216 }
217 break;
218 case 0x0d: /* JCN */
219 __asm__( "evaluxn_0d_JCN:" );
220 {
221 u8 a = u->wst.dat[u->wst.ptr - 1];
222 if(u->wst.dat[u->wst.ptr - 2]) u->ram.ptr += (s8)a;
223#ifndef NO_STACK_CHECKS
224 if(__builtin_expect(u->wst.ptr < 2, 0)) {
225 u->wst.error = 1;
226 goto error;
227 }
228#endif
229 u->wst.ptr -= 2;
230 }
231 break;
232 case 0x0e: /* JSR */
233 __asm__( "evaluxn_0e_JSR:" );
234 {
235 u8 a = u->wst.dat[u->wst.ptr - 1];
236 u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8;
237 u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff;
238 u->ram.ptr += (s8)a;
239#ifndef NO_STACK_CHECKS
240 if(__builtin_expect(u->wst.ptr < 1, 0)) {
241 u->wst.error = 1;
242 goto error;
243 }
244#endif
245 u->wst.ptr -= 1;
246#ifndef NO_STACK_CHECKS
247 if(__builtin_expect(u->rst.ptr > 253, 0)) {
248 u->rst.error = 2;
249 goto error;
250 }
251#endif
252 u->rst.ptr += 2;
253 }
254 break;
255 case 0x0f: /* STH */
256 __asm__( "evaluxn_0f_STH:" );
257 {
258 u8 a = u->wst.dat[u->wst.ptr - 1];
259 u->rst.dat[u->rst.ptr] = a;
260#ifndef NO_STACK_CHECKS
261 if(__builtin_expect(u->wst.ptr < 1, 0)) {
262 u->wst.error = 1;
263 goto error;
264 }
265#endif
266 u->wst.ptr -= 1;
267#ifndef NO_STACK_CHECKS
268 if(__builtin_expect(u->rst.ptr > 254, 0)) {
269 u->rst.error = 2;
270 goto error;
271 }
272#endif
273 u->rst.ptr += 1;
274 }
275 break;
276 case 0x10: /* LDZ */
277 __asm__( "evaluxn_10_LDZ:" );
278 {
279 u8 a = u->wst.dat[u->wst.ptr - 1];
280 u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, a);
281#ifndef NO_STACK_CHECKS
282 if(__builtin_expect(u->wst.ptr < 1, 0)) {
283 u->wst.error = 1;
284 goto error;
285 }
286#endif
287 }
288 break;
289 case 0x11: /* STZ */
290 __asm__( "evaluxn_11_STZ:" );
291 {
292 u8 a = u->wst.dat[u->wst.ptr - 1];
293 u8 b = u->wst.dat[u->wst.ptr - 2];
294 mempoke8(u->ram.dat, a, b);
295#ifndef NO_STACK_CHECKS
296 if(__builtin_expect(u->wst.ptr < 2, 0)) {
297 u->wst.error = 1;
298 goto error;
299 }
300#endif
301 u->wst.ptr -= 2;
302 }
303 break;
304 case 0x12: /* LDR */
305 __asm__( "evaluxn_12_LDR:" );
306 {
307 u8 a = u->wst.dat[u->wst.ptr - 1];
308 u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a);
309#ifndef NO_STACK_CHECKS
310 if(__builtin_expect(u->wst.ptr < 1, 0)) {
311 u->wst.error = 1;
312 goto error;
313 }
314#endif
315 }
316 break;
317 case 0x13: /* STR */
318 __asm__( "evaluxn_13_STR:" );
319 {
320 u8 a = u->wst.dat[u->wst.ptr - 1];
321 u8 b = u->wst.dat[u->wst.ptr - 2];
322 mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b);
323#ifndef NO_STACK_CHECKS
324 if(__builtin_expect(u->wst.ptr < 2, 0)) {
325 u->wst.error = 1;
326 goto error;
327 }
328#endif
329 u->wst.ptr -= 2;
330 }
331 break;
332 case 0x14: /* LDA */
333 __asm__( "evaluxn_14_LDA:" );
334 {
335 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
336 u->wst.dat[u->wst.ptr - 2] = mempeek8(u->ram.dat, a);
337#ifndef NO_STACK_CHECKS
338 if(__builtin_expect(u->wst.ptr < 2, 0)) {
339 u->wst.error = 1;
340 goto error;
341 }
342#endif
343 u->wst.ptr -= 1;
344 }
345 break;
346 case 0x15: /* STA */
347 __asm__( "evaluxn_15_STA:" );
348 {
349 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
350 u8 b = u->wst.dat[u->wst.ptr - 3];
351 mempoke8(u->ram.dat, a, b);
352#ifndef NO_STACK_CHECKS
353 if(__builtin_expect(u->wst.ptr < 3, 0)) {
354 u->wst.error = 1;
355 goto error;
356 }
357#endif
358 u->wst.ptr -= 3;
359 }
360 break;
361 case 0x16: /* DEI */
362 __asm__( "evaluxn_16_DEI:" );
363 {
364 u8 a = u->wst.dat[u->wst.ptr - 1];
365 u->wst.dat[u->wst.ptr - 1] = devpeek8(&u->dev[a >> 4], a);
366#ifndef NO_STACK_CHECKS
367 if(__builtin_expect(u->wst.ptr < 1, 0)) {
368 u->wst.error = 1;
369 goto error;
370 }
371#endif
372 }
373 break;
374 case 0x17: /* DEO */
375 __asm__( "evaluxn_17_DEO:" );
376 {
377 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
378 devpoke8(&u->dev[a >> 4], a, b);
379#ifndef NO_STACK_CHECKS
380 if(__builtin_expect(u->wst.ptr < 2, 0)) {
381 u->wst.error = 1;
382 goto error;
383 }
384#endif
385 u->wst.ptr -= 2;
386 }
387 break;
388 case 0x18: /* ADD */
389 __asm__( "evaluxn_18_ADD:" );
390 {
391 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
392 u->wst.dat[u->wst.ptr - 2] = b + a;
393#ifndef NO_STACK_CHECKS
394 if(__builtin_expect(u->wst.ptr < 2, 0)) {
395 u->wst.error = 1;
396 goto error;
397 }
398#endif
399 u->wst.ptr -= 1;
400 }
401 break;
402 case 0x19: /* SUB */
403 __asm__( "evaluxn_19_SUB:" );
404 {
405 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
406 u->wst.dat[u->wst.ptr - 2] = b - a;
407#ifndef NO_STACK_CHECKS
408 if(__builtin_expect(u->wst.ptr < 2, 0)) {
409 u->wst.error = 1;
410 goto error;
411 }
412#endif
413 u->wst.ptr -= 1;
414 }
415 break;
416 case 0x1a: /* MUL */
417 __asm__( "evaluxn_1a_MUL:" );
418 {
419 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
420 u->wst.dat[u->wst.ptr - 2] = b * a;
421#ifndef NO_STACK_CHECKS
422 if(__builtin_expect(u->wst.ptr < 2, 0)) {
423 u->wst.error = 1;
424 goto error;
425 }
426#endif
427 u->wst.ptr -= 1;
428 }
429 break;
430 case 0x1b: /* DIV */
431 __asm__( "evaluxn_1b_DIV:" );
432 {
433 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
434 u->wst.dat[u->wst.ptr - 2] = b / a;
435#ifndef NO_STACK_CHECKS
436 if(__builtin_expect(u->wst.ptr < 2, 0)) {
437 u->wst.error = 1;
438 goto error;
439 }
440#endif
441 u->wst.ptr -= 1;
442 }
443 break;
444 case 0x1c: /* AND */
445 __asm__( "evaluxn_1c_AND:" );
446 {
447 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
448 u->wst.dat[u->wst.ptr - 2] = b & a;
449#ifndef NO_STACK_CHECKS
450 if(__builtin_expect(u->wst.ptr < 2, 0)) {
451 u->wst.error = 1;
452 goto error;
453 }
454#endif
455 u->wst.ptr -= 1;
456 }
457 break;
458 case 0x1d: /* ORA */
459 __asm__( "evaluxn_1d_ORA:" );
460 {
461 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
462 u->wst.dat[u->wst.ptr - 2] = b | a;
463#ifndef NO_STACK_CHECKS
464 if(__builtin_expect(u->wst.ptr < 2, 0)) {
465 u->wst.error = 1;
466 goto error;
467 }
468#endif
469 u->wst.ptr -= 1;
470 }
471 break;
472 case 0x1e: /* EOR */
473 __asm__( "evaluxn_1e_EOR:" );
474 {
475 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
476 u->wst.dat[u->wst.ptr - 2] = b ^ a;
477#ifndef NO_STACK_CHECKS
478 if(__builtin_expect(u->wst.ptr < 2, 0)) {
479 u->wst.error = 1;
480 goto error;
481 }
482#endif
483 u->wst.ptr -= 1;
484 }
485 break;
486 case 0x1f: /* SFT */
487 __asm__( "evaluxn_1f_SFT:" );
488 {
489 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
490 u->wst.dat[u->wst.ptr - 2] = b >> (a & 0x07) << ((a & 0x70) >> 4);
491#ifndef NO_STACK_CHECKS
492 if(__builtin_expect(u->wst.ptr < 2, 0)) {
493 u->wst.error = 1;
494 goto error;
495 }
496#endif
497 u->wst.ptr -= 1;
498 }
499 break;
500 case 0x21: /* LIT2 */
501 case 0xa1: /* LIT2k */
502 __asm__( "evaluxn_21_LIT2:" );
503 {
504 u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++);
505 u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr++);
506#ifndef NO_STACK_CHECKS
507 if(__builtin_expect(u->wst.ptr > 253, 0)) {
508 u->wst.error = 2;
509 goto error;
510 }
511#endif
512 u->wst.ptr += 2;
513 }
514 break;
515 case 0x23: /* POP2 */
516 __asm__( "evaluxn_23_POP2:" );
517 {
518 (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
519#ifndef NO_STACK_CHECKS
520 if(__builtin_expect(u->wst.ptr < 2, 0)) {
521 u->wst.error = 1;
522 goto error;
523 }
524#endif
525 u->wst.ptr -= 2;
526 }
527 break;
528 case 0x24: /* DUP2 */
529 __asm__( "evaluxn_24_DUP2:" );
530 {
531 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
532 u->wst.dat[u->wst.ptr] = b;
533 u->wst.dat[u->wst.ptr + 1] = a;
534#ifndef NO_STACK_CHECKS
535 if(__builtin_expect(u->wst.ptr < 2, 0)) {
536 u->wst.error = 1;
537 goto error;
538 }
539 if(__builtin_expect(u->wst.ptr > 253, 0)) {
540 u->wst.error = 2;
541 goto error;
542 }
543#endif
544 u->wst.ptr += 2;
545 }
546 break;
547 case 0x25: /* SWP2 */
548 __asm__( "evaluxn_25_SWP2:" );
549 {
550 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
551 u->wst.dat[u->wst.ptr - 4] = b;
552 u->wst.dat[u->wst.ptr - 3] = a;
553 u->wst.dat[u->wst.ptr - 2] = d;
554 u->wst.dat[u->wst.ptr - 1] = c;
555#ifndef NO_STACK_CHECKS
556 if(__builtin_expect(u->wst.ptr < 4, 0)) {
557 u->wst.error = 1;
558 goto error;
559 }
560#endif
561 }
562 break;
563 case 0x26: /* OVR2 */
564 __asm__( "evaluxn_26_OVR2:" );
565 {
566 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
567 u->wst.dat[u->wst.ptr] = d;
568 u->wst.dat[u->wst.ptr + 1] = c;
569#ifndef NO_STACK_CHECKS
570 if(__builtin_expect(u->wst.ptr < 4, 0)) {
571 u->wst.error = 1;
572 goto error;
573 }
574 if(__builtin_expect(u->wst.ptr > 253, 0)) {
575 u->wst.error = 2;
576 goto error;
577 }
578#endif
579 u->wst.ptr += 2;
580 }
581 break;
582 case 0x27: /* ROT2 */
583 __asm__( "evaluxn_27_ROT2:" );
584 {
585 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4], e = u->wst.dat[u->wst.ptr - 5], f = u->wst.dat[u->wst.ptr - 6];
586 u->wst.dat[u->wst.ptr - 6] = d;
587 u->wst.dat[u->wst.ptr - 5] = c;
588 u->wst.dat[u->wst.ptr - 4] = b;
589 u->wst.dat[u->wst.ptr - 3] = a;
590 u->wst.dat[u->wst.ptr - 2] = f;
591 u->wst.dat[u->wst.ptr - 1] = e;
592#ifndef NO_STACK_CHECKS
593 if(__builtin_expect(u->wst.ptr < 6, 0)) {
594 u->wst.error = 1;
595 goto error;
596 }
597#endif
598 }
599 break;
600 case 0x28: /* EQU2 */
601 __asm__( "evaluxn_28_EQU2:" );
602 {
603 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
604 u->wst.dat[u->wst.ptr - 4] = b == a;
605#ifndef NO_STACK_CHECKS
606 if(__builtin_expect(u->wst.ptr < 4, 0)) {
607 u->wst.error = 1;
608 goto error;
609 }
610#endif
611 u->wst.ptr -= 3;
612 }
613 break;
614 case 0x29: /* NEQ2 */
615 __asm__( "evaluxn_29_NEQ2:" );
616 {
617 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
618 u->wst.dat[u->wst.ptr - 4] = b != a;
619#ifndef NO_STACK_CHECKS
620 if(__builtin_expect(u->wst.ptr < 4, 0)) {
621 u->wst.error = 1;
622 goto error;
623 }
624#endif
625 u->wst.ptr -= 3;
626 }
627 break;
628 case 0x2a: /* GTH2 */
629 __asm__( "evaluxn_2a_GTH2:" );
630 {
631 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
632 u->wst.dat[u->wst.ptr - 4] = b > a;
633#ifndef NO_STACK_CHECKS
634 if(__builtin_expect(u->wst.ptr < 4, 0)) {
635 u->wst.error = 1;
636 goto error;
637 }
638#endif
639 u->wst.ptr -= 3;
640 }
641 break;
642 case 0x2b: /* LTH2 */
643 __asm__( "evaluxn_2b_LTH2:" );
644 {
645 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
646 u->wst.dat[u->wst.ptr - 4] = b < a;
647#ifndef NO_STACK_CHECKS
648 if(__builtin_expect(u->wst.ptr < 4, 0)) {
649 u->wst.error = 1;
650 goto error;
651 }
652#endif
653 u->wst.ptr -= 3;
654 }
655 break;
656 case 0x2c: /* JMP2 */
657 __asm__( "evaluxn_2c_JMP2:" );
658 {
659 u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
660#ifndef NO_STACK_CHECKS
661 if(__builtin_expect(u->wst.ptr < 2, 0)) {
662 u->wst.error = 1;
663 goto error;
664 }
665#endif
666 u->wst.ptr -= 2;
667 }
668 break;
669 case 0x2d: /* JCN2 */
670 __asm__( "evaluxn_2d_JCN2:" );
671 {
672 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
673 if(u->wst.dat[u->wst.ptr - 3]) u->ram.ptr = a;
674#ifndef NO_STACK_CHECKS
675 if(__builtin_expect(u->wst.ptr < 3, 0)) {
676 u->wst.error = 1;
677 goto error;
678 }
679#endif
680 u->wst.ptr -= 3;
681 }
682 break;
683 case 0x2e: /* JSR2 */
684 __asm__( "evaluxn_2e_JSR2:" );
685 {
686 u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8;
687 u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff;
688 u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
689#ifndef NO_STACK_CHECKS
690 if(__builtin_expect(u->wst.ptr < 2, 0)) {
691 u->wst.error = 1;
692 goto error;
693 }
694#endif
695 u->wst.ptr -= 2;
696#ifndef NO_STACK_CHECKS
697 if(__builtin_expect(u->rst.ptr > 253, 0)) {
698 u->rst.error = 2;
699 goto error;
700 }
701#endif
702 u->rst.ptr += 2;
703 }
704 break;
705 case 0x2f: /* STH2 */
706 __asm__( "evaluxn_2f_STH2:" );
707 {
708 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
709 u->rst.dat[u->rst.ptr] = b;
710 u->rst.dat[u->rst.ptr + 1] = a;
711#ifndef NO_STACK_CHECKS
712 if(__builtin_expect(u->wst.ptr < 2, 0)) {
713 u->wst.error = 1;
714 goto error;
715 }
716#endif
717 u->wst.ptr -= 2;
718#ifndef NO_STACK_CHECKS
719 if(__builtin_expect(u->rst.ptr > 253, 0)) {
720 u->rst.error = 2;
721 goto error;
722 }
723#endif
724 u->rst.ptr += 2;
725 }
726 break;
727 case 0x30: /* LDZ2 */
728 __asm__( "evaluxn_30_LDZ2:" );
729 {
730 u8 a = u->wst.dat[u->wst.ptr - 1];
731 u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, a);
732 u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a + 1);
733#ifndef NO_STACK_CHECKS
734 if(__builtin_expect(u->wst.ptr < 1, 0)) {
735 u->wst.error = 1;
736 goto error;
737 }
738 if(__builtin_expect(u->wst.ptr > 254, 0)) {
739 u->wst.error = 2;
740 goto error;
741 }
742#endif
743 u->wst.ptr += 1;
744 }
745 break;
746 case 0x31: /* STZ2 */
747 __asm__( "evaluxn_31_STZ2:" );
748 {
749 u8 a = u->wst.dat[u->wst.ptr - 1];
750 u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
751 mempoke16(u->ram.dat, a, b);
752#ifndef NO_STACK_CHECKS
753 if(__builtin_expect(u->wst.ptr < 3, 0)) {
754 u->wst.error = 1;
755 goto error;
756 }
757#endif
758 u->wst.ptr -= 3;
759 }
760 break;
761 case 0x32: /* LDR2 */
762 __asm__( "evaluxn_32_LDR2:" );
763 {
764 u8 a = u->wst.dat[u->wst.ptr - 1];
765 u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a);
766 u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1);
767#ifndef NO_STACK_CHECKS
768 if(__builtin_expect(u->wst.ptr < 1, 0)) {
769 u->wst.error = 1;
770 goto error;
771 }
772 if(__builtin_expect(u->wst.ptr > 254, 0)) {
773 u->wst.error = 2;
774 goto error;
775 }
776#endif
777 u->wst.ptr += 1;
778 }
779 break;
780 case 0x33: /* STR2 */
781 __asm__( "evaluxn_33_STR2:" );
782 {
783 u8 a = u->wst.dat[u->wst.ptr - 1];
784 u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
785 mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b);
786#ifndef NO_STACK_CHECKS
787 if(__builtin_expect(u->wst.ptr < 3, 0)) {
788 u->wst.error = 1;
789 goto error;
790 }
791#endif
792 u->wst.ptr -= 3;
793 }
794 break;
795 case 0x34: /* LDA2 */
796 __asm__( "evaluxn_34_LDA2:" );
797 {
798 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
799 u->wst.dat[u->wst.ptr - 2] = mempeek8(u->ram.dat, a);
800 u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, a + 1);
801#ifndef NO_STACK_CHECKS
802 if(__builtin_expect(u->wst.ptr < 2, 0)) {
803 u->wst.error = 1;
804 goto error;
805 }
806#endif
807 }
808 break;
809 case 0x35: /* STA2 */
810 __asm__( "evaluxn_35_STA2:" );
811 {
812 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
813 u16 b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
814 mempoke16(u->ram.dat, a, b);
815#ifndef NO_STACK_CHECKS
816 if(__builtin_expect(u->wst.ptr < 4, 0)) {
817 u->wst.error = 1;
818 goto error;
819 }
820#endif
821 u->wst.ptr -= 4;
822 }
823 break;
824 case 0x36: /* DEI2 */
825 __asm__( "evaluxn_36_DEI2:" );
826 {
827 u8 a = u->wst.dat[u->wst.ptr - 1];
828 u->wst.dat[u->wst.ptr - 1] = devpeek8(&u->dev[a >> 4], a);
829 u->wst.dat[u->wst.ptr] = devpeek8(&u->dev[a >> 4], a + 1);
830#ifndef NO_STACK_CHECKS
831 if(__builtin_expect(u->wst.ptr < 1, 0)) {
832 u->wst.error = 1;
833 goto error;
834 }
835 if(__builtin_expect(u->wst.ptr > 254, 0)) {
836 u->wst.error = 2;
837 goto error;
838 }
839#endif
840 u->wst.ptr += 1;
841 }
842 break;
843 case 0x37: /* DEO2 */
844 __asm__( "evaluxn_37_DEO2:" );
845 {
846 u8 a = u->wst.dat[u->wst.ptr - 1];
847 u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
848 devpoke16(&u->dev[a >> 4], a, b);
849#ifndef NO_STACK_CHECKS
850 if(__builtin_expect(u->wst.ptr < 3, 0)) {
851 u->wst.error = 1;
852 goto error;
853 }
854#endif
855 u->wst.ptr -= 3;
856 }
857 break;
858 case 0x38: /* ADD2 */
859 __asm__( "evaluxn_38_ADD2:" );
860 {
861 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
862 u->wst.dat[u->wst.ptr - 4] = (b + a) >> 8;
863 u->wst.dat[u->wst.ptr - 3] = (b + a) & 0xff;
864#ifndef NO_STACK_CHECKS
865 if(__builtin_expect(u->wst.ptr < 4, 0)) {
866 u->wst.error = 1;
867 goto error;
868 }
869#endif
870 u->wst.ptr -= 2;
871 }
872 break;
873 case 0x39: /* SUB2 */
874 __asm__( "evaluxn_39_SUB2:" );
875 {
876 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
877 u->wst.dat[u->wst.ptr - 4] = (b - a) >> 8;
878 u->wst.dat[u->wst.ptr - 3] = (b - a) & 0xff;
879#ifndef NO_STACK_CHECKS
880 if(__builtin_expect(u->wst.ptr < 4, 0)) {
881 u->wst.error = 1;
882 goto error;
883 }
884#endif
885 u->wst.ptr -= 2;
886 }
887 break;
888 case 0x3a: /* MUL2 */
889 __asm__( "evaluxn_3a_MUL2:" );
890 {
891 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
892 u->wst.dat[u->wst.ptr - 4] = (b * a) >> 8;
893 u->wst.dat[u->wst.ptr - 3] = (b * a) & 0xff;
894#ifndef NO_STACK_CHECKS
895 if(__builtin_expect(u->wst.ptr < 4, 0)) {
896 u->wst.error = 1;
897 goto error;
898 }
899#endif
900 u->wst.ptr -= 2;
901 }
902 break;
903 case 0x3b: /* DIV2 */
904 __asm__( "evaluxn_3b_DIV2:" );
905 {
906 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
907 u->wst.dat[u->wst.ptr - 4] = (b / a) >> 8;
908 u->wst.dat[u->wst.ptr - 3] = (b / a) & 0xff;
909#ifndef NO_STACK_CHECKS
910 if(__builtin_expect(u->wst.ptr < 4, 0)) {
911 u->wst.error = 1;
912 goto error;
913 }
914#endif
915 u->wst.ptr -= 2;
916 }
917 break;
918 case 0x3c: /* AND2 */
919 __asm__( "evaluxn_3c_AND2:" );
920 {
921 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
922 u->wst.dat[u->wst.ptr - 4] = d & b;
923 u->wst.dat[u->wst.ptr - 3] = c & a;
924#ifndef NO_STACK_CHECKS
925 if(__builtin_expect(u->wst.ptr < 4, 0)) {
926 u->wst.error = 1;
927 goto error;
928 }
929#endif
930 u->wst.ptr -= 2;
931 }
932 break;
933 case 0x3d: /* ORA2 */
934 __asm__( "evaluxn_3d_ORA2:" );
935 {
936 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
937 u->wst.dat[u->wst.ptr - 4] = d | b;
938 u->wst.dat[u->wst.ptr - 3] = c | a;
939#ifndef NO_STACK_CHECKS
940 if(__builtin_expect(u->wst.ptr < 4, 0)) {
941 u->wst.error = 1;
942 goto error;
943 }
944#endif
945 u->wst.ptr -= 2;
946 }
947 break;
948 case 0x3e: /* EOR2 */
949 __asm__( "evaluxn_3e_EOR2:" );
950 {
951 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
952 u->wst.dat[u->wst.ptr - 4] = d ^ b;
953 u->wst.dat[u->wst.ptr - 3] = c ^ a;
954#ifndef NO_STACK_CHECKS
955 if(__builtin_expect(u->wst.ptr < 4, 0)) {
956 u->wst.error = 1;
957 goto error;
958 }
959#endif
960 u->wst.ptr -= 2;
961 }
962 break;
963 case 0x3f: /* SFT2 */
964 __asm__( "evaluxn_3f_SFT2:" );
965 {
966 u8 a = u->wst.dat[u->wst.ptr - 1];
967 u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
968 u->wst.dat[u->wst.ptr - 3] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8;
969 u->wst.dat[u->wst.ptr - 2] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff;
970#ifndef NO_STACK_CHECKS
971 if(__builtin_expect(u->wst.ptr < 3, 0)) {
972 u->wst.error = 1;
973 goto error;
974 }
975#endif
976 u->wst.ptr -= 1;
977 }
978 break;
979 case 0x41: /* LITr */
980 case 0xc1: /* LITkr */
981 __asm__( "evaluxn_41_LITr:" );
982 {
983 u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++);
984#ifndef NO_STACK_CHECKS
985 if(__builtin_expect(u->rst.ptr > 254, 0)) {
986 u->rst.error = 2;
987 goto error;
988 }
989#endif
990 u->rst.ptr += 1;
991 }
992 break;
993 case 0x43: /* POPr */
994 __asm__( "evaluxn_43_POPr:" );
995 {
996 u->rst.dat[u->rst.ptr - 1];
997#ifndef NO_STACK_CHECKS
998 if(__builtin_expect(u->rst.ptr < 1, 0)) {
999 u->rst.error = 1;
1000 goto error;
1001 }
1002#endif
1003 u->rst.ptr -= 1;
1004 }
1005 break;
1006 case 0x44: /* DUPr */
1007 __asm__( "evaluxn_44_DUPr:" );
1008 {
1009 u8 a = u->rst.dat[u->rst.ptr - 1];
1010 u->rst.dat[u->rst.ptr] = a;
1011#ifndef NO_STACK_CHECKS
1012 if(__builtin_expect(u->rst.ptr < 1, 0)) {
1013 u->rst.error = 1;
1014 goto error;
1015 }
1016 if(__builtin_expect(u->rst.ptr > 254, 0)) {
1017 u->rst.error = 2;
1018 goto error;
1019 }
1020#endif
1021 u->rst.ptr += 1;
1022 }
1023 break;
1024 case 0x45: /* SWPr */
1025 __asm__( "evaluxn_45_SWPr:" );
1026 {
1027 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1028 u->rst.dat[u->rst.ptr - 2] = a;
1029 u->rst.dat[u->rst.ptr - 1] = b;
1030#ifndef NO_STACK_CHECKS
1031 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1032 u->rst.error = 1;
1033 goto error;
1034 }
1035#endif
1036 }
1037 break;
1038 case 0x46: /* OVRr */
1039 __asm__( "evaluxn_46_OVRr:" );
1040 {
1041 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1042 u->rst.dat[u->rst.ptr] = b;
1043#ifndef NO_STACK_CHECKS
1044 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1045 u->rst.error = 1;
1046 goto error;
1047 }
1048 if(__builtin_expect(u->rst.ptr > 254, 0)) {
1049 u->rst.error = 2;
1050 goto error;
1051 }
1052#endif
1053 u->rst.ptr += 1;
1054 }
1055 break;
1056 case 0x47: /* ROTr */
1057 __asm__( "evaluxn_47_ROTr:" );
1058 {
1059 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3];
1060 u->rst.dat[u->rst.ptr - 3] = b;
1061 u->rst.dat[u->rst.ptr - 2] = a;
1062 u->rst.dat[u->rst.ptr - 1] = c;
1063#ifndef NO_STACK_CHECKS
1064 if(__builtin_expect(u->rst.ptr < 3, 0)) {
1065 u->rst.error = 1;
1066 goto error;
1067 }
1068#endif
1069 }
1070 break;
1071 case 0x48: /* EQUr */
1072 __asm__( "evaluxn_48_EQUr:" );
1073 {
1074 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1075 u->rst.dat[u->rst.ptr - 2] = b == a;
1076#ifndef NO_STACK_CHECKS
1077 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1078 u->rst.error = 1;
1079 goto error;
1080 }
1081#endif
1082 u->rst.ptr -= 1;
1083 }
1084 break;
1085 case 0x49: /* NEQr */
1086 __asm__( "evaluxn_49_NEQr:" );
1087 {
1088 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1089 u->rst.dat[u->rst.ptr - 2] = b != a;
1090#ifndef NO_STACK_CHECKS
1091 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1092 u->rst.error = 1;
1093 goto error;
1094 }
1095#endif
1096 u->rst.ptr -= 1;
1097 }
1098 break;
1099 case 0x4a: /* GTHr */
1100 __asm__( "evaluxn_4a_GTHr:" );
1101 {
1102 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1103 u->rst.dat[u->rst.ptr - 2] = b > a;
1104#ifndef NO_STACK_CHECKS
1105 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1106 u->rst.error = 1;
1107 goto error;
1108 }
1109#endif
1110 u->rst.ptr -= 1;
1111 }
1112 break;
1113 case 0x4b: /* LTHr */
1114 __asm__( "evaluxn_4b_LTHr:" );
1115 {
1116 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1117 u->rst.dat[u->rst.ptr - 2] = b < a;
1118#ifndef NO_STACK_CHECKS
1119 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1120 u->rst.error = 1;
1121 goto error;
1122 }
1123#endif
1124 u->rst.ptr -= 1;
1125 }
1126 break;
1127 case 0x4c: /* JMPr */
1128 __asm__( "evaluxn_4c_JMPr:" );
1129 {
1130 u8 a = u->rst.dat[u->rst.ptr - 1];
1131 u->ram.ptr += (s8)a;
1132#ifndef NO_STACK_CHECKS
1133 if(__builtin_expect(u->rst.ptr < 1, 0)) {
1134 u->rst.error = 1;
1135 goto error;
1136 }
1137#endif
1138 u->rst.ptr -= 1;
1139 }
1140 break;
1141 case 0x4d: /* JCNr */
1142 __asm__( "evaluxn_4d_JCNr:" );
1143 {
1144 u8 a = u->rst.dat[u->rst.ptr - 1];
1145 if(u->rst.dat[u->rst.ptr - 2]) u->ram.ptr += (s8)a;
1146#ifndef NO_STACK_CHECKS
1147 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1148 u->rst.error = 1;
1149 goto error;
1150 }
1151#endif
1152 u->rst.ptr -= 2;
1153 }
1154 break;
1155 case 0x4e: /* JSRr */
1156 __asm__( "evaluxn_4e_JSRr:" );
1157 {
1158 u8 a = u->rst.dat[u->rst.ptr - 1];
1159 u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8;
1160 u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff;
1161 u->ram.ptr += (s8)a;
1162#ifndef NO_STACK_CHECKS
1163 if(__builtin_expect(u->rst.ptr < 1, 0)) {
1164 u->rst.error = 1;
1165 goto error;
1166 }
1167#endif
1168 u->rst.ptr -= 1;
1169#ifndef NO_STACK_CHECKS
1170 if(__builtin_expect(u->wst.ptr > 253, 0)) {
1171 u->wst.error = 2;
1172 goto error;
1173 }
1174#endif
1175 u->wst.ptr += 2;
1176 }
1177 break;
1178 case 0x4f: /* STHr */
1179 __asm__( "evaluxn_4f_STHr:" );
1180 {
1181 u8 a = u->rst.dat[u->rst.ptr - 1];
1182 u->wst.dat[u->wst.ptr] = a;
1183#ifndef NO_STACK_CHECKS
1184 if(__builtin_expect(u->rst.ptr < 1, 0)) {
1185 u->rst.error = 1;
1186 goto error;
1187 }
1188#endif
1189 u->rst.ptr -= 1;
1190#ifndef NO_STACK_CHECKS
1191 if(__builtin_expect(u->wst.ptr > 254, 0)) {
1192 u->wst.error = 2;
1193 goto error;
1194 }
1195#endif
1196 u->wst.ptr += 1;
1197 }
1198 break;
1199 case 0x50: /* LDZr */
1200 __asm__( "evaluxn_50_LDZr:" );
1201 {
1202 u8 a = u->rst.dat[u->rst.ptr - 1];
1203 u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, a);
1204#ifndef NO_STACK_CHECKS
1205 if(__builtin_expect(u->rst.ptr < 1, 0)) {
1206 u->rst.error = 1;
1207 goto error;
1208 }
1209#endif
1210 }
1211 break;
1212 case 0x51: /* STZr */
1213 __asm__( "evaluxn_51_STZr:" );
1214 {
1215 u8 a = u->rst.dat[u->rst.ptr - 1];
1216 u8 b = u->rst.dat[u->rst.ptr - 2];
1217 mempoke8(u->ram.dat, a, b);
1218#ifndef NO_STACK_CHECKS
1219 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1220 u->rst.error = 1;
1221 goto error;
1222 }
1223#endif
1224 u->rst.ptr -= 2;
1225 }
1226 break;
1227 case 0x52: /* LDRr */
1228 __asm__( "evaluxn_52_LDRr:" );
1229 {
1230 u8 a = u->rst.dat[u->rst.ptr - 1];
1231 u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a);
1232#ifndef NO_STACK_CHECKS
1233 if(__builtin_expect(u->rst.ptr < 1, 0)) {
1234 u->rst.error = 1;
1235 goto error;
1236 }
1237#endif
1238 }
1239 break;
1240 case 0x53: /* STRr */
1241 __asm__( "evaluxn_53_STRr:" );
1242 {
1243 u8 a = u->rst.dat[u->rst.ptr - 1];
1244 u8 b = u->rst.dat[u->rst.ptr - 2];
1245 mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b);
1246#ifndef NO_STACK_CHECKS
1247 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1248 u->rst.error = 1;
1249 goto error;
1250 }
1251#endif
1252 u->rst.ptr -= 2;
1253 }
1254 break;
1255 case 0x54: /* LDAr */
1256 __asm__( "evaluxn_54_LDAr:" );
1257 {
1258 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
1259 u->rst.dat[u->rst.ptr - 2] = mempeek8(u->ram.dat, a);
1260#ifndef NO_STACK_CHECKS
1261 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1262 u->rst.error = 1;
1263 goto error;
1264 }
1265#endif
1266 u->rst.ptr -= 1;
1267 }
1268 break;
1269 case 0x55: /* STAr */
1270 __asm__( "evaluxn_55_STAr:" );
1271 {
1272 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
1273 u8 b = u->rst.dat[u->rst.ptr - 3];
1274 mempoke8(u->ram.dat, a, b);
1275#ifndef NO_STACK_CHECKS
1276 if(__builtin_expect(u->rst.ptr < 3, 0)) {
1277 u->rst.error = 1;
1278 goto error;
1279 }
1280#endif
1281 u->rst.ptr -= 3;
1282 }
1283 break;
1284 case 0x56: /* DEIr */
1285 __asm__( "evaluxn_56_DEIr:" );
1286 {
1287 u8 a = u->rst.dat[u->rst.ptr - 1];
1288 u->rst.dat[u->rst.ptr - 1] = devpeek8(&u->dev[a >> 4], a);
1289#ifndef NO_STACK_CHECKS
1290 if(__builtin_expect(u->rst.ptr < 1, 0)) {
1291 u->rst.error = 1;
1292 goto error;
1293 }
1294#endif
1295 }
1296 break;
1297 case 0x57: /* DEOr */
1298 __asm__( "evaluxn_57_DEOr:" );
1299 {
1300 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1301 devpoke8(&u->dev[a >> 4], a, b);
1302#ifndef NO_STACK_CHECKS
1303 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1304 u->rst.error = 1;
1305 goto error;
1306 }
1307#endif
1308 u->rst.ptr -= 2;
1309 }
1310 break;
1311 case 0x58: /* ADDr */
1312 __asm__( "evaluxn_58_ADDr:" );
1313 {
1314 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1315 u->rst.dat[u->rst.ptr - 2] = b + a;
1316#ifndef NO_STACK_CHECKS
1317 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1318 u->rst.error = 1;
1319 goto error;
1320 }
1321#endif
1322 u->rst.ptr -= 1;
1323 }
1324 break;
1325 case 0x59: /* SUBr */
1326 __asm__( "evaluxn_59_SUBr:" );
1327 {
1328 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1329 u->rst.dat[u->rst.ptr - 2] = b - a;
1330#ifndef NO_STACK_CHECKS
1331 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1332 u->rst.error = 1;
1333 goto error;
1334 }
1335#endif
1336 u->rst.ptr -= 1;
1337 }
1338 break;
1339 case 0x5a: /* MULr */
1340 __asm__( "evaluxn_5a_MULr:" );
1341 {
1342 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1343 u->rst.dat[u->rst.ptr - 2] = b * a;
1344#ifndef NO_STACK_CHECKS
1345 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1346 u->rst.error = 1;
1347 goto error;
1348 }
1349#endif
1350 u->rst.ptr -= 1;
1351 }
1352 break;
1353 case 0x5b: /* DIVr */
1354 __asm__( "evaluxn_5b_DIVr:" );
1355 {
1356 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1357 u->rst.dat[u->rst.ptr - 2] = b / a;
1358#ifndef NO_STACK_CHECKS
1359 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1360 u->rst.error = 1;
1361 goto error;
1362 }
1363#endif
1364 u->rst.ptr -= 1;
1365 }
1366 break;
1367 case 0x5c: /* ANDr */
1368 __asm__( "evaluxn_5c_ANDr:" );
1369 {
1370 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1371 u->rst.dat[u->rst.ptr - 2] = b & a;
1372#ifndef NO_STACK_CHECKS
1373 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1374 u->rst.error = 1;
1375 goto error;
1376 }
1377#endif
1378 u->rst.ptr -= 1;
1379 }
1380 break;
1381 case 0x5d: /* ORAr */
1382 __asm__( "evaluxn_5d_ORAr:" );
1383 {
1384 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1385 u->rst.dat[u->rst.ptr - 2] = b | a;
1386#ifndef NO_STACK_CHECKS
1387 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1388 u->rst.error = 1;
1389 goto error;
1390 }
1391#endif
1392 u->rst.ptr -= 1;
1393 }
1394 break;
1395 case 0x5e: /* EORr */
1396 __asm__( "evaluxn_5e_EORr:" );
1397 {
1398 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1399 u->rst.dat[u->rst.ptr - 2] = b ^ a;
1400#ifndef NO_STACK_CHECKS
1401 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1402 u->rst.error = 1;
1403 goto error;
1404 }
1405#endif
1406 u->rst.ptr -= 1;
1407 }
1408 break;
1409 case 0x5f: /* SFTr */
1410 __asm__( "evaluxn_5f_SFTr:" );
1411 {
1412 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1413 u->rst.dat[u->rst.ptr - 2] = b >> (a & 0x07) << ((a & 0x70) >> 4);
1414#ifndef NO_STACK_CHECKS
1415 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1416 u->rst.error = 1;
1417 goto error;
1418 }
1419#endif
1420 u->rst.ptr -= 1;
1421 }
1422 break;
1423 case 0x61: /* LIT2r */
1424 case 0xe1: /* LIT2kr */
1425 __asm__( "evaluxn_61_LIT2r:" );
1426 {
1427 u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++);
1428 u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr++);
1429#ifndef NO_STACK_CHECKS
1430 if(__builtin_expect(u->rst.ptr > 253, 0)) {
1431 u->rst.error = 2;
1432 goto error;
1433 }
1434#endif
1435 u->rst.ptr += 2;
1436 }
1437 break;
1438 case 0x63: /* POP2r */
1439 __asm__( "evaluxn_63_POP2r:" );
1440 {
1441 (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
1442#ifndef NO_STACK_CHECKS
1443 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1444 u->rst.error = 1;
1445 goto error;
1446 }
1447#endif
1448 u->rst.ptr -= 2;
1449 }
1450 break;
1451 case 0x64: /* DUP2r */
1452 __asm__( "evaluxn_64_DUP2r:" );
1453 {
1454 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1455 u->rst.dat[u->rst.ptr] = b;
1456 u->rst.dat[u->rst.ptr + 1] = a;
1457#ifndef NO_STACK_CHECKS
1458 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1459 u->rst.error = 1;
1460 goto error;
1461 }
1462 if(__builtin_expect(u->rst.ptr > 253, 0)) {
1463 u->rst.error = 2;
1464 goto error;
1465 }
1466#endif
1467 u->rst.ptr += 2;
1468 }
1469 break;
1470 case 0x65: /* SWP2r */
1471 __asm__( "evaluxn_65_SWP2r:" );
1472 {
1473 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4];
1474 u->rst.dat[u->rst.ptr - 4] = b;
1475 u->rst.dat[u->rst.ptr - 3] = a;
1476 u->rst.dat[u->rst.ptr - 2] = d;
1477 u->rst.dat[u->rst.ptr - 1] = c;
1478#ifndef NO_STACK_CHECKS
1479 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1480 u->rst.error = 1;
1481 goto error;
1482 }
1483#endif
1484 }
1485 break;
1486 case 0x66: /* OVR2r */
1487 __asm__( "evaluxn_66_OVR2r:" );
1488 {
1489 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4];
1490 u->rst.dat[u->rst.ptr] = d;
1491 u->rst.dat[u->rst.ptr + 1] = c;
1492#ifndef NO_STACK_CHECKS
1493 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1494 u->rst.error = 1;
1495 goto error;
1496 }
1497 if(__builtin_expect(u->rst.ptr > 253, 0)) {
1498 u->rst.error = 2;
1499 goto error;
1500 }
1501#endif
1502 u->rst.ptr += 2;
1503 }
1504 break;
1505 case 0x67: /* ROT2r */
1506 __asm__( "evaluxn_67_ROT2r:" );
1507 {
1508 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4], e = u->rst.dat[u->rst.ptr - 5], f = u->rst.dat[u->rst.ptr - 6];
1509 u->rst.dat[u->rst.ptr - 6] = d;
1510 u->rst.dat[u->rst.ptr - 5] = c;
1511 u->rst.dat[u->rst.ptr - 4] = b;
1512 u->rst.dat[u->rst.ptr - 3] = a;
1513 u->rst.dat[u->rst.ptr - 2] = f;
1514 u->rst.dat[u->rst.ptr - 1] = e;
1515#ifndef NO_STACK_CHECKS
1516 if(__builtin_expect(u->rst.ptr < 6, 0)) {
1517 u->rst.error = 1;
1518 goto error;
1519 }
1520#endif
1521 }
1522 break;
1523 case 0x68: /* EQU2r */
1524 __asm__( "evaluxn_68_EQU2r:" );
1525 {
1526 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
1527 u->rst.dat[u->rst.ptr - 4] = b == a;
1528#ifndef NO_STACK_CHECKS
1529 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1530 u->rst.error = 1;
1531 goto error;
1532 }
1533#endif
1534 u->rst.ptr -= 3;
1535 }
1536 break;
1537 case 0x69: /* NEQ2r */
1538 __asm__( "evaluxn_69_NEQ2r:" );
1539 {
1540 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
1541 u->rst.dat[u->rst.ptr - 4] = b != a;
1542#ifndef NO_STACK_CHECKS
1543 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1544 u->rst.error = 1;
1545 goto error;
1546 }
1547#endif
1548 u->rst.ptr -= 3;
1549 }
1550 break;
1551 case 0x6a: /* GTH2r */
1552 __asm__( "evaluxn_6a_GTH2r:" );
1553 {
1554 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
1555 u->rst.dat[u->rst.ptr - 4] = b > a;
1556#ifndef NO_STACK_CHECKS
1557 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1558 u->rst.error = 1;
1559 goto error;
1560 }
1561#endif
1562 u->rst.ptr -= 3;
1563 }
1564 break;
1565 case 0x6b: /* LTH2r */
1566 __asm__( "evaluxn_6b_LTH2r:" );
1567 {
1568 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
1569 u->rst.dat[u->rst.ptr - 4] = b < a;
1570#ifndef NO_STACK_CHECKS
1571 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1572 u->rst.error = 1;
1573 goto error;
1574 }
1575#endif
1576 u->rst.ptr -= 3;
1577 }
1578 break;
1579 case 0x6c: /* JMP2r */
1580 __asm__( "evaluxn_6c_JMP2r:" );
1581 {
1582 u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
1583#ifndef NO_STACK_CHECKS
1584 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1585 u->rst.error = 1;
1586 goto error;
1587 }
1588#endif
1589 u->rst.ptr -= 2;
1590 }
1591 break;
1592 case 0x6d: /* JCN2r */
1593 __asm__( "evaluxn_6d_JCN2r:" );
1594 {
1595 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
1596 if(u->rst.dat[u->rst.ptr - 3]) u->ram.ptr = a;
1597#ifndef NO_STACK_CHECKS
1598 if(__builtin_expect(u->rst.ptr < 3, 0)) {
1599 u->rst.error = 1;
1600 goto error;
1601 }
1602#endif
1603 u->rst.ptr -= 3;
1604 }
1605 break;
1606 case 0x6e: /* JSR2r */
1607 __asm__( "evaluxn_6e_JSR2r:" );
1608 {
1609 u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8;
1610 u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff;
1611 u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
1612#ifndef NO_STACK_CHECKS
1613 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1614 u->rst.error = 1;
1615 goto error;
1616 }
1617#endif
1618 u->rst.ptr -= 2;
1619#ifndef NO_STACK_CHECKS
1620 if(__builtin_expect(u->wst.ptr > 253, 0)) {
1621 u->wst.error = 2;
1622 goto error;
1623 }
1624#endif
1625 u->wst.ptr += 2;
1626 }
1627 break;
1628 case 0x6f: /* STH2r */
1629 __asm__( "evaluxn_6f_STH2r:" );
1630 {
1631 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
1632 u->wst.dat[u->wst.ptr] = b;
1633 u->wst.dat[u->wst.ptr + 1] = a;
1634#ifndef NO_STACK_CHECKS
1635 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1636 u->rst.error = 1;
1637 goto error;
1638 }
1639#endif
1640 u->rst.ptr -= 2;
1641#ifndef NO_STACK_CHECKS
1642 if(__builtin_expect(u->wst.ptr > 253, 0)) {
1643 u->wst.error = 2;
1644 goto error;
1645 }
1646#endif
1647 u->wst.ptr += 2;
1648 }
1649 break;
1650 case 0x70: /* LDZ2r */
1651 __asm__( "evaluxn_70_LDZ2r:" );
1652 {
1653 u8 a = u->rst.dat[u->rst.ptr - 1];
1654 u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, a);
1655 u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a + 1);
1656#ifndef NO_STACK_CHECKS
1657 if(__builtin_expect(u->rst.ptr < 1, 0)) {
1658 u->rst.error = 1;
1659 goto error;
1660 }
1661 if(__builtin_expect(u->rst.ptr > 254, 0)) {
1662 u->rst.error = 2;
1663 goto error;
1664 }
1665#endif
1666 u->rst.ptr += 1;
1667 }
1668 break;
1669 case 0x71: /* STZ2r */
1670 __asm__( "evaluxn_71_STZ2r:" );
1671 {
1672 u8 a = u->rst.dat[u->rst.ptr - 1];
1673 u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
1674 mempoke16(u->ram.dat, a, b);
1675#ifndef NO_STACK_CHECKS
1676 if(__builtin_expect(u->rst.ptr < 3, 0)) {
1677 u->rst.error = 1;
1678 goto error;
1679 }
1680#endif
1681 u->rst.ptr -= 3;
1682 }
1683 break;
1684 case 0x72: /* LDR2r */
1685 __asm__( "evaluxn_72_LDR2r:" );
1686 {
1687 u8 a = u->rst.dat[u->rst.ptr - 1];
1688 u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a);
1689 u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1);
1690#ifndef NO_STACK_CHECKS
1691 if(__builtin_expect(u->rst.ptr < 1, 0)) {
1692 u->rst.error = 1;
1693 goto error;
1694 }
1695 if(__builtin_expect(u->rst.ptr > 254, 0)) {
1696 u->rst.error = 2;
1697 goto error;
1698 }
1699#endif
1700 u->rst.ptr += 1;
1701 }
1702 break;
1703 case 0x73: /* STR2r */
1704 __asm__( "evaluxn_73_STR2r:" );
1705 {
1706 u8 a = u->rst.dat[u->rst.ptr - 1];
1707 u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
1708 mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b);
1709#ifndef NO_STACK_CHECKS
1710 if(__builtin_expect(u->rst.ptr < 3, 0)) {
1711 u->rst.error = 1;
1712 goto error;
1713 }
1714#endif
1715 u->rst.ptr -= 3;
1716 }
1717 break;
1718 case 0x74: /* LDA2r */
1719 __asm__( "evaluxn_74_LDA2r:" );
1720 {
1721 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
1722 u->rst.dat[u->rst.ptr - 2] = mempeek8(u->ram.dat, a);
1723 u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, a + 1);
1724#ifndef NO_STACK_CHECKS
1725 if(__builtin_expect(u->rst.ptr < 2, 0)) {
1726 u->rst.error = 1;
1727 goto error;
1728 }
1729#endif
1730 }
1731 break;
1732 case 0x75: /* STA2r */
1733 __asm__( "evaluxn_75_STA2r:" );
1734 {
1735 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
1736 u16 b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
1737 mempoke16(u->ram.dat, a, b);
1738#ifndef NO_STACK_CHECKS
1739 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1740 u->rst.error = 1;
1741 goto error;
1742 }
1743#endif
1744 u->rst.ptr -= 4;
1745 }
1746 break;
1747 case 0x76: /* DEI2r */
1748 __asm__( "evaluxn_76_DEI2r:" );
1749 {
1750 u8 a = u->rst.dat[u->rst.ptr - 1];
1751 u->rst.dat[u->rst.ptr - 1] = devpeek8(&u->dev[a >> 4], a);
1752 u->rst.dat[u->rst.ptr] = devpeek8(&u->dev[a >> 4], a + 1);
1753#ifndef NO_STACK_CHECKS
1754 if(__builtin_expect(u->rst.ptr < 1, 0)) {
1755 u->rst.error = 1;
1756 goto error;
1757 }
1758 if(__builtin_expect(u->rst.ptr > 254, 0)) {
1759 u->rst.error = 2;
1760 goto error;
1761 }
1762#endif
1763 u->rst.ptr += 1;
1764 }
1765 break;
1766 case 0x77: /* DEO2r */
1767 __asm__( "evaluxn_77_DEO2r:" );
1768 {
1769 u8 a = u->rst.dat[u->rst.ptr - 1];
1770 u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
1771 devpoke16(&u->dev[a >> 4], a, b);
1772#ifndef NO_STACK_CHECKS
1773 if(__builtin_expect(u->rst.ptr < 3, 0)) {
1774 u->rst.error = 1;
1775 goto error;
1776 }
1777#endif
1778 u->rst.ptr -= 3;
1779 }
1780 break;
1781 case 0x78: /* ADD2r */
1782 __asm__( "evaluxn_78_ADD2r:" );
1783 {
1784 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
1785 u->rst.dat[u->rst.ptr - 4] = (b + a) >> 8;
1786 u->rst.dat[u->rst.ptr - 3] = (b + a) & 0xff;
1787#ifndef NO_STACK_CHECKS
1788 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1789 u->rst.error = 1;
1790 goto error;
1791 }
1792#endif
1793 u->rst.ptr -= 2;
1794 }
1795 break;
1796 case 0x79: /* SUB2r */
1797 __asm__( "evaluxn_79_SUB2r:" );
1798 {
1799 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
1800 u->rst.dat[u->rst.ptr - 4] = (b - a) >> 8;
1801 u->rst.dat[u->rst.ptr - 3] = (b - a) & 0xff;
1802#ifndef NO_STACK_CHECKS
1803 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1804 u->rst.error = 1;
1805 goto error;
1806 }
1807#endif
1808 u->rst.ptr -= 2;
1809 }
1810 break;
1811 case 0x7a: /* MUL2r */
1812 __asm__( "evaluxn_7a_MUL2r:" );
1813 {
1814 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
1815 u->rst.dat[u->rst.ptr - 4] = (b * a) >> 8;
1816 u->rst.dat[u->rst.ptr - 3] = (b * a) & 0xff;
1817#ifndef NO_STACK_CHECKS
1818 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1819 u->rst.error = 1;
1820 goto error;
1821 }
1822#endif
1823 u->rst.ptr -= 2;
1824 }
1825 break;
1826 case 0x7b: /* DIV2r */
1827 __asm__( "evaluxn_7b_DIV2r:" );
1828 {
1829 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
1830 u->rst.dat[u->rst.ptr - 4] = (b / a) >> 8;
1831 u->rst.dat[u->rst.ptr - 3] = (b / a) & 0xff;
1832#ifndef NO_STACK_CHECKS
1833 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1834 u->rst.error = 1;
1835 goto error;
1836 }
1837#endif
1838 u->rst.ptr -= 2;
1839 }
1840 break;
1841 case 0x7c: /* AND2r */
1842 __asm__( "evaluxn_7c_AND2r:" );
1843 {
1844 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4];
1845 u->rst.dat[u->rst.ptr - 4] = d & b;
1846 u->rst.dat[u->rst.ptr - 3] = c & a;
1847#ifndef NO_STACK_CHECKS
1848 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1849 u->rst.error = 1;
1850 goto error;
1851 }
1852#endif
1853 u->rst.ptr -= 2;
1854 }
1855 break;
1856 case 0x7d: /* ORA2r */
1857 __asm__( "evaluxn_7d_ORA2r:" );
1858 {
1859 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4];
1860 u->rst.dat[u->rst.ptr - 4] = d | b;
1861 u->rst.dat[u->rst.ptr - 3] = c | a;
1862#ifndef NO_STACK_CHECKS
1863 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1864 u->rst.error = 1;
1865 goto error;
1866 }
1867#endif
1868 u->rst.ptr -= 2;
1869 }
1870 break;
1871 case 0x7e: /* EOR2r */
1872 __asm__( "evaluxn_7e_EOR2r:" );
1873 {
1874 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4];
1875 u->rst.dat[u->rst.ptr - 4] = d ^ b;
1876 u->rst.dat[u->rst.ptr - 3] = c ^ a;
1877#ifndef NO_STACK_CHECKS
1878 if(__builtin_expect(u->rst.ptr < 4, 0)) {
1879 u->rst.error = 1;
1880 goto error;
1881 }
1882#endif
1883 u->rst.ptr -= 2;
1884 }
1885 break;
1886 case 0x7f: /* SFT2r */
1887 __asm__( "evaluxn_7f_SFT2r:" );
1888 {
1889 u8 a = u->rst.dat[u->rst.ptr - 1];
1890 u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
1891 u->rst.dat[u->rst.ptr - 3] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8;
1892 u->rst.dat[u->rst.ptr - 2] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff;
1893#ifndef NO_STACK_CHECKS
1894 if(__builtin_expect(u->rst.ptr < 3, 0)) {
1895 u->rst.error = 1;
1896 goto error;
1897 }
1898#endif
1899 u->rst.ptr -= 1;
1900 }
1901 break;
1902 case 0x83: /* POPk */
1903 __asm__( "evaluxn_83_POPk:" );
1904 {
1905 u->wst.dat[u->wst.ptr - 1];
1906#ifndef NO_STACK_CHECKS
1907 if(__builtin_expect(u->wst.ptr < 1, 0)) {
1908 u->wst.error = 1;
1909 goto error;
1910 }
1911#endif
1912 }
1913 break;
1914 case 0x84: /* DUPk */
1915 __asm__( "evaluxn_84_DUPk:" );
1916 {
1917 u8 a = u->wst.dat[u->wst.ptr - 1];
1918 u->wst.dat[u->wst.ptr] = a;
1919 u->wst.dat[u->wst.ptr + 1] = a;
1920#ifndef NO_STACK_CHECKS
1921 if(__builtin_expect(u->wst.ptr < 1, 0)) {
1922 u->wst.error = 1;
1923 goto error;
1924 }
1925 if(__builtin_expect(u->wst.ptr > 253, 0)) {
1926 u->wst.error = 2;
1927 goto error;
1928 }
1929#endif
1930 u->wst.ptr += 2;
1931 }
1932 break;
1933 case 0x85: /* SWPk */
1934 __asm__( "evaluxn_85_SWPk:" );
1935 {
1936 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
1937 u->wst.dat[u->wst.ptr] = a;
1938 u->wst.dat[u->wst.ptr + 1] = b;
1939#ifndef NO_STACK_CHECKS
1940 if(__builtin_expect(u->wst.ptr < 2, 0)) {
1941 u->wst.error = 1;
1942 goto error;
1943 }
1944 if(__builtin_expect(u->wst.ptr > 253, 0)) {
1945 u->wst.error = 2;
1946 goto error;
1947 }
1948#endif
1949 u->wst.ptr += 2;
1950 }
1951 break;
1952 case 0x86: /* OVRk */
1953 __asm__( "evaluxn_86_OVRk:" );
1954 {
1955 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
1956 u->wst.dat[u->wst.ptr] = b;
1957 u->wst.dat[u->wst.ptr + 1] = a;
1958 u->wst.dat[u->wst.ptr + 2] = b;
1959#ifndef NO_STACK_CHECKS
1960 if(__builtin_expect(u->wst.ptr < 2, 0)) {
1961 u->wst.error = 1;
1962 goto error;
1963 }
1964 if(__builtin_expect(u->wst.ptr > 252, 0)) {
1965 u->wst.error = 2;
1966 goto error;
1967 }
1968#endif
1969 u->wst.ptr += 3;
1970 }
1971 break;
1972 case 0x87: /* ROTk */
1973 __asm__( "evaluxn_87_ROTk:" );
1974 {
1975 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3];
1976 u->wst.dat[u->wst.ptr] = b;
1977 u->wst.dat[u->wst.ptr + 1] = a;
1978 u->wst.dat[u->wst.ptr + 2] = c;
1979#ifndef NO_STACK_CHECKS
1980 if(__builtin_expect(u->wst.ptr < 3, 0)) {
1981 u->wst.error = 1;
1982 goto error;
1983 }
1984 if(__builtin_expect(u->wst.ptr > 252, 0)) {
1985 u->wst.error = 2;
1986 goto error;
1987 }
1988#endif
1989 u->wst.ptr += 3;
1990 }
1991 break;
1992 case 0x88: /* EQUk */
1993 __asm__( "evaluxn_88_EQUk:" );
1994 {
1995 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
1996 u->wst.dat[u->wst.ptr] = b == a;
1997#ifndef NO_STACK_CHECKS
1998 if(__builtin_expect(u->wst.ptr < 2, 0)) {
1999 u->wst.error = 1;
2000 goto error;
2001 }
2002 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2003 u->wst.error = 2;
2004 goto error;
2005 }
2006#endif
2007 u->wst.ptr += 1;
2008 }
2009 break;
2010 case 0x89: /* NEQk */
2011 __asm__( "evaluxn_89_NEQk:" );
2012 {
2013 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2014 u->wst.dat[u->wst.ptr] = b != a;
2015#ifndef NO_STACK_CHECKS
2016 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2017 u->wst.error = 1;
2018 goto error;
2019 }
2020 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2021 u->wst.error = 2;
2022 goto error;
2023 }
2024#endif
2025 u->wst.ptr += 1;
2026 }
2027 break;
2028 case 0x8a: /* GTHk */
2029 __asm__( "evaluxn_8a_GTHk:" );
2030 {
2031 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2032 u->wst.dat[u->wst.ptr] = b > a;
2033#ifndef NO_STACK_CHECKS
2034 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2035 u->wst.error = 1;
2036 goto error;
2037 }
2038 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2039 u->wst.error = 2;
2040 goto error;
2041 }
2042#endif
2043 u->wst.ptr += 1;
2044 }
2045 break;
2046 case 0x8b: /* LTHk */
2047 __asm__( "evaluxn_8b_LTHk:" );
2048 {
2049 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2050 u->wst.dat[u->wst.ptr] = b < a;
2051#ifndef NO_STACK_CHECKS
2052 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2053 u->wst.error = 1;
2054 goto error;
2055 }
2056 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2057 u->wst.error = 2;
2058 goto error;
2059 }
2060#endif
2061 u->wst.ptr += 1;
2062 }
2063 break;
2064 case 0x8c: /* JMPk */
2065 __asm__( "evaluxn_8c_JMPk:" );
2066 {
2067 u8 a = u->wst.dat[u->wst.ptr - 1];
2068 u->ram.ptr += (s8)a;
2069#ifndef NO_STACK_CHECKS
2070 if(__builtin_expect(u->wst.ptr < 1, 0)) {
2071 u->wst.error = 1;
2072 goto error;
2073 }
2074#endif
2075 }
2076 break;
2077 case 0x8d: /* JCNk */
2078 __asm__( "evaluxn_8d_JCNk:" );
2079 {
2080 u8 a = u->wst.dat[u->wst.ptr - 1];
2081 if(u->wst.dat[u->wst.ptr - 2]) u->ram.ptr += (s8)a;
2082#ifndef NO_STACK_CHECKS
2083 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2084 u->wst.error = 1;
2085 goto error;
2086 }
2087#endif
2088 }
2089 break;
2090 case 0x8e: /* JSRk */
2091 __asm__( "evaluxn_8e_JSRk:" );
2092 {
2093 u8 a = u->wst.dat[u->wst.ptr - 1];
2094 u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8;
2095 u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff;
2096 u->ram.ptr += (s8)a;
2097#ifndef NO_STACK_CHECKS
2098 if(__builtin_expect(u->wst.ptr < 1, 0)) {
2099 u->wst.error = 1;
2100 goto error;
2101 }
2102 if(__builtin_expect(u->rst.ptr > 253, 0)) {
2103 u->rst.error = 2;
2104 goto error;
2105 }
2106#endif
2107 u->rst.ptr += 2;
2108 }
2109 break;
2110 case 0x8f: /* STHk */
2111 __asm__( "evaluxn_8f_STHk:" );
2112 {
2113 u8 a = u->wst.dat[u->wst.ptr - 1];
2114 u->rst.dat[u->rst.ptr] = a;
2115#ifndef NO_STACK_CHECKS
2116 if(__builtin_expect(u->wst.ptr < 1, 0)) {
2117 u->wst.error = 1;
2118 goto error;
2119 }
2120 if(__builtin_expect(u->rst.ptr > 254, 0)) {
2121 u->rst.error = 2;
2122 goto error;
2123 }
2124#endif
2125 u->rst.ptr += 1;
2126 }
2127 break;
2128 case 0x90: /* LDZk */
2129 __asm__( "evaluxn_90_LDZk:" );
2130 {
2131 u8 a = u->wst.dat[u->wst.ptr - 1];
2132 u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a);
2133#ifndef NO_STACK_CHECKS
2134 if(__builtin_expect(u->wst.ptr < 1, 0)) {
2135 u->wst.error = 1;
2136 goto error;
2137 }
2138 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2139 u->wst.error = 2;
2140 goto error;
2141 }
2142#endif
2143 u->wst.ptr += 1;
2144 }
2145 break;
2146 case 0x91: /* STZk */
2147 __asm__( "evaluxn_91_STZk:" );
2148 {
2149 u8 a = u->wst.dat[u->wst.ptr - 1];
2150 u8 b = u->wst.dat[u->wst.ptr - 2];
2151 mempoke8(u->ram.dat, a, b);
2152#ifndef NO_STACK_CHECKS
2153 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2154 u->wst.error = 1;
2155 goto error;
2156 }
2157#endif
2158 }
2159 break;
2160 case 0x92: /* LDRk */
2161 __asm__( "evaluxn_92_LDRk:" );
2162 {
2163 u8 a = u->wst.dat[u->wst.ptr - 1];
2164 u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a);
2165#ifndef NO_STACK_CHECKS
2166 if(__builtin_expect(u->wst.ptr < 1, 0)) {
2167 u->wst.error = 1;
2168 goto error;
2169 }
2170 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2171 u->wst.error = 2;
2172 goto error;
2173 }
2174#endif
2175 u->wst.ptr += 1;
2176 }
2177 break;
2178 case 0x93: /* STRk */
2179 __asm__( "evaluxn_93_STRk:" );
2180 {
2181 u8 a = u->wst.dat[u->wst.ptr - 1];
2182 u8 b = u->wst.dat[u->wst.ptr - 2];
2183 mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b);
2184#ifndef NO_STACK_CHECKS
2185 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2186 u->wst.error = 1;
2187 goto error;
2188 }
2189#endif
2190 }
2191 break;
2192 case 0x94: /* LDAk */
2193 __asm__( "evaluxn_94_LDAk:" );
2194 {
2195 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
2196 u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a);
2197#ifndef NO_STACK_CHECKS
2198 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2199 u->wst.error = 1;
2200 goto error;
2201 }
2202 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2203 u->wst.error = 2;
2204 goto error;
2205 }
2206#endif
2207 u->wst.ptr += 1;
2208 }
2209 break;
2210 case 0x95: /* STAk */
2211 __asm__( "evaluxn_95_STAk:" );
2212 {
2213 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
2214 u8 b = u->wst.dat[u->wst.ptr - 3];
2215 mempoke8(u->ram.dat, a, b);
2216#ifndef NO_STACK_CHECKS
2217 if(__builtin_expect(u->wst.ptr < 3, 0)) {
2218 u->wst.error = 1;
2219 goto error;
2220 }
2221#endif
2222 }
2223 break;
2224 case 0x96: /* DEIk */
2225 __asm__( "evaluxn_96_DEIk:" );
2226 {
2227 u8 a = u->wst.dat[u->wst.ptr - 1];
2228 u->wst.dat[u->wst.ptr] = devpeek8(&u->dev[a >> 4], a);
2229#ifndef NO_STACK_CHECKS
2230 if(__builtin_expect(u->wst.ptr < 1, 0)) {
2231 u->wst.error = 1;
2232 goto error;
2233 }
2234 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2235 u->wst.error = 2;
2236 goto error;
2237 }
2238#endif
2239 u->wst.ptr += 1;
2240 }
2241 break;
2242 case 0x97: /* DEOk */
2243 __asm__( "evaluxn_97_DEOk:" );
2244 {
2245 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2246 devpoke8(&u->dev[a >> 4], a, b);
2247#ifndef NO_STACK_CHECKS
2248 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2249 u->wst.error = 1;
2250 goto error;
2251 }
2252#endif
2253 }
2254 break;
2255 case 0x98: /* ADDk */
2256 __asm__( "evaluxn_98_ADDk:" );
2257 {
2258 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2259 u->wst.dat[u->wst.ptr] = b + a;
2260#ifndef NO_STACK_CHECKS
2261 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2262 u->wst.error = 1;
2263 goto error;
2264 }
2265 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2266 u->wst.error = 2;
2267 goto error;
2268 }
2269#endif
2270 u->wst.ptr += 1;
2271 }
2272 break;
2273 case 0x99: /* SUBk */
2274 __asm__( "evaluxn_99_SUBk:" );
2275 {
2276 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2277 u->wst.dat[u->wst.ptr] = b - a;
2278#ifndef NO_STACK_CHECKS
2279 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2280 u->wst.error = 1;
2281 goto error;
2282 }
2283 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2284 u->wst.error = 2;
2285 goto error;
2286 }
2287#endif
2288 u->wst.ptr += 1;
2289 }
2290 break;
2291 case 0x9a: /* MULk */
2292 __asm__( "evaluxn_9a_MULk:" );
2293 {
2294 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2295 u->wst.dat[u->wst.ptr] = b * a;
2296#ifndef NO_STACK_CHECKS
2297 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2298 u->wst.error = 1;
2299 goto error;
2300 }
2301 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2302 u->wst.error = 2;
2303 goto error;
2304 }
2305#endif
2306 u->wst.ptr += 1;
2307 }
2308 break;
2309 case 0x9b: /* DIVk */
2310 __asm__( "evaluxn_9b_DIVk:" );
2311 {
2312 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2313 u->wst.dat[u->wst.ptr] = b / a;
2314#ifndef NO_STACK_CHECKS
2315 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2316 u->wst.error = 1;
2317 goto error;
2318 }
2319 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2320 u->wst.error = 2;
2321 goto error;
2322 }
2323#endif
2324 u->wst.ptr += 1;
2325 }
2326 break;
2327 case 0x9c: /* ANDk */
2328 __asm__( "evaluxn_9c_ANDk:" );
2329 {
2330 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2331 u->wst.dat[u->wst.ptr] = b & a;
2332#ifndef NO_STACK_CHECKS
2333 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2334 u->wst.error = 1;
2335 goto error;
2336 }
2337 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2338 u->wst.error = 2;
2339 goto error;
2340 }
2341#endif
2342 u->wst.ptr += 1;
2343 }
2344 break;
2345 case 0x9d: /* ORAk */
2346 __asm__( "evaluxn_9d_ORAk:" );
2347 {
2348 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2349 u->wst.dat[u->wst.ptr] = b | a;
2350#ifndef NO_STACK_CHECKS
2351 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2352 u->wst.error = 1;
2353 goto error;
2354 }
2355 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2356 u->wst.error = 2;
2357 goto error;
2358 }
2359#endif
2360 u->wst.ptr += 1;
2361 }
2362 break;
2363 case 0x9e: /* EORk */
2364 __asm__( "evaluxn_9e_EORk:" );
2365 {
2366 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2367 u->wst.dat[u->wst.ptr] = b ^ a;
2368#ifndef NO_STACK_CHECKS
2369 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2370 u->wst.error = 1;
2371 goto error;
2372 }
2373 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2374 u->wst.error = 2;
2375 goto error;
2376 }
2377#endif
2378 u->wst.ptr += 1;
2379 }
2380 break;
2381 case 0x9f: /* SFTk */
2382 __asm__( "evaluxn_9f_SFTk:" );
2383 {
2384 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2385 u->wst.dat[u->wst.ptr] = b >> (a & 0x07) << ((a & 0x70) >> 4);
2386#ifndef NO_STACK_CHECKS
2387 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2388 u->wst.error = 1;
2389 goto error;
2390 }
2391 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2392 u->wst.error = 2;
2393 goto error;
2394 }
2395#endif
2396 u->wst.ptr += 1;
2397 }
2398 break;
2399 case 0xa3: /* POP2k */
2400 __asm__( "evaluxn_a3_POP2k:" );
2401 {
2402 (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
2403#ifndef NO_STACK_CHECKS
2404 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2405 u->wst.error = 1;
2406 goto error;
2407 }
2408#endif
2409 }
2410 break;
2411 case 0xa4: /* DUP2k */
2412 __asm__( "evaluxn_a4_DUP2k:" );
2413 {
2414 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2415 u->wst.dat[u->wst.ptr] = b;
2416 u->wst.dat[u->wst.ptr + 1] = a;
2417 u->wst.dat[u->wst.ptr + 2] = b;
2418 u->wst.dat[u->wst.ptr + 3] = a;
2419#ifndef NO_STACK_CHECKS
2420 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2421 u->wst.error = 1;
2422 goto error;
2423 }
2424 if(__builtin_expect(u->wst.ptr > 251, 0)) {
2425 u->wst.error = 2;
2426 goto error;
2427 }
2428#endif
2429 u->wst.ptr += 4;
2430 }
2431 break;
2432 case 0xa5: /* SWP2k */
2433 __asm__( "evaluxn_a5_SWP2k:" );
2434 {
2435 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
2436 u->wst.dat[u->wst.ptr] = b;
2437 u->wst.dat[u->wst.ptr + 1] = a;
2438 u->wst.dat[u->wst.ptr + 2] = d;
2439 u->wst.dat[u->wst.ptr + 3] = c;
2440#ifndef NO_STACK_CHECKS
2441 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2442 u->wst.error = 1;
2443 goto error;
2444 }
2445 if(__builtin_expect(u->wst.ptr > 251, 0)) {
2446 u->wst.error = 2;
2447 goto error;
2448 }
2449#endif
2450 u->wst.ptr += 4;
2451 }
2452 break;
2453 case 0xa6: /* OVR2k */
2454 __asm__( "evaluxn_a6_OVR2k:" );
2455 {
2456 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
2457 u->wst.dat[u->wst.ptr] = d;
2458 u->wst.dat[u->wst.ptr + 1] = c;
2459 u->wst.dat[u->wst.ptr + 2] = b;
2460 u->wst.dat[u->wst.ptr + 3] = a;
2461 u->wst.dat[u->wst.ptr + 4] = d;
2462 u->wst.dat[u->wst.ptr + 5] = c;
2463#ifndef NO_STACK_CHECKS
2464 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2465 u->wst.error = 1;
2466 goto error;
2467 }
2468 if(__builtin_expect(u->wst.ptr > 249, 0)) {
2469 u->wst.error = 2;
2470 goto error;
2471 }
2472#endif
2473 u->wst.ptr += 6;
2474 }
2475 break;
2476 case 0xa7: /* ROT2k */
2477 __asm__( "evaluxn_a7_ROT2k:" );
2478 {
2479 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4], e = u->wst.dat[u->wst.ptr - 5], f = u->wst.dat[u->wst.ptr - 6];
2480 u->wst.dat[u->wst.ptr] = d;
2481 u->wst.dat[u->wst.ptr + 1] = c;
2482 u->wst.dat[u->wst.ptr + 2] = b;
2483 u->wst.dat[u->wst.ptr + 3] = a;
2484 u->wst.dat[u->wst.ptr + 4] = f;
2485 u->wst.dat[u->wst.ptr + 5] = e;
2486#ifndef NO_STACK_CHECKS
2487 if(__builtin_expect(u->wst.ptr < 6, 0)) {
2488 u->wst.error = 1;
2489 goto error;
2490 }
2491 if(__builtin_expect(u->wst.ptr > 249, 0)) {
2492 u->wst.error = 2;
2493 goto error;
2494 }
2495#endif
2496 u->wst.ptr += 6;
2497 }
2498 break;
2499 case 0xa8: /* EQU2k */
2500 __asm__( "evaluxn_a8_EQU2k:" );
2501 {
2502 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
2503 u->wst.dat[u->wst.ptr] = b == a;
2504#ifndef NO_STACK_CHECKS
2505 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2506 u->wst.error = 1;
2507 goto error;
2508 }
2509 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2510 u->wst.error = 2;
2511 goto error;
2512 }
2513#endif
2514 u->wst.ptr += 1;
2515 }
2516 break;
2517 case 0xa9: /* NEQ2k */
2518 __asm__( "evaluxn_a9_NEQ2k:" );
2519 {
2520 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
2521 u->wst.dat[u->wst.ptr] = b != a;
2522#ifndef NO_STACK_CHECKS
2523 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2524 u->wst.error = 1;
2525 goto error;
2526 }
2527 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2528 u->wst.error = 2;
2529 goto error;
2530 }
2531#endif
2532 u->wst.ptr += 1;
2533 }
2534 break;
2535 case 0xaa: /* GTH2k */
2536 __asm__( "evaluxn_aa_GTH2k:" );
2537 {
2538 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
2539 u->wst.dat[u->wst.ptr] = b > a;
2540#ifndef NO_STACK_CHECKS
2541 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2542 u->wst.error = 1;
2543 goto error;
2544 }
2545 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2546 u->wst.error = 2;
2547 goto error;
2548 }
2549#endif
2550 u->wst.ptr += 1;
2551 }
2552 break;
2553 case 0xab: /* LTH2k */
2554 __asm__( "evaluxn_ab_LTH2k:" );
2555 {
2556 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
2557 u->wst.dat[u->wst.ptr] = b < a;
2558#ifndef NO_STACK_CHECKS
2559 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2560 u->wst.error = 1;
2561 goto error;
2562 }
2563 if(__builtin_expect(u->wst.ptr > 254, 0)) {
2564 u->wst.error = 2;
2565 goto error;
2566 }
2567#endif
2568 u->wst.ptr += 1;
2569 }
2570 break;
2571 case 0xac: /* JMP2k */
2572 __asm__( "evaluxn_ac_JMP2k:" );
2573 {
2574 u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
2575#ifndef NO_STACK_CHECKS
2576 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2577 u->wst.error = 1;
2578 goto error;
2579 }
2580#endif
2581 }
2582 break;
2583 case 0xad: /* JCN2k */
2584 __asm__( "evaluxn_ad_JCN2k:" );
2585 {
2586 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
2587 if(u->wst.dat[u->wst.ptr - 3]) u->ram.ptr = a;
2588#ifndef NO_STACK_CHECKS
2589 if(__builtin_expect(u->wst.ptr < 3, 0)) {
2590 u->wst.error = 1;
2591 goto error;
2592 }
2593#endif
2594 }
2595 break;
2596 case 0xae: /* JSR2k */
2597 __asm__( "evaluxn_ae_JSR2k:" );
2598 {
2599 u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8;
2600 u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff;
2601 u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
2602#ifndef NO_STACK_CHECKS
2603 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2604 u->wst.error = 1;
2605 goto error;
2606 }
2607 if(__builtin_expect(u->rst.ptr > 253, 0)) {
2608 u->rst.error = 2;
2609 goto error;
2610 }
2611#endif
2612 u->rst.ptr += 2;
2613 }
2614 break;
2615 case 0xaf: /* STH2k */
2616 __asm__( "evaluxn_af_STH2k:" );
2617 {
2618 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2];
2619 u->rst.dat[u->rst.ptr] = b;
2620 u->rst.dat[u->rst.ptr + 1] = a;
2621#ifndef NO_STACK_CHECKS
2622 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2623 u->wst.error = 1;
2624 goto error;
2625 }
2626 if(__builtin_expect(u->rst.ptr > 253, 0)) {
2627 u->rst.error = 2;
2628 goto error;
2629 }
2630#endif
2631 u->rst.ptr += 2;
2632 }
2633 break;
2634 case 0xb0: /* LDZ2k */
2635 __asm__( "evaluxn_b0_LDZ2k:" );
2636 {
2637 u8 a = u->wst.dat[u->wst.ptr - 1];
2638 u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a);
2639 u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, a + 1);
2640#ifndef NO_STACK_CHECKS
2641 if(__builtin_expect(u->wst.ptr < 1, 0)) {
2642 u->wst.error = 1;
2643 goto error;
2644 }
2645 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2646 u->wst.error = 2;
2647 goto error;
2648 }
2649#endif
2650 u->wst.ptr += 2;
2651 }
2652 break;
2653 case 0xb1: /* STZ2k */
2654 __asm__( "evaluxn_b1_STZ2k:" );
2655 {
2656 u8 a = u->wst.dat[u->wst.ptr - 1];
2657 u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
2658 mempoke16(u->ram.dat, a, b);
2659#ifndef NO_STACK_CHECKS
2660 if(__builtin_expect(u->wst.ptr < 3, 0)) {
2661 u->wst.error = 1;
2662 goto error;
2663 }
2664#endif
2665 }
2666 break;
2667 case 0xb2: /* LDR2k */
2668 __asm__( "evaluxn_b2_LDR2k:" );
2669 {
2670 u8 a = u->wst.dat[u->wst.ptr - 1];
2671 u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a);
2672 u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1);
2673#ifndef NO_STACK_CHECKS
2674 if(__builtin_expect(u->wst.ptr < 1, 0)) {
2675 u->wst.error = 1;
2676 goto error;
2677 }
2678 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2679 u->wst.error = 2;
2680 goto error;
2681 }
2682#endif
2683 u->wst.ptr += 2;
2684 }
2685 break;
2686 case 0xb3: /* STR2k */
2687 __asm__( "evaluxn_b3_STR2k:" );
2688 {
2689 u8 a = u->wst.dat[u->wst.ptr - 1];
2690 u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
2691 mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b);
2692#ifndef NO_STACK_CHECKS
2693 if(__builtin_expect(u->wst.ptr < 3, 0)) {
2694 u->wst.error = 1;
2695 goto error;
2696 }
2697#endif
2698 }
2699 break;
2700 case 0xb4: /* LDA2k */
2701 __asm__( "evaluxn_b4_LDA2k:" );
2702 {
2703 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
2704 u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a);
2705 u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, a + 1);
2706#ifndef NO_STACK_CHECKS
2707 if(__builtin_expect(u->wst.ptr < 2, 0)) {
2708 u->wst.error = 1;
2709 goto error;
2710 }
2711 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2712 u->wst.error = 2;
2713 goto error;
2714 }
2715#endif
2716 u->wst.ptr += 2;
2717 }
2718 break;
2719 case 0xb5: /* STA2k */
2720 __asm__( "evaluxn_b5_STA2k:" );
2721 {
2722 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8));
2723 u16 b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
2724 mempoke16(u->ram.dat, a, b);
2725#ifndef NO_STACK_CHECKS
2726 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2727 u->wst.error = 1;
2728 goto error;
2729 }
2730#endif
2731 }
2732 break;
2733 case 0xb6: /* DEI2k */
2734 __asm__( "evaluxn_b6_DEI2k:" );
2735 {
2736 u8 a = u->wst.dat[u->wst.ptr - 1];
2737 u->wst.dat[u->wst.ptr] = devpeek8(&u->dev[a >> 4], a);
2738 u->wst.dat[u->wst.ptr + 1] = devpeek8(&u->dev[a >> 4], a + 1);
2739#ifndef NO_STACK_CHECKS
2740 if(__builtin_expect(u->wst.ptr < 1, 0)) {
2741 u->wst.error = 1;
2742 goto error;
2743 }
2744 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2745 u->wst.error = 2;
2746 goto error;
2747 }
2748#endif
2749 u->wst.ptr += 2;
2750 }
2751 break;
2752 case 0xb7: /* DEO2k */
2753 __asm__( "evaluxn_b7_DEO2k:" );
2754 {
2755 u8 a = u->wst.dat[u->wst.ptr - 1];
2756 u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
2757 devpoke16(&u->dev[a >> 4], a, b);
2758#ifndef NO_STACK_CHECKS
2759 if(__builtin_expect(u->wst.ptr < 3, 0)) {
2760 u->wst.error = 1;
2761 goto error;
2762 }
2763#endif
2764 }
2765 break;
2766 case 0xb8: /* ADD2k */
2767 __asm__( "evaluxn_b8_ADD2k:" );
2768 {
2769 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
2770 u->wst.dat[u->wst.ptr] = (b + a) >> 8;
2771 u->wst.dat[u->wst.ptr + 1] = (b + a) & 0xff;
2772#ifndef NO_STACK_CHECKS
2773 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2774 u->wst.error = 1;
2775 goto error;
2776 }
2777 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2778 u->wst.error = 2;
2779 goto error;
2780 }
2781#endif
2782 u->wst.ptr += 2;
2783 }
2784 break;
2785 case 0xb9: /* SUB2k */
2786 __asm__( "evaluxn_b9_SUB2k:" );
2787 {
2788 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
2789 u->wst.dat[u->wst.ptr] = (b - a) >> 8;
2790 u->wst.dat[u->wst.ptr + 1] = (b - a) & 0xff;
2791#ifndef NO_STACK_CHECKS
2792 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2793 u->wst.error = 1;
2794 goto error;
2795 }
2796 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2797 u->wst.error = 2;
2798 goto error;
2799 }
2800#endif
2801 u->wst.ptr += 2;
2802 }
2803 break;
2804 case 0xba: /* MUL2k */
2805 __asm__( "evaluxn_ba_MUL2k:" );
2806 {
2807 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
2808 u->wst.dat[u->wst.ptr] = (b * a) >> 8;
2809 u->wst.dat[u->wst.ptr + 1] = (b * a) & 0xff;
2810#ifndef NO_STACK_CHECKS
2811 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2812 u->wst.error = 1;
2813 goto error;
2814 }
2815 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2816 u->wst.error = 2;
2817 goto error;
2818 }
2819#endif
2820 u->wst.ptr += 2;
2821 }
2822 break;
2823 case 0xbb: /* DIV2k */
2824 __asm__( "evaluxn_bb_DIV2k:" );
2825 {
2826 u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)), b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8));
2827 u->wst.dat[u->wst.ptr] = (b / a) >> 8;
2828 u->wst.dat[u->wst.ptr + 1] = (b / a) & 0xff;
2829#ifndef NO_STACK_CHECKS
2830 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2831 u->wst.error = 1;
2832 goto error;
2833 }
2834 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2835 u->wst.error = 2;
2836 goto error;
2837 }
2838#endif
2839 u->wst.ptr += 2;
2840 }
2841 break;
2842 case 0xbc: /* AND2k */
2843 __asm__( "evaluxn_bc_AND2k:" );
2844 {
2845 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
2846 u->wst.dat[u->wst.ptr] = d & b;
2847 u->wst.dat[u->wst.ptr + 1] = c & a;
2848#ifndef NO_STACK_CHECKS
2849 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2850 u->wst.error = 1;
2851 goto error;
2852 }
2853 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2854 u->wst.error = 2;
2855 goto error;
2856 }
2857#endif
2858 u->wst.ptr += 2;
2859 }
2860 break;
2861 case 0xbd: /* ORA2k */
2862 __asm__( "evaluxn_bd_ORA2k:" );
2863 {
2864 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
2865 u->wst.dat[u->wst.ptr] = d | b;
2866 u->wst.dat[u->wst.ptr + 1] = c | a;
2867#ifndef NO_STACK_CHECKS
2868 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2869 u->wst.error = 1;
2870 goto error;
2871 }
2872 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2873 u->wst.error = 2;
2874 goto error;
2875 }
2876#endif
2877 u->wst.ptr += 2;
2878 }
2879 break;
2880 case 0xbe: /* EOR2k */
2881 __asm__( "evaluxn_be_EOR2k:" );
2882 {
2883 u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2], c = u->wst.dat[u->wst.ptr - 3], d = u->wst.dat[u->wst.ptr - 4];
2884 u->wst.dat[u->wst.ptr] = d ^ b;
2885 u->wst.dat[u->wst.ptr + 1] = c ^ a;
2886#ifndef NO_STACK_CHECKS
2887 if(__builtin_expect(u->wst.ptr < 4, 0)) {
2888 u->wst.error = 1;
2889 goto error;
2890 }
2891 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2892 u->wst.error = 2;
2893 goto error;
2894 }
2895#endif
2896 u->wst.ptr += 2;
2897 }
2898 break;
2899 case 0xbf: /* SFT2k */
2900 __asm__( "evaluxn_bf_SFT2k:" );
2901 {
2902 u8 a = u->wst.dat[u->wst.ptr - 1];
2903 u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8));
2904 u->wst.dat[u->wst.ptr] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8;
2905 u->wst.dat[u->wst.ptr + 1] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff;
2906#ifndef NO_STACK_CHECKS
2907 if(__builtin_expect(u->wst.ptr < 3, 0)) {
2908 u->wst.error = 1;
2909 goto error;
2910 }
2911 if(__builtin_expect(u->wst.ptr > 253, 0)) {
2912 u->wst.error = 2;
2913 goto error;
2914 }
2915#endif
2916 u->wst.ptr += 2;
2917 }
2918 break;
2919 case 0xc3: /* POPkr */
2920 __asm__( "evaluxn_c3_POPkr:" );
2921 {
2922 u->rst.dat[u->rst.ptr - 1];
2923#ifndef NO_STACK_CHECKS
2924 if(__builtin_expect(u->rst.ptr < 1, 0)) {
2925 u->rst.error = 1;
2926 goto error;
2927 }
2928#endif
2929 }
2930 break;
2931 case 0xc4: /* DUPkr */
2932 __asm__( "evaluxn_c4_DUPkr:" );
2933 {
2934 u8 a = u->rst.dat[u->rst.ptr - 1];
2935 u->rst.dat[u->rst.ptr] = a;
2936 u->rst.dat[u->rst.ptr + 1] = a;
2937#ifndef NO_STACK_CHECKS
2938 if(__builtin_expect(u->rst.ptr < 1, 0)) {
2939 u->rst.error = 1;
2940 goto error;
2941 }
2942 if(__builtin_expect(u->rst.ptr > 253, 0)) {
2943 u->rst.error = 2;
2944 goto error;
2945 }
2946#endif
2947 u->rst.ptr += 2;
2948 }
2949 break;
2950 case 0xc5: /* SWPkr */
2951 __asm__( "evaluxn_c5_SWPkr:" );
2952 {
2953 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
2954 u->rst.dat[u->rst.ptr] = a;
2955 u->rst.dat[u->rst.ptr + 1] = b;
2956#ifndef NO_STACK_CHECKS
2957 if(__builtin_expect(u->rst.ptr < 2, 0)) {
2958 u->rst.error = 1;
2959 goto error;
2960 }
2961 if(__builtin_expect(u->rst.ptr > 253, 0)) {
2962 u->rst.error = 2;
2963 goto error;
2964 }
2965#endif
2966 u->rst.ptr += 2;
2967 }
2968 break;
2969 case 0xc6: /* OVRkr */
2970 __asm__( "evaluxn_c6_OVRkr:" );
2971 {
2972 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
2973 u->rst.dat[u->rst.ptr] = b;
2974 u->rst.dat[u->rst.ptr + 1] = a;
2975 u->rst.dat[u->rst.ptr + 2] = b;
2976#ifndef NO_STACK_CHECKS
2977 if(__builtin_expect(u->rst.ptr < 2, 0)) {
2978 u->rst.error = 1;
2979 goto error;
2980 }
2981 if(__builtin_expect(u->rst.ptr > 252, 0)) {
2982 u->rst.error = 2;
2983 goto error;
2984 }
2985#endif
2986 u->rst.ptr += 3;
2987 }
2988 break;
2989 case 0xc7: /* ROTkr */
2990 __asm__( "evaluxn_c7_ROTkr:" );
2991 {
2992 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3];
2993 u->rst.dat[u->rst.ptr] = b;
2994 u->rst.dat[u->rst.ptr + 1] = a;
2995 u->rst.dat[u->rst.ptr + 2] = c;
2996#ifndef NO_STACK_CHECKS
2997 if(__builtin_expect(u->rst.ptr < 3, 0)) {
2998 u->rst.error = 1;
2999 goto error;
3000 }
3001 if(__builtin_expect(u->rst.ptr > 252, 0)) {
3002 u->rst.error = 2;
3003 goto error;
3004 }
3005#endif
3006 u->rst.ptr += 3;
3007 }
3008 break;
3009 case 0xc8: /* EQUkr */
3010 __asm__( "evaluxn_c8_EQUkr:" );
3011 {
3012 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3013 u->rst.dat[u->rst.ptr] = b == a;
3014#ifndef NO_STACK_CHECKS
3015 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3016 u->rst.error = 1;
3017 goto error;
3018 }
3019 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3020 u->rst.error = 2;
3021 goto error;
3022 }
3023#endif
3024 u->rst.ptr += 1;
3025 }
3026 break;
3027 case 0xc9: /* NEQkr */
3028 __asm__( "evaluxn_c9_NEQkr:" );
3029 {
3030 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3031 u->rst.dat[u->rst.ptr] = b != a;
3032#ifndef NO_STACK_CHECKS
3033 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3034 u->rst.error = 1;
3035 goto error;
3036 }
3037 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3038 u->rst.error = 2;
3039 goto error;
3040 }
3041#endif
3042 u->rst.ptr += 1;
3043 }
3044 break;
3045 case 0xca: /* GTHkr */
3046 __asm__( "evaluxn_ca_GTHkr:" );
3047 {
3048 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3049 u->rst.dat[u->rst.ptr] = b > a;
3050#ifndef NO_STACK_CHECKS
3051 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3052 u->rst.error = 1;
3053 goto error;
3054 }
3055 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3056 u->rst.error = 2;
3057 goto error;
3058 }
3059#endif
3060 u->rst.ptr += 1;
3061 }
3062 break;
3063 case 0xcb: /* LTHkr */
3064 __asm__( "evaluxn_cb_LTHkr:" );
3065 {
3066 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3067 u->rst.dat[u->rst.ptr] = b < a;
3068#ifndef NO_STACK_CHECKS
3069 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3070 u->rst.error = 1;
3071 goto error;
3072 }
3073 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3074 u->rst.error = 2;
3075 goto error;
3076 }
3077#endif
3078 u->rst.ptr += 1;
3079 }
3080 break;
3081 case 0xcc: /* JMPkr */
3082 __asm__( "evaluxn_cc_JMPkr:" );
3083 {
3084 u8 a = u->rst.dat[u->rst.ptr - 1];
3085 u->ram.ptr += (s8)a;
3086#ifndef NO_STACK_CHECKS
3087 if(__builtin_expect(u->rst.ptr < 1, 0)) {
3088 u->rst.error = 1;
3089 goto error;
3090 }
3091#endif
3092 }
3093 break;
3094 case 0xcd: /* JCNkr */
3095 __asm__( "evaluxn_cd_JCNkr:" );
3096 {
3097 u8 a = u->rst.dat[u->rst.ptr - 1];
3098 if(u->rst.dat[u->rst.ptr - 2]) u->ram.ptr += (s8)a;
3099#ifndef NO_STACK_CHECKS
3100 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3101 u->rst.error = 1;
3102 goto error;
3103 }
3104#endif
3105 }
3106 break;
3107 case 0xce: /* JSRkr */
3108 __asm__( "evaluxn_ce_JSRkr:" );
3109 {
3110 u8 a = u->rst.dat[u->rst.ptr - 1];
3111 u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8;
3112 u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff;
3113 u->ram.ptr += (s8)a;
3114#ifndef NO_STACK_CHECKS
3115 if(__builtin_expect(u->rst.ptr < 1, 0)) {
3116 u->rst.error = 1;
3117 goto error;
3118 }
3119 if(__builtin_expect(u->wst.ptr > 253, 0)) {
3120 u->wst.error = 2;
3121 goto error;
3122 }
3123#endif
3124 u->wst.ptr += 2;
3125 }
3126 break;
3127 case 0xcf: /* STHkr */
3128 __asm__( "evaluxn_cf_STHkr:" );
3129 {
3130 u8 a = u->rst.dat[u->rst.ptr - 1];
3131 u->wst.dat[u->wst.ptr] = a;
3132#ifndef NO_STACK_CHECKS
3133 if(__builtin_expect(u->rst.ptr < 1, 0)) {
3134 u->rst.error = 1;
3135 goto error;
3136 }
3137 if(__builtin_expect(u->wst.ptr > 254, 0)) {
3138 u->wst.error = 2;
3139 goto error;
3140 }
3141#endif
3142 u->wst.ptr += 1;
3143 }
3144 break;
3145 case 0xd0: /* LDZkr */
3146 __asm__( "evaluxn_d0_LDZkr:" );
3147 {
3148 u8 a = u->rst.dat[u->rst.ptr - 1];
3149 u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a);
3150#ifndef NO_STACK_CHECKS
3151 if(__builtin_expect(u->rst.ptr < 1, 0)) {
3152 u->rst.error = 1;
3153 goto error;
3154 }
3155 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3156 u->rst.error = 2;
3157 goto error;
3158 }
3159#endif
3160 u->rst.ptr += 1;
3161 }
3162 break;
3163 case 0xd1: /* STZkr */
3164 __asm__( "evaluxn_d1_STZkr:" );
3165 {
3166 u8 a = u->rst.dat[u->rst.ptr - 1];
3167 u8 b = u->rst.dat[u->rst.ptr - 2];
3168 mempoke8(u->ram.dat, a, b);
3169#ifndef NO_STACK_CHECKS
3170 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3171 u->rst.error = 1;
3172 goto error;
3173 }
3174#endif
3175 }
3176 break;
3177 case 0xd2: /* LDRkr */
3178 __asm__( "evaluxn_d2_LDRkr:" );
3179 {
3180 u8 a = u->rst.dat[u->rst.ptr - 1];
3181 u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a);
3182#ifndef NO_STACK_CHECKS
3183 if(__builtin_expect(u->rst.ptr < 1, 0)) {
3184 u->rst.error = 1;
3185 goto error;
3186 }
3187 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3188 u->rst.error = 2;
3189 goto error;
3190 }
3191#endif
3192 u->rst.ptr += 1;
3193 }
3194 break;
3195 case 0xd3: /* STRkr */
3196 __asm__( "evaluxn_d3_STRkr:" );
3197 {
3198 u8 a = u->rst.dat[u->rst.ptr - 1];
3199 u8 b = u->rst.dat[u->rst.ptr - 2];
3200 mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b);
3201#ifndef NO_STACK_CHECKS
3202 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3203 u->rst.error = 1;
3204 goto error;
3205 }
3206#endif
3207 }
3208 break;
3209 case 0xd4: /* LDAkr */
3210 __asm__( "evaluxn_d4_LDAkr:" );
3211 {
3212 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
3213 u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a);
3214#ifndef NO_STACK_CHECKS
3215 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3216 u->rst.error = 1;
3217 goto error;
3218 }
3219 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3220 u->rst.error = 2;
3221 goto error;
3222 }
3223#endif
3224 u->rst.ptr += 1;
3225 }
3226 break;
3227 case 0xd5: /* STAkr */
3228 __asm__( "evaluxn_d5_STAkr:" );
3229 {
3230 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
3231 u8 b = u->rst.dat[u->rst.ptr - 3];
3232 mempoke8(u->ram.dat, a, b);
3233#ifndef NO_STACK_CHECKS
3234 if(__builtin_expect(u->rst.ptr < 3, 0)) {
3235 u->rst.error = 1;
3236 goto error;
3237 }
3238#endif
3239 }
3240 break;
3241 case 0xd6: /* DEIkr */
3242 __asm__( "evaluxn_d6_DEIkr:" );
3243 {
3244 u8 a = u->rst.dat[u->rst.ptr - 1];
3245 u->rst.dat[u->rst.ptr] = devpeek8(&u->dev[a >> 4], a);
3246#ifndef NO_STACK_CHECKS
3247 if(__builtin_expect(u->rst.ptr < 1, 0)) {
3248 u->rst.error = 1;
3249 goto error;
3250 }
3251 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3252 u->rst.error = 2;
3253 goto error;
3254 }
3255#endif
3256 u->rst.ptr += 1;
3257 }
3258 break;
3259 case 0xd7: /* DEOkr */
3260 __asm__( "evaluxn_d7_DEOkr:" );
3261 {
3262 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3263 devpoke8(&u->dev[a >> 4], a, b);
3264#ifndef NO_STACK_CHECKS
3265 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3266 u->rst.error = 1;
3267 goto error;
3268 }
3269#endif
3270 }
3271 break;
3272 case 0xd8: /* ADDkr */
3273 __asm__( "evaluxn_d8_ADDkr:" );
3274 {
3275 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3276 u->rst.dat[u->rst.ptr] = b + a;
3277#ifndef NO_STACK_CHECKS
3278 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3279 u->rst.error = 1;
3280 goto error;
3281 }
3282 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3283 u->rst.error = 2;
3284 goto error;
3285 }
3286#endif
3287 u->rst.ptr += 1;
3288 }
3289 break;
3290 case 0xd9: /* SUBkr */
3291 __asm__( "evaluxn_d9_SUBkr:" );
3292 {
3293 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3294 u->rst.dat[u->rst.ptr] = b - a;
3295#ifndef NO_STACK_CHECKS
3296 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3297 u->rst.error = 1;
3298 goto error;
3299 }
3300 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3301 u->rst.error = 2;
3302 goto error;
3303 }
3304#endif
3305 u->rst.ptr += 1;
3306 }
3307 break;
3308 case 0xda: /* MULkr */
3309 __asm__( "evaluxn_da_MULkr:" );
3310 {
3311 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3312 u->rst.dat[u->rst.ptr] = b * a;
3313#ifndef NO_STACK_CHECKS
3314 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3315 u->rst.error = 1;
3316 goto error;
3317 }
3318 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3319 u->rst.error = 2;
3320 goto error;
3321 }
3322#endif
3323 u->rst.ptr += 1;
3324 }
3325 break;
3326 case 0xdb: /* DIVkr */
3327 __asm__( "evaluxn_db_DIVkr:" );
3328 {
3329 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3330 u->rst.dat[u->rst.ptr] = b / a;
3331#ifndef NO_STACK_CHECKS
3332 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3333 u->rst.error = 1;
3334 goto error;
3335 }
3336 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3337 u->rst.error = 2;
3338 goto error;
3339 }
3340#endif
3341 u->rst.ptr += 1;
3342 }
3343 break;
3344 case 0xdc: /* ANDkr */
3345 __asm__( "evaluxn_dc_ANDkr:" );
3346 {
3347 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3348 u->rst.dat[u->rst.ptr] = b & a;
3349#ifndef NO_STACK_CHECKS
3350 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3351 u->rst.error = 1;
3352 goto error;
3353 }
3354 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3355 u->rst.error = 2;
3356 goto error;
3357 }
3358#endif
3359 u->rst.ptr += 1;
3360 }
3361 break;
3362 case 0xdd: /* ORAkr */
3363 __asm__( "evaluxn_dd_ORAkr:" );
3364 {
3365 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3366 u->rst.dat[u->rst.ptr] = b | a;
3367#ifndef NO_STACK_CHECKS
3368 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3369 u->rst.error = 1;
3370 goto error;
3371 }
3372 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3373 u->rst.error = 2;
3374 goto error;
3375 }
3376#endif
3377 u->rst.ptr += 1;
3378 }
3379 break;
3380 case 0xde: /* EORkr */
3381 __asm__( "evaluxn_de_EORkr:" );
3382 {
3383 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3384 u->rst.dat[u->rst.ptr] = b ^ a;
3385#ifndef NO_STACK_CHECKS
3386 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3387 u->rst.error = 1;
3388 goto error;
3389 }
3390 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3391 u->rst.error = 2;
3392 goto error;
3393 }
3394#endif
3395 u->rst.ptr += 1;
3396 }
3397 break;
3398 case 0xdf: /* SFTkr */
3399 __asm__( "evaluxn_df_SFTkr:" );
3400 {
3401 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3402 u->rst.dat[u->rst.ptr] = b >> (a & 0x07) << ((a & 0x70) >> 4);
3403#ifndef NO_STACK_CHECKS
3404 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3405 u->rst.error = 1;
3406 goto error;
3407 }
3408 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3409 u->rst.error = 2;
3410 goto error;
3411 }
3412#endif
3413 u->rst.ptr += 1;
3414 }
3415 break;
3416 case 0xe3: /* POP2kr */
3417 __asm__( "evaluxn_e3_POP2kr:" );
3418 {
3419 (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
3420#ifndef NO_STACK_CHECKS
3421 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3422 u->rst.error = 1;
3423 goto error;
3424 }
3425#endif
3426 }
3427 break;
3428 case 0xe4: /* DUP2kr */
3429 __asm__( "evaluxn_e4_DUP2kr:" );
3430 {
3431 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3432 u->rst.dat[u->rst.ptr] = b;
3433 u->rst.dat[u->rst.ptr + 1] = a;
3434 u->rst.dat[u->rst.ptr + 2] = b;
3435 u->rst.dat[u->rst.ptr + 3] = a;
3436#ifndef NO_STACK_CHECKS
3437 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3438 u->rst.error = 1;
3439 goto error;
3440 }
3441 if(__builtin_expect(u->rst.ptr > 251, 0)) {
3442 u->rst.error = 2;
3443 goto error;
3444 }
3445#endif
3446 u->rst.ptr += 4;
3447 }
3448 break;
3449 case 0xe5: /* SWP2kr */
3450 __asm__( "evaluxn_e5_SWP2kr:" );
3451 {
3452 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4];
3453 u->rst.dat[u->rst.ptr] = b;
3454 u->rst.dat[u->rst.ptr + 1] = a;
3455 u->rst.dat[u->rst.ptr + 2] = d;
3456 u->rst.dat[u->rst.ptr + 3] = c;
3457#ifndef NO_STACK_CHECKS
3458 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3459 u->rst.error = 1;
3460 goto error;
3461 }
3462 if(__builtin_expect(u->rst.ptr > 251, 0)) {
3463 u->rst.error = 2;
3464 goto error;
3465 }
3466#endif
3467 u->rst.ptr += 4;
3468 }
3469 break;
3470 case 0xe6: /* OVR2kr */
3471 __asm__( "evaluxn_e6_OVR2kr:" );
3472 {
3473 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4];
3474 u->rst.dat[u->rst.ptr] = d;
3475 u->rst.dat[u->rst.ptr + 1] = c;
3476 u->rst.dat[u->rst.ptr + 2] = b;
3477 u->rst.dat[u->rst.ptr + 3] = a;
3478 u->rst.dat[u->rst.ptr + 4] = d;
3479 u->rst.dat[u->rst.ptr + 5] = c;
3480#ifndef NO_STACK_CHECKS
3481 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3482 u->rst.error = 1;
3483 goto error;
3484 }
3485 if(__builtin_expect(u->rst.ptr > 249, 0)) {
3486 u->rst.error = 2;
3487 goto error;
3488 }
3489#endif
3490 u->rst.ptr += 6;
3491 }
3492 break;
3493 case 0xe7: /* ROT2kr */
3494 __asm__( "evaluxn_e7_ROT2kr:" );
3495 {
3496 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4], e = u->rst.dat[u->rst.ptr - 5], f = u->rst.dat[u->rst.ptr - 6];
3497 u->rst.dat[u->rst.ptr] = d;
3498 u->rst.dat[u->rst.ptr + 1] = c;
3499 u->rst.dat[u->rst.ptr + 2] = b;
3500 u->rst.dat[u->rst.ptr + 3] = a;
3501 u->rst.dat[u->rst.ptr + 4] = f;
3502 u->rst.dat[u->rst.ptr + 5] = e;
3503#ifndef NO_STACK_CHECKS
3504 if(__builtin_expect(u->rst.ptr < 6, 0)) {
3505 u->rst.error = 1;
3506 goto error;
3507 }
3508 if(__builtin_expect(u->rst.ptr > 249, 0)) {
3509 u->rst.error = 2;
3510 goto error;
3511 }
3512#endif
3513 u->rst.ptr += 6;
3514 }
3515 break;
3516 case 0xe8: /* EQU2kr */
3517 __asm__( "evaluxn_e8_EQU2kr:" );
3518 {
3519 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
3520 u->rst.dat[u->rst.ptr] = b == a;
3521#ifndef NO_STACK_CHECKS
3522 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3523 u->rst.error = 1;
3524 goto error;
3525 }
3526 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3527 u->rst.error = 2;
3528 goto error;
3529 }
3530#endif
3531 u->rst.ptr += 1;
3532 }
3533 break;
3534 case 0xe9: /* NEQ2kr */
3535 __asm__( "evaluxn_e9_NEQ2kr:" );
3536 {
3537 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
3538 u->rst.dat[u->rst.ptr] = b != a;
3539#ifndef NO_STACK_CHECKS
3540 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3541 u->rst.error = 1;
3542 goto error;
3543 }
3544 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3545 u->rst.error = 2;
3546 goto error;
3547 }
3548#endif
3549 u->rst.ptr += 1;
3550 }
3551 break;
3552 case 0xea: /* GTH2kr */
3553 __asm__( "evaluxn_ea_GTH2kr:" );
3554 {
3555 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
3556 u->rst.dat[u->rst.ptr] = b > a;
3557#ifndef NO_STACK_CHECKS
3558 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3559 u->rst.error = 1;
3560 goto error;
3561 }
3562 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3563 u->rst.error = 2;
3564 goto error;
3565 }
3566#endif
3567 u->rst.ptr += 1;
3568 }
3569 break;
3570 case 0xeb: /* LTH2kr */
3571 __asm__( "evaluxn_eb_LTH2kr:" );
3572 {
3573 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
3574 u->rst.dat[u->rst.ptr] = b < a;
3575#ifndef NO_STACK_CHECKS
3576 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3577 u->rst.error = 1;
3578 goto error;
3579 }
3580 if(__builtin_expect(u->rst.ptr > 254, 0)) {
3581 u->rst.error = 2;
3582 goto error;
3583 }
3584#endif
3585 u->rst.ptr += 1;
3586 }
3587 break;
3588 case 0xec: /* JMP2kr */
3589 __asm__( "evaluxn_ec_JMP2kr:" );
3590 {
3591 u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
3592#ifndef NO_STACK_CHECKS
3593 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3594 u->rst.error = 1;
3595 goto error;
3596 }
3597#endif
3598 }
3599 break;
3600 case 0xed: /* JCN2kr */
3601 __asm__( "evaluxn_ed_JCN2kr:" );
3602 {
3603 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
3604 if(u->rst.dat[u->rst.ptr - 3]) u->ram.ptr = a;
3605#ifndef NO_STACK_CHECKS
3606 if(__builtin_expect(u->rst.ptr < 3, 0)) {
3607 u->rst.error = 1;
3608 goto error;
3609 }
3610#endif
3611 }
3612 break;
3613 case 0xee: /* JSR2kr */
3614 __asm__( "evaluxn_ee_JSR2kr:" );
3615 {
3616 u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8;
3617 u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff;
3618 u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
3619#ifndef NO_STACK_CHECKS
3620 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3621 u->rst.error = 1;
3622 goto error;
3623 }
3624 if(__builtin_expect(u->wst.ptr > 253, 0)) {
3625 u->wst.error = 2;
3626 goto error;
3627 }
3628#endif
3629 u->wst.ptr += 2;
3630 }
3631 break;
3632 case 0xef: /* STH2kr */
3633 __asm__( "evaluxn_ef_STH2kr:" );
3634 {
3635 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2];
3636 u->wst.dat[u->wst.ptr] = b;
3637 u->wst.dat[u->wst.ptr + 1] = a;
3638#ifndef NO_STACK_CHECKS
3639 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3640 u->rst.error = 1;
3641 goto error;
3642 }
3643 if(__builtin_expect(u->wst.ptr > 253, 0)) {
3644 u->wst.error = 2;
3645 goto error;
3646 }
3647#endif
3648 u->wst.ptr += 2;
3649 }
3650 break;
3651 case 0xf0: /* LDZ2kr */
3652 __asm__( "evaluxn_f0_LDZ2kr:" );
3653 {
3654 u8 a = u->rst.dat[u->rst.ptr - 1];
3655 u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a);
3656 u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, a + 1);
3657#ifndef NO_STACK_CHECKS
3658 if(__builtin_expect(u->rst.ptr < 1, 0)) {
3659 u->rst.error = 1;
3660 goto error;
3661 }
3662 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3663 u->rst.error = 2;
3664 goto error;
3665 }
3666#endif
3667 u->rst.ptr += 2;
3668 }
3669 break;
3670 case 0xf1: /* STZ2kr */
3671 __asm__( "evaluxn_f1_STZ2kr:" );
3672 {
3673 u8 a = u->rst.dat[u->rst.ptr - 1];
3674 u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
3675 mempoke16(u->ram.dat, a, b);
3676#ifndef NO_STACK_CHECKS
3677 if(__builtin_expect(u->rst.ptr < 3, 0)) {
3678 u->rst.error = 1;
3679 goto error;
3680 }
3681#endif
3682 }
3683 break;
3684 case 0xf2: /* LDR2kr */
3685 __asm__( "evaluxn_f2_LDR2kr:" );
3686 {
3687 u8 a = u->rst.dat[u->rst.ptr - 1];
3688 u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a);
3689 u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1);
3690#ifndef NO_STACK_CHECKS
3691 if(__builtin_expect(u->rst.ptr < 1, 0)) {
3692 u->rst.error = 1;
3693 goto error;
3694 }
3695 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3696 u->rst.error = 2;
3697 goto error;
3698 }
3699#endif
3700 u->rst.ptr += 2;
3701 }
3702 break;
3703 case 0xf3: /* STR2kr */
3704 __asm__( "evaluxn_f3_STR2kr:" );
3705 {
3706 u8 a = u->rst.dat[u->rst.ptr - 1];
3707 u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
3708 mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b);
3709#ifndef NO_STACK_CHECKS
3710 if(__builtin_expect(u->rst.ptr < 3, 0)) {
3711 u->rst.error = 1;
3712 goto error;
3713 }
3714#endif
3715 }
3716 break;
3717 case 0xf4: /* LDA2kr */
3718 __asm__( "evaluxn_f4_LDA2kr:" );
3719 {
3720 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
3721 u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a);
3722 u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, a + 1);
3723#ifndef NO_STACK_CHECKS
3724 if(__builtin_expect(u->rst.ptr < 2, 0)) {
3725 u->rst.error = 1;
3726 goto error;
3727 }
3728 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3729 u->rst.error = 2;
3730 goto error;
3731 }
3732#endif
3733 u->rst.ptr += 2;
3734 }
3735 break;
3736 case 0xf5: /* STA2kr */
3737 __asm__( "evaluxn_f5_STA2kr:" );
3738 {
3739 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8));
3740 u16 b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
3741 mempoke16(u->ram.dat, a, b);
3742#ifndef NO_STACK_CHECKS
3743 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3744 u->rst.error = 1;
3745 goto error;
3746 }
3747#endif
3748 }
3749 break;
3750 case 0xf6: /* DEI2kr */
3751 __asm__( "evaluxn_f6_DEI2kr:" );
3752 {
3753 u8 a = u->rst.dat[u->rst.ptr - 1];
3754 u->rst.dat[u->rst.ptr] = devpeek8(&u->dev[a >> 4], a);
3755 u->rst.dat[u->rst.ptr + 1] = devpeek8(&u->dev[a >> 4], a + 1);
3756#ifndef NO_STACK_CHECKS
3757 if(__builtin_expect(u->rst.ptr < 1, 0)) {
3758 u->rst.error = 1;
3759 goto error;
3760 }
3761 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3762 u->rst.error = 2;
3763 goto error;
3764 }
3765#endif
3766 u->rst.ptr += 2;
3767 }
3768 break;
3769 case 0xf7: /* DEO2kr */
3770 __asm__( "evaluxn_f7_DEO2kr:" );
3771 {
3772 u8 a = u->rst.dat[u->rst.ptr - 1];
3773 u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
3774 devpoke16(&u->dev[a >> 4], a, b);
3775#ifndef NO_STACK_CHECKS
3776 if(__builtin_expect(u->rst.ptr < 3, 0)) {
3777 u->rst.error = 1;
3778 goto error;
3779 }
3780#endif
3781 }
3782 break;
3783 case 0xf8: /* ADD2kr */
3784 __asm__( "evaluxn_f8_ADD2kr:" );
3785 {
3786 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
3787 u->rst.dat[u->rst.ptr] = (b + a) >> 8;
3788 u->rst.dat[u->rst.ptr + 1] = (b + a) & 0xff;
3789#ifndef NO_STACK_CHECKS
3790 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3791 u->rst.error = 1;
3792 goto error;
3793 }
3794 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3795 u->rst.error = 2;
3796 goto error;
3797 }
3798#endif
3799 u->rst.ptr += 2;
3800 }
3801 break;
3802 case 0xf9: /* SUB2kr */
3803 __asm__( "evaluxn_f9_SUB2kr:" );
3804 {
3805 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
3806 u->rst.dat[u->rst.ptr] = (b - a) >> 8;
3807 u->rst.dat[u->rst.ptr + 1] = (b - a) & 0xff;
3808#ifndef NO_STACK_CHECKS
3809 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3810 u->rst.error = 1;
3811 goto error;
3812 }
3813 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3814 u->rst.error = 2;
3815 goto error;
3816 }
3817#endif
3818 u->rst.ptr += 2;
3819 }
3820 break;
3821 case 0xfa: /* MUL2kr */
3822 __asm__( "evaluxn_fa_MUL2kr:" );
3823 {
3824 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
3825 u->rst.dat[u->rst.ptr] = (b * a) >> 8;
3826 u->rst.dat[u->rst.ptr + 1] = (b * a) & 0xff;
3827#ifndef NO_STACK_CHECKS
3828 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3829 u->rst.error = 1;
3830 goto error;
3831 }
3832 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3833 u->rst.error = 2;
3834 goto error;
3835 }
3836#endif
3837 u->rst.ptr += 2;
3838 }
3839 break;
3840 case 0xfb: /* DIV2kr */
3841 __asm__( "evaluxn_fb_DIV2kr:" );
3842 {
3843 u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)), b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8));
3844 u->rst.dat[u->rst.ptr] = (b / a) >> 8;
3845 u->rst.dat[u->rst.ptr + 1] = (b / a) & 0xff;
3846#ifndef NO_STACK_CHECKS
3847 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3848 u->rst.error = 1;
3849 goto error;
3850 }
3851 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3852 u->rst.error = 2;
3853 goto error;
3854 }
3855#endif
3856 u->rst.ptr += 2;
3857 }
3858 break;
3859 case 0xfc: /* AND2kr */
3860 __asm__( "evaluxn_fc_AND2kr:" );
3861 {
3862 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4];
3863 u->rst.dat[u->rst.ptr] = d & b;
3864 u->rst.dat[u->rst.ptr + 1] = c & a;
3865#ifndef NO_STACK_CHECKS
3866 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3867 u->rst.error = 1;
3868 goto error;
3869 }
3870 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3871 u->rst.error = 2;
3872 goto error;
3873 }
3874#endif
3875 u->rst.ptr += 2;
3876 }
3877 break;
3878 case 0xfd: /* ORA2kr */
3879 __asm__( "evaluxn_fd_ORA2kr:" );
3880 {
3881 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4];
3882 u->rst.dat[u->rst.ptr] = d | b;
3883 u->rst.dat[u->rst.ptr + 1] = c | a;
3884#ifndef NO_STACK_CHECKS
3885 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3886 u->rst.error = 1;
3887 goto error;
3888 }
3889 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3890 u->rst.error = 2;
3891 goto error;
3892 }
3893#endif
3894 u->rst.ptr += 2;
3895 }
3896 break;
3897 case 0xfe: /* EOR2kr */
3898 __asm__( "evaluxn_fe_EOR2kr:" );
3899 {
3900 u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2], c = u->rst.dat[u->rst.ptr - 3], d = u->rst.dat[u->rst.ptr - 4];
3901 u->rst.dat[u->rst.ptr] = d ^ b;
3902 u->rst.dat[u->rst.ptr + 1] = c ^ a;
3903#ifndef NO_STACK_CHECKS
3904 if(__builtin_expect(u->rst.ptr < 4, 0)) {
3905 u->rst.error = 1;
3906 goto error;
3907 }
3908 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3909 u->rst.error = 2;
3910 goto error;
3911 }
3912#endif
3913 u->rst.ptr += 2;
3914 }
3915 break;
3916 case 0xff: /* SFT2kr */
3917 __asm__( "evaluxn_ff_SFT2kr:" );
3918 {
3919 u8 a = u->rst.dat[u->rst.ptr - 1];
3920 u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8));
3921 u->rst.dat[u->rst.ptr] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8;
3922 u->rst.dat[u->rst.ptr + 1] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff;
3923#ifndef NO_STACK_CHECKS
3924 if(__builtin_expect(u->rst.ptr < 3, 0)) {
3925 u->rst.error = 1;
3926 goto error;
3927 }
3928 if(__builtin_expect(u->rst.ptr > 253, 0)) {
3929 u->rst.error = 2;
3930 goto error;
3931 }
3932#endif
3933 u->rst.ptr += 2;
3934 }
3935 break;
3936#pragma GCC diagnostic pop
3937 }
3938 }
3939 return 1;
3940#ifndef NO_STACK_CHECKS
3941error:
3942 return 0;
3943#endif
3944}
3945
3946Device *
3947portuxn(Uxn *u, u8 id, char *name, void (*talkfn)(Device *d, u8 b0, u8 w))
3948{
3949 Device *d = &u->dev[id];
3950 d->addr = id * 0x10;
3951 d->u = u;
3952 d->mem = u->ram.dat;
3953 d->talk = talkfn;
3954 (void)name;
3955 return d;
3956}
generated by cgit v1.2.1 (git 2.18.0) at 2024-05-03 04:36:39 +0000