From 1fabc50056826ba54ad2a613e5509f3047414cae Mon Sep 17 00:00:00 2001 From: Bad Diode Date: Fri, 28 May 2021 21:05:49 +0200 Subject: Rename source files for flat directory structure --- src/ppu.c | 418 ++++++ src/ppu.h | 30 + src/uxn.c | 3956 +++++++++++++++++++++++++++++++++++++++++++++++++ src/uxn.h | 56 + src/uxn/devices/ppu.c | 418 ------ src/uxn/devices/ppu.h | 30 - src/uxn/uxn.c | 3956 ------------------------------------------------- src/uxn/uxn.h | 56 - 8 files changed, 4460 insertions(+), 4460 deletions(-) create mode 100644 src/ppu.c create mode 100644 src/ppu.h create mode 100644 src/uxn.c create mode 100644 src/uxn.h delete mode 100644 src/uxn/devices/ppu.c delete mode 100644 src/uxn/devices/ppu.h delete mode 100644 src/uxn/uxn.c delete mode 100644 src/uxn/uxn.h (limited to 'src') diff --git a/src/ppu.c b/src/ppu.c new file mode 100644 index 0000000..f626604 --- /dev/null +++ b/src/ppu.c @@ -0,0 +1,418 @@ +#include "ppu.h" +#include "bd-font.c" + +/* +Copyright (c) 2021 Devine Lu Linvega +Copyright (c) 2021 Andrew Alderwick +Copyright (c) 2021 Adrian "asie" Siekierka +Copyright (c) 2021 Bad Diode + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE. +*/ + +#define FG_FRONT ((u32*)(MEM_VRAM)) +#define BG_FRONT ((u32*)(MEM_VRAM + KB(20))) +#define FG_BACK ((u32*)(MEM_VRAM + KB(44))) +#define BG_BACK ((u32*)(MEM_VRAM + KB(64))) +#define TILE_MAP ((u32*)(MEM_VRAM + KB(40))) +#define FONT_DATA ((u32*)(MEM_VRAM + KB(84))) + +// Keyboard. +#define SPRITE_START_IDX 640 + +static u32 unpack_icon_lut[256] = { + 0x00000000, 0x00000001, 0x00000010, 0x00000011, 0x00000100, + 0x00000101, 0x00000110, 0x00000111, 0x00001000, 0x00001001, + 0x00001010, 0x00001011, 0x00001100, 0x00001101, 0x00001110, + 0x00001111, 0x00010000, 0x00010001, 0x00010010, 0x00010011, + 0x00010100, 0x00010101, 0x00010110, 0x00010111, 0x00011000, + 0x00011001, 0x00011010, 0x00011011, 0x00011100, 0x00011101, + 0x00011110, 0x00011111, 0x00100000, 0x00100001, 0x00100010, + 0x00100011, 0x00100100, 0x00100101, 0x00100110, 0x00100111, + 0x00101000, 0x00101001, 0x00101010, 0x00101011, 0x00101100, + 0x00101101, 0x00101110, 0x00101111, 0x00110000, 0x00110001, + 0x00110010, 0x00110011, 0x00110100, 0x00110101, 0x00110110, + 0x00110111, 0x00111000, 0x00111001, 0x00111010, 0x00111011, + 0x00111100, 0x00111101, 0x00111110, 0x00111111, 0x01000000, + 0x01000001, 0x01000010, 0x01000011, 0x01000100, 0x01000101, + 0x01000110, 0x01000111, 0x01001000, 0x01001001, 0x01001010, + 0x01001011, 0x01001100, 0x01001101, 0x01001110, 0x01001111, + 0x01010000, 0x01010001, 0x01010010, 0x01010011, 0x01010100, + 0x01010101, 0x01010110, 0x01010111, 0x01011000, 0x01011001, + 0x01011010, 0x01011011, 0x01011100, 0x01011101, 0x01011110, + 0x01011111, 0x01100000, 0x01100001, 0x01100010, 0x01100011, + 0x01100100, 0x01100101, 0x01100110, 0x01100111, 0x01101000, + 0x01101001, 0x01101010, 0x01101011, 0x01101100, 0x01101101, + 0x01101110, 0x01101111, 0x01110000, 0x01110001, 0x01110010, + 0x01110011, 0x01110100, 0x01110101, 0x01110110, 0x01110111, + 0x01111000, 0x01111001, 0x01111010, 0x01111011, 0x01111100, + 0x01111101, 0x01111110, 0x01111111, 0x10000000, 0x10000001, + 0x10000010, 0x10000011, 0x10000100, 0x10000101, 0x10000110, + 0x10000111, 0x10001000, 0x10001001, 0x10001010, 0x10001011, + 0x10001100, 0x10001101, 0x10001110, 0x10001111, 0x10010000, + 0x10010001, 0x10010010, 0x10010011, 0x10010100, 0x10010101, + 0x10010110, 0x10010111, 0x10011000, 0x10011001, 0x10011010, + 0x10011011, 0x10011100, 0x10011101, 0x10011110, 0x10011111, + 0x10100000, 0x10100001, 0x10100010, 0x10100011, 0x10100100, + 0x10100101, 0x10100110, 0x10100111, 0x10101000, 0x10101001, + 0x10101010, 0x10101011, 0x10101100, 0x10101101, 0x10101110, + 0x10101111, 0x10110000, 0x10110001, 0x10110010, 0x10110011, + 0x10110100, 0x10110101, 0x10110110, 0x10110111, 0x10111000, + 0x10111001, 0x10111010, 0x10111011, 0x10111100, 0x10111101, + 0x10111110, 0x10111111, 0x11000000, 0x11000001, 0x11000010, + 0x11000011, 0x11000100, 0x11000101, 0x11000110, 0x11000111, + 0x11001000, 0x11001001, 0x11001010, 0x11001011, 0x11001100, + 0x11001101, 0x11001110, 0x11001111, 0x11010000, 0x11010001, + 0x11010010, 0x11010011, 0x11010100, 0x11010101, 0x11010110, + 0x11010111, 0x11011000, 0x11011001, 0x11011010, 0x11011011, + 0x11011100, 0x11011101, 0x11011110, 0x11011111, 0x11100000, + 0x11100001, 0x11100010, 0x11100011, 0x11100100, 0x11100101, + 0x11100110, 0x11100111, 0x11101000, 0x11101001, 0x11101010, + 0x11101011, 0x11101100, 0x11101101, 0x11101110, 0x11101111, + 0x11110000, 0x11110001, 0x11110010, 0x11110011, 0x11110100, + 0x11110101, 0x11110110, 0x11110111, 0x11111000, 0x11111001, + 0x11111010, 0x11111011, 0x11111100, 0x11111101, 0x11111110, + 0x11111111 +}; + +static u32 unpack_icon_lut_flipx[256] = { + 0x00000000, 0x10000000, 0x01000000, 0x11000000, 0x00100000, + 0x10100000, 0x01100000, 0x11100000, 0x00010000, 0x10010000, + 0x01010000, 0x11010000, 0x00110000, 0x10110000, 0x01110000, + 0x11110000, 0x00001000, 0x10001000, 0x01001000, 0x11001000, + 0x00101000, 0x10101000, 0x01101000, 0x11101000, 0x00011000, + 0x10011000, 0x01011000, 0x11011000, 0x00111000, 0x10111000, + 0x01111000, 0x11111000, 0x00000100, 0x10000100, 0x01000100, + 0x11000100, 0x00100100, 0x10100100, 0x01100100, 0x11100100, + 0x00010100, 0x10010100, 0x01010100, 0x11010100, 0x00110100, + 0x10110100, 0x01110100, 0x11110100, 0x00001100, 0x10001100, + 0x01001100, 0x11001100, 0x00101100, 0x10101100, 0x01101100, + 0x11101100, 0x00011100, 0x10011100, 0x01011100, 0x11011100, + 0x00111100, 0x10111100, 0x01111100, 0x11111100, 0x00000010, + 0x10000010, 0x01000010, 0x11000010, 0x00100010, 0x10100010, + 0x01100010, 0x11100010, 0x00010010, 0x10010010, 0x01010010, + 0x11010010, 0x00110010, 0x10110010, 0x01110010, 0x11110010, + 0x00001010, 0x10001010, 0x01001010, 0x11001010, 0x00101010, + 0x10101010, 0x01101010, 0x11101010, 0x00011010, 0x10011010, + 0x01011010, 0x11011010, 0x00111010, 0x10111010, 0x01111010, + 0x11111010, 0x00000110, 0x10000110, 0x01000110, 0x11000110, + 0x00100110, 0x10100110, 0x01100110, 0x11100110, 0x00010110, + 0x10010110, 0x01010110, 0x11010110, 0x00110110, 0x10110110, + 0x01110110, 0x11110110, 0x00001110, 0x10001110, 0x01001110, + 0x11001110, 0x00101110, 0x10101110, 0x01101110, 0x11101110, + 0x00011110, 0x10011110, 0x01011110, 0x11011110, 0x00111110, + 0x10111110, 0x01111110, 0x11111110, 0x00000001, 0x10000001, + 0x01000001, 0x11000001, 0x00100001, 0x10100001, 0x01100001, + 0x11100001, 0x00010001, 0x10010001, 0x01010001, 0x11010001, + 0x00110001, 0x10110001, 0x01110001, 0x11110001, 0x00001001, + 0x10001001, 0x01001001, 0x11001001, 0x00101001, 0x10101001, + 0x01101001, 0x11101001, 0x00011001, 0x10011001, 0x01011001, + 0x11011001, 0x00111001, 0x10111001, 0x01111001, 0x11111001, + 0x00000101, 0x10000101, 0x01000101, 0x11000101, 0x00100101, + 0x10100101, 0x01100101, 0x11100101, 0x00010101, 0x10010101, + 0x01010101, 0x11010101, 0x00110101, 0x10110101, 0x01110101, + 0x11110101, 0x00001101, 0x10001101, 0x01001101, 0x11001101, + 0x00101101, 0x10101101, 0x01101101, 0x11101101, 0x00011101, + 0x10011101, 0x01011101, 0x11011101, 0x00111101, 0x10111101, + 0x01111101, 0x11111101, 0x00000011, 0x10000011, 0x01000011, + 0x11000011, 0x00100011, 0x10100011, 0x01100011, 0x11100011, + 0x00010011, 0x10010011, 0x01010011, 0x11010011, 0x00110011, + 0x10110011, 0x01110011, 0x11110011, 0x00001011, 0x10001011, + 0x01001011, 0x11001011, 0x00101011, 0x10101011, 0x01101011, + 0x11101011, 0x00011011, 0x10011011, 0x01011011, 0x11011011, + 0x00111011, 0x10111011, 0x01111011, 0x11111011, 0x00000111, + 0x10000111, 0x01000111, 0x11000111, 0x00100111, 0x10100111, + 0x01100111, 0x11100111, 0x00010111, 0x10010111, 0x01010111, + 0x11010111, 0x00110111, 0x10110111, 0x01110111, 0x11110111, + 0x00001111, 0x10001111, 0x01001111, 0x11001111, 0x00101111, + 0x10101111, 0x01101111, 0x11101111, 0x00011111, 0x10011111, + 0x01011111, 0x11011111, 0x00111111, 0x10111111, 0x01111111, + 0x11111111 +}; + +static u32 dirty_tiles[21] = {0}; + +void +putcolors(u8 *addr) { + int i; + for(i = 0; i < 4; ++i) { + u8 + r = (*(addr + i / 2) >> (!(i % 2) << 2)) & 0x0f, + g = (*(addr + 2 + i / 2) >> (!(i % 2) << 2)) & 0x0f, + b = (*(addr + 4 + i / 2) >> (!(i % 2) << 2)) & 0x0f; + PAL_BUFFER_BG[i] = rgb15( + (r << 1) | (r >> 3), + (g << 1) | (g >> 3), + (b << 1) | (b >> 3)); + for (size_t j = 0; j < 16; ++j) { + PAL_BUFFER_SPRITES[i * 16 + j] = rgb15( + (r << 1) | (r >> 3), + (g << 1) | (g >> 3), + (b << 1) | (b >> 3)); + } + } +} + +IWRAM_CODE +void +putpixel(u32 *layer, u16 x, u16 y, u8 color) { + if (x >= SCREEN_WIDTH || y >= SCREEN_HEIGHT) return; + size_t tile_x = x / 8; + size_t tile_y = y / 8; + size_t start_col = x % 8; + size_t start_row = y % 8; + size_t pos = (start_row + ((tile_x + tile_y * 32) * 8)); + size_t shift = start_col * 4; + layer[pos] = (layer[pos] & (~(0xF << shift))) | (color << shift); + dirty_tiles[tile_y] |= 1 << tile_x; +} + +IWRAM_CODE +void +puticn(u32 *layer, u16 x, u16 y, u8 *sprite, u8 color, u8 flipx, u8 flipy) { + u8 sprline; + u16 v; + u32 dirtyflag = (1 << (x >> 3)) | (1 << ((x + 7) >> 3)); + + u32 layerpos = ((y & 7) + (((x >> 3) + (y >> 3) * 32) * 8)); + u32 *layerptr = &layer[layerpos]; + u32 shift = (x & 7) << 2; + u32 *lut_expand = flipx ? unpack_icon_lut : unpack_icon_lut_flipx; + + if (flipy) flipy = 7; + + if (x >= SCREEN_WIDTH || y >= SCREEN_HEIGHT) return; + + if (color != 0x05 && color != 0x0a && color != 0x0f) { + u64 mask = ~((u64)0xFFFFFFFF << shift); + + for (v = 0; v < 8; v++, layerptr++) { + if ((y + v) >= SCREEN_HEIGHT) break; + + sprline = sprite[v ^ flipy]; + u64 data = (u64)(lut_expand[sprline] * (color & 3)) << shift; + data |= (u64)(lut_expand[sprline ^ 0xFF] * (color >> 2)) << shift; + + layerptr[0] = (layerptr[0] & mask) | data; + layerptr[8] = (layerptr[8] & (mask >> 32)) | (data >> 32); + + if (((y + v) & 7) == 7) layerptr += (32 - 1) * 8; + } + } else { + for (v = 0; v < 8; v++, layerptr++) { + if ((y + v) >= SCREEN_HEIGHT) break; + + sprline = sprite[v ^ flipy]; + u64 mask = ~((u64)(lut_expand[sprline] * 0xF) << shift); + u64 data = (u64)(lut_expand[sprline] * (color & 3)) << shift; + + layerptr[0] = (layerptr[0] & mask) | data; + layerptr[8] = (layerptr[8] & (mask >> 32)) | (data >> 32); + + if (((y + v) & 7) == 7) layerptr += (32 - 1) * 8; + } + } + + dirty_tiles[y >> 3] |= dirtyflag; + dirty_tiles[(y + 7) >> 3] |= dirtyflag; +} + +IWRAM_CODE +void +putfontchar(u32 *layer, u16 tile_x, u16 tile_y, u8 ch, u8 color) { + u32 pos = (tile_x + tile_y * 32) * 8; + u32 *tile_data = &layer[pos]; + u32 *font_data = &FONT_DATA[8 * ch]; + for (size_t i = 0; i < 8; ++i) { + tile_data[i] = font_data[i] * color; + } + dirty_tiles[tile_y] |= 1 << tile_x; +} + +IWRAM_CODE +void +putchr(u32 *layer, u16 x, u16 y, u8 *sprite, u8 color, + u8 flipx, u8 flipy) { + u8 sprline1, sprline2; + u16 v; + u32 dirtyflag = (1 << (x >> 3)) | (1 << ((x + 7) >> 3)); + + u32 layerpos = ((y & 7) + (((x >> 3) + (y >> 3) * 32) * 8)); + u32 *layerptr = &layer[layerpos]; + u32 shift = (x & 7) << 2; + u32 *lut_expand = flipx ? unpack_icon_lut : unpack_icon_lut_flipx; + + if (flipy) flipy = 7; + + if (x >= SCREEN_WIDTH || y >= SCREEN_HEIGHT) return; + + u64 mask = ~((u64)0xFFFFFFFF << shift); + u32 colconst = (color >> 2) * 0x11111111; + + for (v = 0; v < 8; v++, layerptr++) { + if ((y + v) >= SCREEN_HEIGHT) break; + + sprline1 = sprite[v ^ flipy]; + sprline2 = sprite[(v ^ flipy) | 8]; + + u32 data32 = + (lut_expand[sprline1] * (color & 3)) + + (lut_expand[sprline2] * ((color & 1) << 1)) + + colconst; + u64 data = ((u64) (data32 & 0x33333333)) << shift; + + layerptr[0] = (layerptr[0] & mask) | data; + layerptr[8] = (layerptr[8] & (mask >> 32)) | (data >> 32); + + if (((y + v) & 7) == 7) layerptr += (32 - 1) * 8; + } + + dirty_tiles[y >> 3] |= dirtyflag; + dirty_tiles[(y + 7) >> 3] |= dirtyflag; +} + +IWRAM_CODE +void +flipbuf(Ppu *p) { + Tile *mem_fg = FG_FRONT; + Tile *mem_bg = BG_FRONT; + for (size_t j = 0; j < 20; ++j) { + if (dirty_tiles[j] == 0) { + continue; + } + + size_t k = 1; + for (size_t i = 0; i < 30; ++i, k <<= 1) { + if (dirty_tiles[j] & k) { + Tile *tile_fg = p->fg; + Tile *tile_bg = p->bg; + mem_fg[i + j * 32] = tile_fg[i + j * 32]; + mem_bg[i + j * 32] = tile_bg[i + j * 32]; + } + } + dirty_tiles[j] = 0; + } +} + +typedef struct KeyboardChar { + int x; + int y; + u8 symbol; +} KeyboardChar; + +static u8 cursor_position = 0; + +#define KEYBOARD_ROW_SIZE 12 +#define KEYBOARD_START_TILE_X (30 / 2 - KEYBOARD_ROW_SIZE / 2) +#define KEYBOARD_START_TILE_Y (20 / 2 - 3) + +KeyboardChar keyboard[] = { + {0, 0, '!'}, {0, 0, '?'}, {0, 0, '@'}, {0, 0, '#'}, {0, 0, '$'}, {0, 0, '%'}, {0, 0, '^'}, {0, 0, '&'}, {0, 0, '*'}, {0, 0, '"'}, {0, 0, '\''}, {0, 0, 0x7f}, + {0, 0, '('}, {0, 0, ')'}, {0, 0, '['}, {0, 0, ']'}, {0, 0, '{'}, {0, 0, '}'}, {0, 0, '<'}, {0, 0, '>'}, {0, 0, '+'}, {0, 0, '-'}, {0, 0, '='}, {0, 0, 0x14}, + {0, 0, '0'}, {0, 0, '1'}, {0, 0, '2'}, {0, 0, '3'}, {0, 0, '4'}, {0, 0, '5'}, {0, 0, '6'}, {0, 0, '7'}, {0, 0, '8'}, {0, 0, '9'}, {0, 0, '~'}, {0, 0, 0x18}, + {0, 0, 'a'}, {0, 0, 'b'}, {0, 0, 'c'}, {0, 0, 'd'}, {0, 0, 'e'}, {0, 0, 'f'}, {0, 0, 'g'}, {0, 0, 'h'}, {0, 0, 'i'}, {0, 0, 'j'}, {0, 0, '/'}, {0, 0, 0x19}, + {0, 0, 'k'}, {0, 0, 'l'}, {0, 0, 'm'}, {0, 0, 'n'}, {0, 0, 'o'}, {0, 0, 'p'}, {0, 0, 'q'}, {0, 0, 'r'}, {0, 0, 's'}, {0, 0, 't'}, {0, 0, '\\'}, {0, 0, 0x1b}, + {0, 0, 'u'}, {0, 0, 'v'}, {0, 0, 'w'}, {0, 0, 'x'}, {0, 0, 'y'}, {0, 0, 'z'}, {0, 0, ','}, {0, 0, '.'}, {0, 0, ';'}, {0, 0, ':'}, {0, 0, '_'}, {0, 0, 0x1a}, +}; + +void +toggle_keyboard(void) { + for (size_t i = 0; i < LEN(keyboard); ++i) { + OBJ_ATTR_0(i) ^= OBJ_HIDDEN; + } + OBJ_ATTR_0(127) ^= OBJ_HIDDEN; +} + +void +update_cursor(u8 pos) { + cursor_position = CLAMP(pos, 0, LEN(keyboard) - 1); + OBJ_ATTR_0(127) = (OBJ_ATTR_0(127) & ~0xFF) + | OBJ_Y_COORD(keyboard[cursor_position].y); + OBJ_ATTR_1(127) = (OBJ_ATTR_0(127) & ~0x1FF) + | OBJ_X_COORD(keyboard[cursor_position].x); +} + +int +initppu(Ppu *p, u8 hor, u8 ver, u8 pad) { + p->hor = hor; + p->ver = ver; + p->pad = pad; + p->width = (8 * p->hor + p->pad * 2); + p->height = (8 * p->ver + p->pad * 2); + + // Initialize display mode and bg palette. + DISP_CTRL = DISP_MODE_0 | DISP_BG_0 | DISP_BG_1 | DISP_OBJ; + + // Initialize backgrounds. + u8 cb_fg = 0; + u8 cb_bg = 1; + u8 sb_fg = 20; + u8 sb_bg = 21; + BG_CTRL(0) = BG_CHARBLOCK(cb_fg) | BG_SCREENBLOCK(sb_fg) | BG_PRIORITY(1); + BG_CTRL(1) = BG_CHARBLOCK(cb_bg) | BG_SCREENBLOCK(sb_bg) | BG_PRIORITY(2); + + // Clear front buffer. + p->fg = FG_FRONT; + p->bg = BG_FRONT; + + // Use DMA to clear VRAM. + u32 fill = 0; + dma_fill(p->fg, fill, KB(20), 3); + dma_fill(p->bg, fill, KB(20), 3); + + // Clear back buffer. + p->fg = FG_BACK; + p->bg = BG_BACK; + dma_fill(p->fg, fill, KB(20), 3); + dma_fill(p->bg, fill, KB(20), 3); + + // Initialize default palette. + PAL_BUFFER_BG[0] = COLOR_BLACK; + PAL_BUFFER_BG[1] = COLOR_WHITE; + PAL_BUFFER_BG[2] = COLOR_RED; + PAL_BUFFER_BG[3] = COLOR_BLUE; + for (size_t i = 0; i < 16; ++i) { + PAL_BUFFER_SPRITES[i] = COLOR_BLACK; + PAL_BUFFER_SPRITES[1 * 16] = COLOR_WHITE; + PAL_BUFFER_SPRITES[2 * 16] = COLOR_RED; + PAL_BUFFER_SPRITES[3 * 16] = COLOR_BLUE; + } + + // Initialize background memory map. + u16 *mem_map_fg = SCREENBLOCK_MEM[sb_fg]; + u16 *mem_map_bg = SCREENBLOCK_MEM[sb_bg]; + size_t k = 0; + for (size_t i = 0; i < 32 * 20; ++i, ++k) { + mem_map_fg[i] = k; + mem_map_bg[i] = k + 32 * 4; + } + + // Load font data into VRAM. + unpack_tiles(&bd_font, FONT_DATA, 256); + + // Initialize keyboard sprites. + int tile_x = KEYBOARD_START_TILE_X; + int tile_y = KEYBOARD_START_TILE_Y; + for (size_t i = 0; i < sizeof(keyboard) / sizeof(keyboard[0]); ++i) { + keyboard[i].x = tile_x * 8; + keyboard[i].y = tile_y * 8; + OBJ_ATTR_0(i) = OBJ_SHAPE_SQUARE | OBJ_Y_COORD(keyboard[i].y) | OBJ_HIDDEN; + OBJ_ATTR_1(i) = OBJ_SIZE_SMALL | OBJ_X_COORD(keyboard[i].x); + OBJ_ATTR_2(i) = (SPRITE_START_IDX + keyboard[i].symbol) | OBJ_PAL_BANK(0); + tile_x++; + if (tile_x - KEYBOARD_START_TILE_X >= KEYBOARD_ROW_SIZE) { + tile_x = KEYBOARD_START_TILE_X; + tile_y++; + } + } + OBJ_ATTR_0(127) = OBJ_SHAPE_SQUARE | OBJ_Y_COORD(keyboard[cursor_position].y) | OBJ_HIDDEN; + OBJ_ATTR_1(127) = OBJ_SIZE_SMALL | OBJ_X_COORD(keyboard[cursor_position].x); + OBJ_ATTR_2(127) = (SPRITE_START_IDX + 0xdb) | OBJ_PAL_BANK(3); + + return 1; +} diff --git a/src/ppu.h b/src/ppu.h new file mode 100644 index 0000000..0356b63 --- /dev/null +++ b/src/ppu.h @@ -0,0 +1,30 @@ +#ifndef UXNGBA_PPU_H +#define UXNGBA_PPU_H + +#include +#include + +/* +Copyright (c) 2021 Devine Lu Linvega +Copyright (c) 2021 Andrew Alderwick +Copyright (c) 2021 Bad Diode + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE. +*/ + +typedef struct Ppu { + u32 *bg, *fg; + u16 hor, ver, pad, width, height; +} Ppu; + +int initppu(Ppu *p, u8 hor, u8 ver, u8 pad); +void putcolors(u8 *addr); +void putpixel(u32 *layer, u16 x, u16 y, u8 color); +void puticn(u32 *layer, u16 x, u16 y, u8 *sprite, u8 color, u8 flipx, u8 flipy); +void putchr(u32 *layer, u16 x, u16 y, u8 *sprite, u8 color, u8 flipx, u8 flipy); +#endif // UXNGBA_PPU_H 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 @@ +#include +#include "uxn.h" + +#define NO_STACK_CHECKS + +/* +Copyright (u) 2021 Devine Lu Linvega +Copyright (u) 2021 Andrew Alderwick + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE. +*/ + +IWRAM_CODE +int +evaluxn(Uxn *u, u16 vec) +{ + u8 instr; + u->ram.ptr = vec; + while(u->ram.ptr) { + instr = u->ram.dat[u->ram.ptr++]; + switch(instr) { +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-value" +#pragma GCC diagnostic ignored "-Wunused-variable" + case 0x00: /* BRK */ + case 0x20: /* BRK2 */ + case 0x40: /* BRKr */ + case 0x60: /* BRK2r */ + case 0x80: /* BRKk */ + case 0xa0: /* BRK2k */ + case 0xc0: /* BRKkr */ + case 0xe0: /* BRK2kr */ + __asm__( "evaluxn_00_BRK:" ); + { + u->ram.ptr = 0; + } + break; + case 0x01: /* LIT */ + case 0x81: /* LITk */ + __asm__( "evaluxn_01_LIT:" ); + { + u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x02: /* NOP */ + case 0x22: /* NOP2 */ + case 0x42: /* NOPr */ + case 0x62: /* NOP2r */ + case 0x82: /* NOPk */ + case 0xa2: /* NOP2k */ + case 0xc2: /* NOPkr */ + case 0xe2: /* NOP2kr */ + __asm__( "evaluxn_02_NOP:" ); + { + (void)u; + } + break; + case 0x03: /* POP */ + __asm__( "evaluxn_03_POP:" ); + { + u->wst.dat[u->wst.ptr - 1]; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x04: /* DUP */ + __asm__( "evaluxn_04_DUP:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x05: /* SWP */ + __asm__( "evaluxn_05_SWP:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = a; + u->wst.dat[u->wst.ptr - 1] = b; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x06: /* OVR */ + __asm__( "evaluxn_06_OVR:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x07: /* ROT */ + __asm__( "evaluxn_07_ROT:" ); + { + 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]; + u->wst.dat[u->wst.ptr - 3] = b; + u->wst.dat[u->wst.ptr - 2] = a; + u->wst.dat[u->wst.ptr - 1] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x08: /* EQU */ + __asm__( "evaluxn_08_EQU:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b == a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x09: /* NEQ */ + __asm__( "evaluxn_09_NEQ:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b != a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x0a: /* GTH */ + __asm__( "evaluxn_0a_GTH:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b > a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x0b: /* LTH */ + __asm__( "evaluxn_0b_LTH:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b < a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x0c: /* JMP */ + __asm__( "evaluxn_0c_JMP:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x0d: /* JCN */ + __asm__( "evaluxn_0d_JCN:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + if(u->wst.dat[u->wst.ptr - 2]) u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x0e: /* JSR */ + __asm__( "evaluxn_0e_JSR:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8; + u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff; + u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0x0f: /* STH */ + __asm__( "evaluxn_0f_STH:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->rst.dat[u->rst.ptr] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0x10: /* LDZ */ + __asm__( "evaluxn_10_LDZ:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x11: /* STZ */ + __asm__( "evaluxn_11_STZ:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u8 b = u->wst.dat[u->wst.ptr - 2]; + mempoke8(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x12: /* LDR */ + __asm__( "evaluxn_12_LDR:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x13: /* STR */ + __asm__( "evaluxn_13_STR:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u8 b = u->wst.dat[u->wst.ptr - 2]; + mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x14: /* LDA */ + __asm__( "evaluxn_14_LDA:" ); + { + u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); + u->wst.dat[u->wst.ptr - 2] = mempeek8(u->ram.dat, a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x15: /* STA */ + __asm__( "evaluxn_15_STA:" ); + { + u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); + u8 b = u->wst.dat[u->wst.ptr - 3]; + mempoke8(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 3; + } + break; + case 0x16: /* DEI */ + __asm__( "evaluxn_16_DEI:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr - 1] = devpeek8(&u->dev[a >> 4], a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x17: /* DEO */ + __asm__( "evaluxn_17_DEO:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + devpoke8(&u->dev[a >> 4], a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x18: /* ADD */ + __asm__( "evaluxn_18_ADD:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b + a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x19: /* SUB */ + __asm__( "evaluxn_19_SUB:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b - a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x1a: /* MUL */ + __asm__( "evaluxn_1a_MUL:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b * a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x1b: /* DIV */ + __asm__( "evaluxn_1b_DIV:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b / a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x1c: /* AND */ + __asm__( "evaluxn_1c_AND:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b & a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x1d: /* ORA */ + __asm__( "evaluxn_1d_ORA:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b | a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x1e: /* EOR */ + __asm__( "evaluxn_1e_EOR:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b ^ a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x1f: /* SFT */ + __asm__( "evaluxn_1f_SFT:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr - 2] = b >> (a & 0x07) << ((a & 0x70) >> 4); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x21: /* LIT2 */ + case 0xa1: /* LIT2k */ + __asm__( "evaluxn_21_LIT2:" ); + { + u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++); + u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr++); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0x23: /* POP2 */ + __asm__( "evaluxn_23_POP2:" ); + { + (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x24: /* DUP2 */ + __asm__( "evaluxn_24_DUP2:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b; + u->wst.dat[u->wst.ptr + 1] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0x25: /* SWP2 */ + __asm__( "evaluxn_25_SWP2:" ); + { + 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]; + u->wst.dat[u->wst.ptr - 4] = b; + u->wst.dat[u->wst.ptr - 3] = a; + u->wst.dat[u->wst.ptr - 2] = d; + u->wst.dat[u->wst.ptr - 1] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x26: /* OVR2 */ + __asm__( "evaluxn_26_OVR2:" ); + { + 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]; + u->wst.dat[u->wst.ptr] = d; + u->wst.dat[u->wst.ptr + 1] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0x27: /* ROT2 */ + __asm__( "evaluxn_27_ROT2:" ); + { + 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]; + u->wst.dat[u->wst.ptr - 6] = d; + u->wst.dat[u->wst.ptr - 5] = c; + u->wst.dat[u->wst.ptr - 4] = b; + u->wst.dat[u->wst.ptr - 3] = a; + u->wst.dat[u->wst.ptr - 2] = f; + u->wst.dat[u->wst.ptr - 1] = e; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 6, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x28: /* EQU2 */ + __asm__( "evaluxn_28_EQU2:" ); + { + 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)); + u->wst.dat[u->wst.ptr - 4] = b == a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 3; + } + break; + case 0x29: /* NEQ2 */ + __asm__( "evaluxn_29_NEQ2:" ); + { + 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)); + u->wst.dat[u->wst.ptr - 4] = b != a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 3; + } + break; + case 0x2a: /* GTH2 */ + __asm__( "evaluxn_2a_GTH2:" ); + { + 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)); + u->wst.dat[u->wst.ptr - 4] = b > a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 3; + } + break; + case 0x2b: /* LTH2 */ + __asm__( "evaluxn_2b_LTH2:" ); + { + 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)); + u->wst.dat[u->wst.ptr - 4] = b < a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 3; + } + break; + case 0x2c: /* JMP2 */ + __asm__( "evaluxn_2c_JMP2:" ); + { + u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x2d: /* JCN2 */ + __asm__( "evaluxn_2d_JCN2:" ); + { + u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); + if(u->wst.dat[u->wst.ptr - 3]) u->ram.ptr = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 3; + } + break; + case 0x2e: /* JSR2 */ + __asm__( "evaluxn_2e_JSR2:" ); + { + u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8; + u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff; + u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0x2f: /* STH2 */ + __asm__( "evaluxn_2f_STH2:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b; + u->rst.dat[u->rst.ptr + 1] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0x30: /* LDZ2 */ + __asm__( "evaluxn_30_LDZ2:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, a); + u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x31: /* STZ2 */ + __asm__( "evaluxn_31_STZ2:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); + mempoke16(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 3; + } + break; + case 0x32: /* LDR2 */ + __asm__( "evaluxn_32_LDR2:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); + u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x33: /* STR2 */ + __asm__( "evaluxn_33_STR2:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); + mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 3; + } + break; + case 0x34: /* LDA2 */ + __asm__( "evaluxn_34_LDA2:" ); + { + u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); + u->wst.dat[u->wst.ptr - 2] = mempeek8(u->ram.dat, a); + u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x35: /* STA2 */ + __asm__( "evaluxn_35_STA2:" ); + { + u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); + u16 b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8)); + mempoke16(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 4; + } + break; + case 0x36: /* DEI2 */ + __asm__( "evaluxn_36_DEI2:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr - 1] = devpeek8(&u->dev[a >> 4], a); + u->wst.dat[u->wst.ptr] = devpeek8(&u->dev[a >> 4], a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x37: /* DEO2 */ + __asm__( "evaluxn_37_DEO2:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); + devpoke16(&u->dev[a >> 4], a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 3; + } + break; + case 0x38: /* ADD2 */ + __asm__( "evaluxn_38_ADD2:" ); + { + 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)); + u->wst.dat[u->wst.ptr - 4] = (b + a) >> 8; + u->wst.dat[u->wst.ptr - 3] = (b + a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x39: /* SUB2 */ + __asm__( "evaluxn_39_SUB2:" ); + { + 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)); + u->wst.dat[u->wst.ptr - 4] = (b - a) >> 8; + u->wst.dat[u->wst.ptr - 3] = (b - a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x3a: /* MUL2 */ + __asm__( "evaluxn_3a_MUL2:" ); + { + 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)); + u->wst.dat[u->wst.ptr - 4] = (b * a) >> 8; + u->wst.dat[u->wst.ptr - 3] = (b * a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x3b: /* DIV2 */ + __asm__( "evaluxn_3b_DIV2:" ); + { + 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)); + u->wst.dat[u->wst.ptr - 4] = (b / a) >> 8; + u->wst.dat[u->wst.ptr - 3] = (b / a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x3c: /* AND2 */ + __asm__( "evaluxn_3c_AND2:" ); + { + 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]; + u->wst.dat[u->wst.ptr - 4] = d & b; + u->wst.dat[u->wst.ptr - 3] = c & a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x3d: /* ORA2 */ + __asm__( "evaluxn_3d_ORA2:" ); + { + 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]; + u->wst.dat[u->wst.ptr - 4] = d | b; + u->wst.dat[u->wst.ptr - 3] = c | a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x3e: /* EOR2 */ + __asm__( "evaluxn_3e_EOR2:" ); + { + 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]; + u->wst.dat[u->wst.ptr - 4] = d ^ b; + u->wst.dat[u->wst.ptr - 3] = c ^ a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 2; + } + break; + case 0x3f: /* SFT2 */ + __asm__( "evaluxn_3f_SFT2:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); + u->wst.dat[u->wst.ptr - 3] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8; + u->wst.dat[u->wst.ptr - 2] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + u->wst.ptr -= 1; + } + break; + case 0x41: /* LITr */ + case 0xc1: /* LITkr */ + __asm__( "evaluxn_41_LITr:" ); + { + u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0x43: /* POPr */ + __asm__( "evaluxn_43_POPr:" ); + { + u->rst.dat[u->rst.ptr - 1]; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x44: /* DUPr */ + __asm__( "evaluxn_44_DUPr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0x45: /* SWPr */ + __asm__( "evaluxn_45_SWPr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = a; + u->rst.dat[u->rst.ptr - 1] = b; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0x46: /* OVRr */ + __asm__( "evaluxn_46_OVRr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0x47: /* ROTr */ + __asm__( "evaluxn_47_ROTr:" ); + { + 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]; + u->rst.dat[u->rst.ptr - 3] = b; + u->rst.dat[u->rst.ptr - 2] = a; + u->rst.dat[u->rst.ptr - 1] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0x48: /* EQUr */ + __asm__( "evaluxn_48_EQUr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b == a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x49: /* NEQr */ + __asm__( "evaluxn_49_NEQr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b != a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x4a: /* GTHr */ + __asm__( "evaluxn_4a_GTHr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b > a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x4b: /* LTHr */ + __asm__( "evaluxn_4b_LTHr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b < a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x4c: /* JMPr */ + __asm__( "evaluxn_4c_JMPr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x4d: /* JCNr */ + __asm__( "evaluxn_4d_JCNr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + if(u->rst.dat[u->rst.ptr - 2]) u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x4e: /* JSRr */ + __asm__( "evaluxn_4e_JSRr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8; + u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff; + u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0x4f: /* STHr */ + __asm__( "evaluxn_4f_STHr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->wst.dat[u->wst.ptr] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x50: /* LDZr */ + __asm__( "evaluxn_50_LDZr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0x51: /* STZr */ + __asm__( "evaluxn_51_STZr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u8 b = u->rst.dat[u->rst.ptr - 2]; + mempoke8(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x52: /* LDRr */ + __asm__( "evaluxn_52_LDRr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0x53: /* STRr */ + __asm__( "evaluxn_53_STRr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u8 b = u->rst.dat[u->rst.ptr - 2]; + mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x54: /* LDAr */ + __asm__( "evaluxn_54_LDAr:" ); + { + u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); + u->rst.dat[u->rst.ptr - 2] = mempeek8(u->ram.dat, a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x55: /* STAr */ + __asm__( "evaluxn_55_STAr:" ); + { + u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); + u8 b = u->rst.dat[u->rst.ptr - 3]; + mempoke8(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 3; + } + break; + case 0x56: /* DEIr */ + __asm__( "evaluxn_56_DEIr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr - 1] = devpeek8(&u->dev[a >> 4], a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0x57: /* DEOr */ + __asm__( "evaluxn_57_DEOr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + devpoke8(&u->dev[a >> 4], a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x58: /* ADDr */ + __asm__( "evaluxn_58_ADDr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b + a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x59: /* SUBr */ + __asm__( "evaluxn_59_SUBr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b - a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x5a: /* MULr */ + __asm__( "evaluxn_5a_MULr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b * a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x5b: /* DIVr */ + __asm__( "evaluxn_5b_DIVr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b / a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x5c: /* ANDr */ + __asm__( "evaluxn_5c_ANDr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b & a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x5d: /* ORAr */ + __asm__( "evaluxn_5d_ORAr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b | a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x5e: /* EORr */ + __asm__( "evaluxn_5e_EORr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b ^ a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x5f: /* SFTr */ + __asm__( "evaluxn_5f_SFTr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr - 2] = b >> (a & 0x07) << ((a & 0x70) >> 4); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x61: /* LIT2r */ + case 0xe1: /* LIT2kr */ + __asm__( "evaluxn_61_LIT2r:" ); + { + u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++); + u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr++); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0x63: /* POP2r */ + __asm__( "evaluxn_63_POP2r:" ); + { + (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x64: /* DUP2r */ + __asm__( "evaluxn_64_DUP2r:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b; + u->rst.dat[u->rst.ptr + 1] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0x65: /* SWP2r */ + __asm__( "evaluxn_65_SWP2r:" ); + { + 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]; + u->rst.dat[u->rst.ptr - 4] = b; + u->rst.dat[u->rst.ptr - 3] = a; + u->rst.dat[u->rst.ptr - 2] = d; + u->rst.dat[u->rst.ptr - 1] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0x66: /* OVR2r */ + __asm__( "evaluxn_66_OVR2r:" ); + { + 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]; + u->rst.dat[u->rst.ptr] = d; + u->rst.dat[u->rst.ptr + 1] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0x67: /* ROT2r */ + __asm__( "evaluxn_67_ROT2r:" ); + { + 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]; + u->rst.dat[u->rst.ptr - 6] = d; + u->rst.dat[u->rst.ptr - 5] = c; + u->rst.dat[u->rst.ptr - 4] = b; + u->rst.dat[u->rst.ptr - 3] = a; + u->rst.dat[u->rst.ptr - 2] = f; + u->rst.dat[u->rst.ptr - 1] = e; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 6, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0x68: /* EQU2r */ + __asm__( "evaluxn_68_EQU2r:" ); + { + 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)); + u->rst.dat[u->rst.ptr - 4] = b == a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 3; + } + break; + case 0x69: /* NEQ2r */ + __asm__( "evaluxn_69_NEQ2r:" ); + { + 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)); + u->rst.dat[u->rst.ptr - 4] = b != a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 3; + } + break; + case 0x6a: /* GTH2r */ + __asm__( "evaluxn_6a_GTH2r:" ); + { + 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)); + u->rst.dat[u->rst.ptr - 4] = b > a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 3; + } + break; + case 0x6b: /* LTH2r */ + __asm__( "evaluxn_6b_LTH2r:" ); + { + 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)); + u->rst.dat[u->rst.ptr - 4] = b < a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 3; + } + break; + case 0x6c: /* JMP2r */ + __asm__( "evaluxn_6c_JMP2r:" ); + { + u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x6d: /* JCN2r */ + __asm__( "evaluxn_6d_JCN2r:" ); + { + u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); + if(u->rst.dat[u->rst.ptr - 3]) u->ram.ptr = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 3; + } + break; + case 0x6e: /* JSR2r */ + __asm__( "evaluxn_6e_JSR2r:" ); + { + u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8; + u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff; + u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0x6f: /* STH2r */ + __asm__( "evaluxn_6f_STH2r:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b; + u->wst.dat[u->wst.ptr + 1] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0x70: /* LDZ2r */ + __asm__( "evaluxn_70_LDZ2r:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, a); + u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0x71: /* STZ2r */ + __asm__( "evaluxn_71_STZ2r:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); + mempoke16(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 3; + } + break; + case 0x72: /* LDR2r */ + __asm__( "evaluxn_72_LDR2r:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); + u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0x73: /* STR2r */ + __asm__( "evaluxn_73_STR2r:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); + mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 3; + } + break; + case 0x74: /* LDA2r */ + __asm__( "evaluxn_74_LDA2r:" ); + { + u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); + u->rst.dat[u->rst.ptr - 2] = mempeek8(u->ram.dat, a); + u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0x75: /* STA2r */ + __asm__( "evaluxn_75_STA2r:" ); + { + u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); + u16 b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8)); + mempoke16(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 4; + } + break; + case 0x76: /* DEI2r */ + __asm__( "evaluxn_76_DEI2r:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr - 1] = devpeek8(&u->dev[a >> 4], a); + u->rst.dat[u->rst.ptr] = devpeek8(&u->dev[a >> 4], a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0x77: /* DEO2r */ + __asm__( "evaluxn_77_DEO2r:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); + devpoke16(&u->dev[a >> 4], a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 3; + } + break; + case 0x78: /* ADD2r */ + __asm__( "evaluxn_78_ADD2r:" ); + { + 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)); + u->rst.dat[u->rst.ptr - 4] = (b + a) >> 8; + u->rst.dat[u->rst.ptr - 3] = (b + a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x79: /* SUB2r */ + __asm__( "evaluxn_79_SUB2r:" ); + { + 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)); + u->rst.dat[u->rst.ptr - 4] = (b - a) >> 8; + u->rst.dat[u->rst.ptr - 3] = (b - a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x7a: /* MUL2r */ + __asm__( "evaluxn_7a_MUL2r:" ); + { + 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)); + u->rst.dat[u->rst.ptr - 4] = (b * a) >> 8; + u->rst.dat[u->rst.ptr - 3] = (b * a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x7b: /* DIV2r */ + __asm__( "evaluxn_7b_DIV2r:" ); + { + 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)); + u->rst.dat[u->rst.ptr - 4] = (b / a) >> 8; + u->rst.dat[u->rst.ptr - 3] = (b / a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x7c: /* AND2r */ + __asm__( "evaluxn_7c_AND2r:" ); + { + 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]; + u->rst.dat[u->rst.ptr - 4] = d & b; + u->rst.dat[u->rst.ptr - 3] = c & a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x7d: /* ORA2r */ + __asm__( "evaluxn_7d_ORA2r:" ); + { + 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]; + u->rst.dat[u->rst.ptr - 4] = d | b; + u->rst.dat[u->rst.ptr - 3] = c | a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x7e: /* EOR2r */ + __asm__( "evaluxn_7e_EOR2r:" ); + { + 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]; + u->rst.dat[u->rst.ptr - 4] = d ^ b; + u->rst.dat[u->rst.ptr - 3] = c ^ a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 2; + } + break; + case 0x7f: /* SFT2r */ + __asm__( "evaluxn_7f_SFT2r:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); + u->rst.dat[u->rst.ptr - 3] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8; + u->rst.dat[u->rst.ptr - 2] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + u->rst.ptr -= 1; + } + break; + case 0x83: /* POPk */ + __asm__( "evaluxn_83_POPk:" ); + { + u->wst.dat[u->wst.ptr - 1]; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x84: /* DUPk */ + __asm__( "evaluxn_84_DUPk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr] = a; + u->wst.dat[u->wst.ptr + 1] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0x85: /* SWPk */ + __asm__( "evaluxn_85_SWPk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = a; + u->wst.dat[u->wst.ptr + 1] = b; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0x86: /* OVRk */ + __asm__( "evaluxn_86_OVRk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b; + u->wst.dat[u->wst.ptr + 1] = a; + u->wst.dat[u->wst.ptr + 2] = b; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 252, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 3; + } + break; + case 0x87: /* ROTk */ + __asm__( "evaluxn_87_ROTk:" ); + { + 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]; + u->wst.dat[u->wst.ptr] = b; + u->wst.dat[u->wst.ptr + 1] = a; + u->wst.dat[u->wst.ptr + 2] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 252, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 3; + } + break; + case 0x88: /* EQUk */ + __asm__( "evaluxn_88_EQUk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b == a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x89: /* NEQk */ + __asm__( "evaluxn_89_NEQk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b != a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x8a: /* GTHk */ + __asm__( "evaluxn_8a_GTHk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b > a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x8b: /* LTHk */ + __asm__( "evaluxn_8b_LTHk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b < a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x8c: /* JMPk */ + __asm__( "evaluxn_8c_JMPk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x8d: /* JCNk */ + __asm__( "evaluxn_8d_JCNk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + if(u->wst.dat[u->wst.ptr - 2]) u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x8e: /* JSRk */ + __asm__( "evaluxn_8e_JSRk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8; + u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff; + u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0x8f: /* STHk */ + __asm__( "evaluxn_8f_STHk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->rst.dat[u->rst.ptr] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0x90: /* LDZk */ + __asm__( "evaluxn_90_LDZk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x91: /* STZk */ + __asm__( "evaluxn_91_STZk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u8 b = u->wst.dat[u->wst.ptr - 2]; + mempoke8(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x92: /* LDRk */ + __asm__( "evaluxn_92_LDRk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x93: /* STRk */ + __asm__( "evaluxn_93_STRk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u8 b = u->wst.dat[u->wst.ptr - 2]; + mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x94: /* LDAk */ + __asm__( "evaluxn_94_LDAk:" ); + { + u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); + u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x95: /* STAk */ + __asm__( "evaluxn_95_STAk:" ); + { + u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); + u8 b = u->wst.dat[u->wst.ptr - 3]; + mempoke8(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x96: /* DEIk */ + __asm__( "evaluxn_96_DEIk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr] = devpeek8(&u->dev[a >> 4], a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x97: /* DEOk */ + __asm__( "evaluxn_97_DEOk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + devpoke8(&u->dev[a >> 4], a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0x98: /* ADDk */ + __asm__( "evaluxn_98_ADDk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b + a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x99: /* SUBk */ + __asm__( "evaluxn_99_SUBk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b - a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x9a: /* MULk */ + __asm__( "evaluxn_9a_MULk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b * a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x9b: /* DIVk */ + __asm__( "evaluxn_9b_DIVk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b / a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x9c: /* ANDk */ + __asm__( "evaluxn_9c_ANDk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b & a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x9d: /* ORAk */ + __asm__( "evaluxn_9d_ORAk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b | a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x9e: /* EORk */ + __asm__( "evaluxn_9e_EORk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b ^ a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0x9f: /* SFTk */ + __asm__( "evaluxn_9f_SFTk:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b >> (a & 0x07) << ((a & 0x70) >> 4); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0xa3: /* POP2k */ + __asm__( "evaluxn_a3_POP2k:" ); + { + (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0xa4: /* DUP2k */ + __asm__( "evaluxn_a4_DUP2k:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b; + u->wst.dat[u->wst.ptr + 1] = a; + u->wst.dat[u->wst.ptr + 2] = b; + u->wst.dat[u->wst.ptr + 3] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 251, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 4; + } + break; + case 0xa5: /* SWP2k */ + __asm__( "evaluxn_a5_SWP2k:" ); + { + 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]; + u->wst.dat[u->wst.ptr] = b; + u->wst.dat[u->wst.ptr + 1] = a; + u->wst.dat[u->wst.ptr + 2] = d; + u->wst.dat[u->wst.ptr + 3] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 251, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 4; + } + break; + case 0xa6: /* OVR2k */ + __asm__( "evaluxn_a6_OVR2k:" ); + { + 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]; + u->wst.dat[u->wst.ptr] = d; + u->wst.dat[u->wst.ptr + 1] = c; + u->wst.dat[u->wst.ptr + 2] = b; + u->wst.dat[u->wst.ptr + 3] = a; + u->wst.dat[u->wst.ptr + 4] = d; + u->wst.dat[u->wst.ptr + 5] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 249, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 6; + } + break; + case 0xa7: /* ROT2k */ + __asm__( "evaluxn_a7_ROT2k:" ); + { + 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]; + u->wst.dat[u->wst.ptr] = d; + u->wst.dat[u->wst.ptr + 1] = c; + u->wst.dat[u->wst.ptr + 2] = b; + u->wst.dat[u->wst.ptr + 3] = a; + u->wst.dat[u->wst.ptr + 4] = f; + u->wst.dat[u->wst.ptr + 5] = e; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 6, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 249, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 6; + } + break; + case 0xa8: /* EQU2k */ + __asm__( "evaluxn_a8_EQU2k:" ); + { + 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)); + u->wst.dat[u->wst.ptr] = b == a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0xa9: /* NEQ2k */ + __asm__( "evaluxn_a9_NEQ2k:" ); + { + 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)); + u->wst.dat[u->wst.ptr] = b != a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0xaa: /* GTH2k */ + __asm__( "evaluxn_aa_GTH2k:" ); + { + 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)); + u->wst.dat[u->wst.ptr] = b > a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0xab: /* LTH2k */ + __asm__( "evaluxn_ab_LTH2k:" ); + { + 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)); + u->wst.dat[u->wst.ptr] = b < a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0xac: /* JMP2k */ + __asm__( "evaluxn_ac_JMP2k:" ); + { + u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0xad: /* JCN2k */ + __asm__( "evaluxn_ad_JCN2k:" ); + { + u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); + if(u->wst.dat[u->wst.ptr - 3]) u->ram.ptr = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0xae: /* JSR2k */ + __asm__( "evaluxn_ae_JSR2k:" ); + { + u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8; + u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff; + u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xaf: /* STH2k */ + __asm__( "evaluxn_af_STH2k:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b; + u->rst.dat[u->rst.ptr + 1] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xb0: /* LDZ2k */ + __asm__( "evaluxn_b0_LDZ2k:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a); + u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xb1: /* STZ2k */ + __asm__( "evaluxn_b1_STZ2k:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); + mempoke16(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0xb2: /* LDR2k */ + __asm__( "evaluxn_b2_LDR2k:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); + u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xb3: /* STR2k */ + __asm__( "evaluxn_b3_STR2k:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); + mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0xb4: /* LDA2k */ + __asm__( "evaluxn_b4_LDA2k:" ); + { + u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); + u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a); + u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 2, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xb5: /* STA2k */ + __asm__( "evaluxn_b5_STA2k:" ); + { + u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); + u16 b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8)); + mempoke16(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0xb6: /* DEI2k */ + __asm__( "evaluxn_b6_DEI2k:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u->wst.dat[u->wst.ptr] = devpeek8(&u->dev[a >> 4], a); + u->wst.dat[u->wst.ptr + 1] = devpeek8(&u->dev[a >> 4], a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 1, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xb7: /* DEO2k */ + __asm__( "evaluxn_b7_DEO2k:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); + devpoke16(&u->dev[a >> 4], a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } +#endif + } + break; + case 0xb8: /* ADD2k */ + __asm__( "evaluxn_b8_ADD2k:" ); + { + 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)); + u->wst.dat[u->wst.ptr] = (b + a) >> 8; + u->wst.dat[u->wst.ptr + 1] = (b + a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xb9: /* SUB2k */ + __asm__( "evaluxn_b9_SUB2k:" ); + { + 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)); + u->wst.dat[u->wst.ptr] = (b - a) >> 8; + u->wst.dat[u->wst.ptr + 1] = (b - a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xba: /* MUL2k */ + __asm__( "evaluxn_ba_MUL2k:" ); + { + 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)); + u->wst.dat[u->wst.ptr] = (b * a) >> 8; + u->wst.dat[u->wst.ptr + 1] = (b * a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xbb: /* DIV2k */ + __asm__( "evaluxn_bb_DIV2k:" ); + { + 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)); + u->wst.dat[u->wst.ptr] = (b / a) >> 8; + u->wst.dat[u->wst.ptr + 1] = (b / a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xbc: /* AND2k */ + __asm__( "evaluxn_bc_AND2k:" ); + { + 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]; + u->wst.dat[u->wst.ptr] = d & b; + u->wst.dat[u->wst.ptr + 1] = c & a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xbd: /* ORA2k */ + __asm__( "evaluxn_bd_ORA2k:" ); + { + 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]; + u->wst.dat[u->wst.ptr] = d | b; + u->wst.dat[u->wst.ptr + 1] = c | a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xbe: /* EOR2k */ + __asm__( "evaluxn_be_EOR2k:" ); + { + 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]; + u->wst.dat[u->wst.ptr] = d ^ b; + u->wst.dat[u->wst.ptr + 1] = c ^ a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 4, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xbf: /* SFT2k */ + __asm__( "evaluxn_bf_SFT2k:" ); + { + u8 a = u->wst.dat[u->wst.ptr - 1]; + u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); + u->wst.dat[u->wst.ptr] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8; + u->wst.dat[u->wst.ptr + 1] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->wst.ptr < 3, 0)) { + u->wst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xc3: /* POPkr */ + __asm__( "evaluxn_c3_POPkr:" ); + { + u->rst.dat[u->rst.ptr - 1]; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xc4: /* DUPkr */ + __asm__( "evaluxn_c4_DUPkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr] = a; + u->rst.dat[u->rst.ptr + 1] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xc5: /* SWPkr */ + __asm__( "evaluxn_c5_SWPkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = a; + u->rst.dat[u->rst.ptr + 1] = b; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xc6: /* OVRkr */ + __asm__( "evaluxn_c6_OVRkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b; + u->rst.dat[u->rst.ptr + 1] = a; + u->rst.dat[u->rst.ptr + 2] = b; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 252, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 3; + } + break; + case 0xc7: /* ROTkr */ + __asm__( "evaluxn_c7_ROTkr:" ); + { + 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]; + u->rst.dat[u->rst.ptr] = b; + u->rst.dat[u->rst.ptr + 1] = a; + u->rst.dat[u->rst.ptr + 2] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 252, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 3; + } + break; + case 0xc8: /* EQUkr */ + __asm__( "evaluxn_c8_EQUkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b == a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xc9: /* NEQkr */ + __asm__( "evaluxn_c9_NEQkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b != a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xca: /* GTHkr */ + __asm__( "evaluxn_ca_GTHkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b > a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xcb: /* LTHkr */ + __asm__( "evaluxn_cb_LTHkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b < a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xcc: /* JMPkr */ + __asm__( "evaluxn_cc_JMPkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xcd: /* JCNkr */ + __asm__( "evaluxn_cd_JCNkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + if(u->rst.dat[u->rst.ptr - 2]) u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xce: /* JSRkr */ + __asm__( "evaluxn_ce_JSRkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8; + u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff; + u->ram.ptr += (s8)a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xcf: /* STHkr */ + __asm__( "evaluxn_cf_STHkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->wst.dat[u->wst.ptr] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 254, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 1; + } + break; + case 0xd0: /* LDZkr */ + __asm__( "evaluxn_d0_LDZkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xd1: /* STZkr */ + __asm__( "evaluxn_d1_STZkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u8 b = u->rst.dat[u->rst.ptr - 2]; + mempoke8(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xd2: /* LDRkr */ + __asm__( "evaluxn_d2_LDRkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xd3: /* STRkr */ + __asm__( "evaluxn_d3_STRkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u8 b = u->rst.dat[u->rst.ptr - 2]; + mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xd4: /* LDAkr */ + __asm__( "evaluxn_d4_LDAkr:" ); + { + u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); + u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xd5: /* STAkr */ + __asm__( "evaluxn_d5_STAkr:" ); + { + u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); + u8 b = u->rst.dat[u->rst.ptr - 3]; + mempoke8(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xd6: /* DEIkr */ + __asm__( "evaluxn_d6_DEIkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr] = devpeek8(&u->dev[a >> 4], a); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xd7: /* DEOkr */ + __asm__( "evaluxn_d7_DEOkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + devpoke8(&u->dev[a >> 4], a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xd8: /* ADDkr */ + __asm__( "evaluxn_d8_ADDkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b + a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xd9: /* SUBkr */ + __asm__( "evaluxn_d9_SUBkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b - a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xda: /* MULkr */ + __asm__( "evaluxn_da_MULkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b * a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xdb: /* DIVkr */ + __asm__( "evaluxn_db_DIVkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b / a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xdc: /* ANDkr */ + __asm__( "evaluxn_dc_ANDkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b & a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xdd: /* ORAkr */ + __asm__( "evaluxn_dd_ORAkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b | a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xde: /* EORkr */ + __asm__( "evaluxn_de_EORkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b ^ a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xdf: /* SFTkr */ + __asm__( "evaluxn_df_SFTkr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b >> (a & 0x07) << ((a & 0x70) >> 4); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xe3: /* POP2kr */ + __asm__( "evaluxn_e3_POP2kr:" ); + { + (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xe4: /* DUP2kr */ + __asm__( "evaluxn_e4_DUP2kr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->rst.dat[u->rst.ptr] = b; + u->rst.dat[u->rst.ptr + 1] = a; + u->rst.dat[u->rst.ptr + 2] = b; + u->rst.dat[u->rst.ptr + 3] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 251, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 4; + } + break; + case 0xe5: /* SWP2kr */ + __asm__( "evaluxn_e5_SWP2kr:" ); + { + 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]; + u->rst.dat[u->rst.ptr] = b; + u->rst.dat[u->rst.ptr + 1] = a; + u->rst.dat[u->rst.ptr + 2] = d; + u->rst.dat[u->rst.ptr + 3] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 251, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 4; + } + break; + case 0xe6: /* OVR2kr */ + __asm__( "evaluxn_e6_OVR2kr:" ); + { + 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]; + u->rst.dat[u->rst.ptr] = d; + u->rst.dat[u->rst.ptr + 1] = c; + u->rst.dat[u->rst.ptr + 2] = b; + u->rst.dat[u->rst.ptr + 3] = a; + u->rst.dat[u->rst.ptr + 4] = d; + u->rst.dat[u->rst.ptr + 5] = c; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 249, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 6; + } + break; + case 0xe7: /* ROT2kr */ + __asm__( "evaluxn_e7_ROT2kr:" ); + { + 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]; + u->rst.dat[u->rst.ptr] = d; + u->rst.dat[u->rst.ptr + 1] = c; + u->rst.dat[u->rst.ptr + 2] = b; + u->rst.dat[u->rst.ptr + 3] = a; + u->rst.dat[u->rst.ptr + 4] = f; + u->rst.dat[u->rst.ptr + 5] = e; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 6, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 249, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 6; + } + break; + case 0xe8: /* EQU2kr */ + __asm__( "evaluxn_e8_EQU2kr:" ); + { + 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)); + u->rst.dat[u->rst.ptr] = b == a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xe9: /* NEQ2kr */ + __asm__( "evaluxn_e9_NEQ2kr:" ); + { + 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)); + u->rst.dat[u->rst.ptr] = b != a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xea: /* GTH2kr */ + __asm__( "evaluxn_ea_GTH2kr:" ); + { + 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)); + u->rst.dat[u->rst.ptr] = b > a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xeb: /* LTH2kr */ + __asm__( "evaluxn_eb_LTH2kr:" ); + { + 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)); + u->rst.dat[u->rst.ptr] = b < a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 254, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 1; + } + break; + case 0xec: /* JMP2kr */ + __asm__( "evaluxn_ec_JMP2kr:" ); + { + u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xed: /* JCN2kr */ + __asm__( "evaluxn_ed_JCN2kr:" ); + { + u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); + if(u->rst.dat[u->rst.ptr - 3]) u->ram.ptr = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xee: /* JSR2kr */ + __asm__( "evaluxn_ee_JSR2kr:" ); + { + u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8; + u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff; + u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xef: /* STH2kr */ + __asm__( "evaluxn_ef_STH2kr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; + u->wst.dat[u->wst.ptr] = b; + u->wst.dat[u->wst.ptr + 1] = a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->wst.ptr > 253, 0)) { + u->wst.error = 2; + goto error; + } +#endif + u->wst.ptr += 2; + } + break; + case 0xf0: /* LDZ2kr */ + __asm__( "evaluxn_f0_LDZ2kr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a); + u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xf1: /* STZ2kr */ + __asm__( "evaluxn_f1_STZ2kr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); + mempoke16(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xf2: /* LDR2kr */ + __asm__( "evaluxn_f2_LDR2kr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); + u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xf3: /* STR2kr */ + __asm__( "evaluxn_f3_STR2kr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); + mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xf4: /* LDA2kr */ + __asm__( "evaluxn_f4_LDA2kr:" ); + { + u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); + u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a); + u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 2, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xf5: /* STA2kr */ + __asm__( "evaluxn_f5_STA2kr:" ); + { + u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); + u16 b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8)); + mempoke16(u->ram.dat, a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xf6: /* DEI2kr */ + __asm__( "evaluxn_f6_DEI2kr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u->rst.dat[u->rst.ptr] = devpeek8(&u->dev[a >> 4], a); + u->rst.dat[u->rst.ptr + 1] = devpeek8(&u->dev[a >> 4], a + 1); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 1, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xf7: /* DEO2kr */ + __asm__( "evaluxn_f7_DEO2kr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); + devpoke16(&u->dev[a >> 4], a, b); +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } +#endif + } + break; + case 0xf8: /* ADD2kr */ + __asm__( "evaluxn_f8_ADD2kr:" ); + { + 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)); + u->rst.dat[u->rst.ptr] = (b + a) >> 8; + u->rst.dat[u->rst.ptr + 1] = (b + a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xf9: /* SUB2kr */ + __asm__( "evaluxn_f9_SUB2kr:" ); + { + 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)); + u->rst.dat[u->rst.ptr] = (b - a) >> 8; + u->rst.dat[u->rst.ptr + 1] = (b - a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xfa: /* MUL2kr */ + __asm__( "evaluxn_fa_MUL2kr:" ); + { + 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)); + u->rst.dat[u->rst.ptr] = (b * a) >> 8; + u->rst.dat[u->rst.ptr + 1] = (b * a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xfb: /* DIV2kr */ + __asm__( "evaluxn_fb_DIV2kr:" ); + { + 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)); + u->rst.dat[u->rst.ptr] = (b / a) >> 8; + u->rst.dat[u->rst.ptr + 1] = (b / a) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xfc: /* AND2kr */ + __asm__( "evaluxn_fc_AND2kr:" ); + { + 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]; + u->rst.dat[u->rst.ptr] = d & b; + u->rst.dat[u->rst.ptr + 1] = c & a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xfd: /* ORA2kr */ + __asm__( "evaluxn_fd_ORA2kr:" ); + { + 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]; + u->rst.dat[u->rst.ptr] = d | b; + u->rst.dat[u->rst.ptr + 1] = c | a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xfe: /* EOR2kr */ + __asm__( "evaluxn_fe_EOR2kr:" ); + { + 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]; + u->rst.dat[u->rst.ptr] = d ^ b; + u->rst.dat[u->rst.ptr + 1] = c ^ a; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 4, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; + case 0xff: /* SFT2kr */ + __asm__( "evaluxn_ff_SFT2kr:" ); + { + u8 a = u->rst.dat[u->rst.ptr - 1]; + u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); + u->rst.dat[u->rst.ptr] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8; + u->rst.dat[u->rst.ptr + 1] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff; +#ifndef NO_STACK_CHECKS + if(__builtin_expect(u->rst.ptr < 3, 0)) { + u->rst.error = 1; + goto error; + } + if(__builtin_expect(u->rst.ptr > 253, 0)) { + u->rst.error = 2; + goto error; + } +#endif + u->rst.ptr += 2; + } + break; +#pragma GCC diagnostic pop + } + } + return 1; +#ifndef NO_STACK_CHECKS +error: + return 0; +#endif +} + +Device * +portuxn(Uxn *u, u8 id, char *name, void (*talkfn)(Device *d, u8 b0, u8 w)) +{ + Device *d = &u->dev[id]; + d->addr = id * 0x10; + d->u = u; + d->mem = u->ram.dat; + d->talk = talkfn; + (void)name; + return d; +} diff --git a/src/uxn.h b/src/uxn.h new file mode 100644 index 0000000..a4ab428 --- /dev/null +++ b/src/uxn.h @@ -0,0 +1,56 @@ +#ifndef UXNGBA_UXN_H +#define UXNGBA_UXN_H + +#include + +/* +Copyright (c) 2021 Devine Lu Linvega + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE. +*/ + +#define PAGE_PROGRAM 0x0100 + +typedef struct { + u8 ptr, kptr, error; + u8 dat[256]; +} Stack; + +typedef struct { + u16 ptr; + u8 *dat; +} Memory; + +typedef struct Device { + struct Uxn *u; + u8 addr, dat[16], *mem; + void (*talk)(struct Device *d, u8, u8); +} Device; + +typedef struct Uxn { + Stack wst, rst, *src, *dst; + Memory ram; + Device dev[16]; +} Uxn; + +struct Uxn; + +static inline void mempoke8(u8 *m, u16 a, u8 b) { m[a] = b; } +static inline u8 mempeek8(u8 *m, u16 a) { return m[a]; } +static inline void mempoke16(u8 *m, u16 a, u16 b) { mempoke8(m, a, b >> 8); mempoke8(m, a + 1, b); } +static inline u16 mempeek16(u8 *m, u16 a) { return (mempeek8(m, a) << 8) + mempeek8(m, a + 1); } +static inline void devpoke8(Device *d, u8 a, u8 b) { d->dat[a & 0xf] = b; d->talk(d, a & 0x0f, 1); } +static inline u8 devpeek8(Device *d, u8 a) { d->talk(d, a & 0x0f, 0); return d->dat[a & 0xf]; } +static inline void devpoke16(Device *d, u8 a, u16 b) { devpoke8(d, a, b >> 8); devpoke8(d, a + 1, b); } +static inline u16 devpeek16(Device *d, u16 a) { return (devpeek8(d, a) << 8) + devpeek8(d, a + 1); } + +int loaduxn(Uxn *c, char *filepath); +int bootuxn(Uxn *c); +int evaluxn(Uxn *u, u16 vec); +Device *portuxn(Uxn *u, u8 id, char *name, void (*talkfn)(Device *, u8, u8)); +#endif // UXNGBA_UXN_H diff --git a/src/uxn/devices/ppu.c b/src/uxn/devices/ppu.c deleted file mode 100644 index f626604..0000000 --- a/src/uxn/devices/ppu.c +++ /dev/null @@ -1,418 +0,0 @@ -#include "ppu.h" -#include "bd-font.c" - -/* -Copyright (c) 2021 Devine Lu Linvega -Copyright (c) 2021 Andrew Alderwick -Copyright (c) 2021 Adrian "asie" Siekierka -Copyright (c) 2021 Bad Diode - -Permission to use, copy, modify, and distribute this software for any -purpose with or without fee is hereby granted, provided that the above -copyright notice and this permission notice appear in all copies. - -THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES -WITH REGARD TO THIS SOFTWARE. -*/ - -#define FG_FRONT ((u32*)(MEM_VRAM)) -#define BG_FRONT ((u32*)(MEM_VRAM + KB(20))) -#define FG_BACK ((u32*)(MEM_VRAM + KB(44))) -#define BG_BACK ((u32*)(MEM_VRAM + KB(64))) -#define TILE_MAP ((u32*)(MEM_VRAM + KB(40))) -#define FONT_DATA ((u32*)(MEM_VRAM + KB(84))) - -// Keyboard. -#define SPRITE_START_IDX 640 - -static u32 unpack_icon_lut[256] = { - 0x00000000, 0x00000001, 0x00000010, 0x00000011, 0x00000100, - 0x00000101, 0x00000110, 0x00000111, 0x00001000, 0x00001001, - 0x00001010, 0x00001011, 0x00001100, 0x00001101, 0x00001110, - 0x00001111, 0x00010000, 0x00010001, 0x00010010, 0x00010011, - 0x00010100, 0x00010101, 0x00010110, 0x00010111, 0x00011000, - 0x00011001, 0x00011010, 0x00011011, 0x00011100, 0x00011101, - 0x00011110, 0x00011111, 0x00100000, 0x00100001, 0x00100010, - 0x00100011, 0x00100100, 0x00100101, 0x00100110, 0x00100111, - 0x00101000, 0x00101001, 0x00101010, 0x00101011, 0x00101100, - 0x00101101, 0x00101110, 0x00101111, 0x00110000, 0x00110001, - 0x00110010, 0x00110011, 0x00110100, 0x00110101, 0x00110110, - 0x00110111, 0x00111000, 0x00111001, 0x00111010, 0x00111011, - 0x00111100, 0x00111101, 0x00111110, 0x00111111, 0x01000000, - 0x01000001, 0x01000010, 0x01000011, 0x01000100, 0x01000101, - 0x01000110, 0x01000111, 0x01001000, 0x01001001, 0x01001010, - 0x01001011, 0x01001100, 0x01001101, 0x01001110, 0x01001111, - 0x01010000, 0x01010001, 0x01010010, 0x01010011, 0x01010100, - 0x01010101, 0x01010110, 0x01010111, 0x01011000, 0x01011001, - 0x01011010, 0x01011011, 0x01011100, 0x01011101, 0x01011110, - 0x01011111, 0x01100000, 0x01100001, 0x01100010, 0x01100011, - 0x01100100, 0x01100101, 0x01100110, 0x01100111, 0x01101000, - 0x01101001, 0x01101010, 0x01101011, 0x01101100, 0x01101101, - 0x01101110, 0x01101111, 0x01110000, 0x01110001, 0x01110010, - 0x01110011, 0x01110100, 0x01110101, 0x01110110, 0x01110111, - 0x01111000, 0x01111001, 0x01111010, 0x01111011, 0x01111100, - 0x01111101, 0x01111110, 0x01111111, 0x10000000, 0x10000001, - 0x10000010, 0x10000011, 0x10000100, 0x10000101, 0x10000110, - 0x10000111, 0x10001000, 0x10001001, 0x10001010, 0x10001011, - 0x10001100, 0x10001101, 0x10001110, 0x10001111, 0x10010000, - 0x10010001, 0x10010010, 0x10010011, 0x10010100, 0x10010101, - 0x10010110, 0x10010111, 0x10011000, 0x10011001, 0x10011010, - 0x10011011, 0x10011100, 0x10011101, 0x10011110, 0x10011111, - 0x10100000, 0x10100001, 0x10100010, 0x10100011, 0x10100100, - 0x10100101, 0x10100110, 0x10100111, 0x10101000, 0x10101001, - 0x10101010, 0x10101011, 0x10101100, 0x10101101, 0x10101110, - 0x10101111, 0x10110000, 0x10110001, 0x10110010, 0x10110011, - 0x10110100, 0x10110101, 0x10110110, 0x10110111, 0x10111000, - 0x10111001, 0x10111010, 0x10111011, 0x10111100, 0x10111101, - 0x10111110, 0x10111111, 0x11000000, 0x11000001, 0x11000010, - 0x11000011, 0x11000100, 0x11000101, 0x11000110, 0x11000111, - 0x11001000, 0x11001001, 0x11001010, 0x11001011, 0x11001100, - 0x11001101, 0x11001110, 0x11001111, 0x11010000, 0x11010001, - 0x11010010, 0x11010011, 0x11010100, 0x11010101, 0x11010110, - 0x11010111, 0x11011000, 0x11011001, 0x11011010, 0x11011011, - 0x11011100, 0x11011101, 0x11011110, 0x11011111, 0x11100000, - 0x11100001, 0x11100010, 0x11100011, 0x11100100, 0x11100101, - 0x11100110, 0x11100111, 0x11101000, 0x11101001, 0x11101010, - 0x11101011, 0x11101100, 0x11101101, 0x11101110, 0x11101111, - 0x11110000, 0x11110001, 0x11110010, 0x11110011, 0x11110100, - 0x11110101, 0x11110110, 0x11110111, 0x11111000, 0x11111001, - 0x11111010, 0x11111011, 0x11111100, 0x11111101, 0x11111110, - 0x11111111 -}; - -static u32 unpack_icon_lut_flipx[256] = { - 0x00000000, 0x10000000, 0x01000000, 0x11000000, 0x00100000, - 0x10100000, 0x01100000, 0x11100000, 0x00010000, 0x10010000, - 0x01010000, 0x11010000, 0x00110000, 0x10110000, 0x01110000, - 0x11110000, 0x00001000, 0x10001000, 0x01001000, 0x11001000, - 0x00101000, 0x10101000, 0x01101000, 0x11101000, 0x00011000, - 0x10011000, 0x01011000, 0x11011000, 0x00111000, 0x10111000, - 0x01111000, 0x11111000, 0x00000100, 0x10000100, 0x01000100, - 0x11000100, 0x00100100, 0x10100100, 0x01100100, 0x11100100, - 0x00010100, 0x10010100, 0x01010100, 0x11010100, 0x00110100, - 0x10110100, 0x01110100, 0x11110100, 0x00001100, 0x10001100, - 0x01001100, 0x11001100, 0x00101100, 0x10101100, 0x01101100, - 0x11101100, 0x00011100, 0x10011100, 0x01011100, 0x11011100, - 0x00111100, 0x10111100, 0x01111100, 0x11111100, 0x00000010, - 0x10000010, 0x01000010, 0x11000010, 0x00100010, 0x10100010, - 0x01100010, 0x11100010, 0x00010010, 0x10010010, 0x01010010, - 0x11010010, 0x00110010, 0x10110010, 0x01110010, 0x11110010, - 0x00001010, 0x10001010, 0x01001010, 0x11001010, 0x00101010, - 0x10101010, 0x01101010, 0x11101010, 0x00011010, 0x10011010, - 0x01011010, 0x11011010, 0x00111010, 0x10111010, 0x01111010, - 0x11111010, 0x00000110, 0x10000110, 0x01000110, 0x11000110, - 0x00100110, 0x10100110, 0x01100110, 0x11100110, 0x00010110, - 0x10010110, 0x01010110, 0x11010110, 0x00110110, 0x10110110, - 0x01110110, 0x11110110, 0x00001110, 0x10001110, 0x01001110, - 0x11001110, 0x00101110, 0x10101110, 0x01101110, 0x11101110, - 0x00011110, 0x10011110, 0x01011110, 0x11011110, 0x00111110, - 0x10111110, 0x01111110, 0x11111110, 0x00000001, 0x10000001, - 0x01000001, 0x11000001, 0x00100001, 0x10100001, 0x01100001, - 0x11100001, 0x00010001, 0x10010001, 0x01010001, 0x11010001, - 0x00110001, 0x10110001, 0x01110001, 0x11110001, 0x00001001, - 0x10001001, 0x01001001, 0x11001001, 0x00101001, 0x10101001, - 0x01101001, 0x11101001, 0x00011001, 0x10011001, 0x01011001, - 0x11011001, 0x00111001, 0x10111001, 0x01111001, 0x11111001, - 0x00000101, 0x10000101, 0x01000101, 0x11000101, 0x00100101, - 0x10100101, 0x01100101, 0x11100101, 0x00010101, 0x10010101, - 0x01010101, 0x11010101, 0x00110101, 0x10110101, 0x01110101, - 0x11110101, 0x00001101, 0x10001101, 0x01001101, 0x11001101, - 0x00101101, 0x10101101, 0x01101101, 0x11101101, 0x00011101, - 0x10011101, 0x01011101, 0x11011101, 0x00111101, 0x10111101, - 0x01111101, 0x11111101, 0x00000011, 0x10000011, 0x01000011, - 0x11000011, 0x00100011, 0x10100011, 0x01100011, 0x11100011, - 0x00010011, 0x10010011, 0x01010011, 0x11010011, 0x00110011, - 0x10110011, 0x01110011, 0x11110011, 0x00001011, 0x10001011, - 0x01001011, 0x11001011, 0x00101011, 0x10101011, 0x01101011, - 0x11101011, 0x00011011, 0x10011011, 0x01011011, 0x11011011, - 0x00111011, 0x10111011, 0x01111011, 0x11111011, 0x00000111, - 0x10000111, 0x01000111, 0x11000111, 0x00100111, 0x10100111, - 0x01100111, 0x11100111, 0x00010111, 0x10010111, 0x01010111, - 0x11010111, 0x00110111, 0x10110111, 0x01110111, 0x11110111, - 0x00001111, 0x10001111, 0x01001111, 0x11001111, 0x00101111, - 0x10101111, 0x01101111, 0x11101111, 0x00011111, 0x10011111, - 0x01011111, 0x11011111, 0x00111111, 0x10111111, 0x01111111, - 0x11111111 -}; - -static u32 dirty_tiles[21] = {0}; - -void -putcolors(u8 *addr) { - int i; - for(i = 0; i < 4; ++i) { - u8 - r = (*(addr + i / 2) >> (!(i % 2) << 2)) & 0x0f, - g = (*(addr + 2 + i / 2) >> (!(i % 2) << 2)) & 0x0f, - b = (*(addr + 4 + i / 2) >> (!(i % 2) << 2)) & 0x0f; - PAL_BUFFER_BG[i] = rgb15( - (r << 1) | (r >> 3), - (g << 1) | (g >> 3), - (b << 1) | (b >> 3)); - for (size_t j = 0; j < 16; ++j) { - PAL_BUFFER_SPRITES[i * 16 + j] = rgb15( - (r << 1) | (r >> 3), - (g << 1) | (g >> 3), - (b << 1) | (b >> 3)); - } - } -} - -IWRAM_CODE -void -putpixel(u32 *layer, u16 x, u16 y, u8 color) { - if (x >= SCREEN_WIDTH || y >= SCREEN_HEIGHT) return; - size_t tile_x = x / 8; - size_t tile_y = y / 8; - size_t start_col = x % 8; - size_t start_row = y % 8; - size_t pos = (start_row + ((tile_x + tile_y * 32) * 8)); - size_t shift = start_col * 4; - layer[pos] = (layer[pos] & (~(0xF << shift))) | (color << shift); - dirty_tiles[tile_y] |= 1 << tile_x; -} - -IWRAM_CODE -void -puticn(u32 *layer, u16 x, u16 y, u8 *sprite, u8 color, u8 flipx, u8 flipy) { - u8 sprline; - u16 v; - u32 dirtyflag = (1 << (x >> 3)) | (1 << ((x + 7) >> 3)); - - u32 layerpos = ((y & 7) + (((x >> 3) + (y >> 3) * 32) * 8)); - u32 *layerptr = &layer[layerpos]; - u32 shift = (x & 7) << 2; - u32 *lut_expand = flipx ? unpack_icon_lut : unpack_icon_lut_flipx; - - if (flipy) flipy = 7; - - if (x >= SCREEN_WIDTH || y >= SCREEN_HEIGHT) return; - - if (color != 0x05 && color != 0x0a && color != 0x0f) { - u64 mask = ~((u64)0xFFFFFFFF << shift); - - for (v = 0; v < 8; v++, layerptr++) { - if ((y + v) >= SCREEN_HEIGHT) break; - - sprline = sprite[v ^ flipy]; - u64 data = (u64)(lut_expand[sprline] * (color & 3)) << shift; - data |= (u64)(lut_expand[sprline ^ 0xFF] * (color >> 2)) << shift; - - layerptr[0] = (layerptr[0] & mask) | data; - layerptr[8] = (layerptr[8] & (mask >> 32)) | (data >> 32); - - if (((y + v) & 7) == 7) layerptr += (32 - 1) * 8; - } - } else { - for (v = 0; v < 8; v++, layerptr++) { - if ((y + v) >= SCREEN_HEIGHT) break; - - sprline = sprite[v ^ flipy]; - u64 mask = ~((u64)(lut_expand[sprline] * 0xF) << shift); - u64 data = (u64)(lut_expand[sprline] * (color & 3)) << shift; - - layerptr[0] = (layerptr[0] & mask) | data; - layerptr[8] = (layerptr[8] & (mask >> 32)) | (data >> 32); - - if (((y + v) & 7) == 7) layerptr += (32 - 1) * 8; - } - } - - dirty_tiles[y >> 3] |= dirtyflag; - dirty_tiles[(y + 7) >> 3] |= dirtyflag; -} - -IWRAM_CODE -void -putfontchar(u32 *layer, u16 tile_x, u16 tile_y, u8 ch, u8 color) { - u32 pos = (tile_x + tile_y * 32) * 8; - u32 *tile_data = &layer[pos]; - u32 *font_data = &FONT_DATA[8 * ch]; - for (size_t i = 0; i < 8; ++i) { - tile_data[i] = font_data[i] * color; - } - dirty_tiles[tile_y] |= 1 << tile_x; -} - -IWRAM_CODE -void -putchr(u32 *layer, u16 x, u16 y, u8 *sprite, u8 color, - u8 flipx, u8 flipy) { - u8 sprline1, sprline2; - u16 v; - u32 dirtyflag = (1 << (x >> 3)) | (1 << ((x + 7) >> 3)); - - u32 layerpos = ((y & 7) + (((x >> 3) + (y >> 3) * 32) * 8)); - u32 *layerptr = &layer[layerpos]; - u32 shift = (x & 7) << 2; - u32 *lut_expand = flipx ? unpack_icon_lut : unpack_icon_lut_flipx; - - if (flipy) flipy = 7; - - if (x >= SCREEN_WIDTH || y >= SCREEN_HEIGHT) return; - - u64 mask = ~((u64)0xFFFFFFFF << shift); - u32 colconst = (color >> 2) * 0x11111111; - - for (v = 0; v < 8; v++, layerptr++) { - if ((y + v) >= SCREEN_HEIGHT) break; - - sprline1 = sprite[v ^ flipy]; - sprline2 = sprite[(v ^ flipy) | 8]; - - u32 data32 = - (lut_expand[sprline1] * (color & 3)) - + (lut_expand[sprline2] * ((color & 1) << 1)) - + colconst; - u64 data = ((u64) (data32 & 0x33333333)) << shift; - - layerptr[0] = (layerptr[0] & mask) | data; - layerptr[8] = (layerptr[8] & (mask >> 32)) | (data >> 32); - - if (((y + v) & 7) == 7) layerptr += (32 - 1) * 8; - } - - dirty_tiles[y >> 3] |= dirtyflag; - dirty_tiles[(y + 7) >> 3] |= dirtyflag; -} - -IWRAM_CODE -void -flipbuf(Ppu *p) { - Tile *mem_fg = FG_FRONT; - Tile *mem_bg = BG_FRONT; - for (size_t j = 0; j < 20; ++j) { - if (dirty_tiles[j] == 0) { - continue; - } - - size_t k = 1; - for (size_t i = 0; i < 30; ++i, k <<= 1) { - if (dirty_tiles[j] & k) { - Tile *tile_fg = p->fg; - Tile *tile_bg = p->bg; - mem_fg[i + j * 32] = tile_fg[i + j * 32]; - mem_bg[i + j * 32] = tile_bg[i + j * 32]; - } - } - dirty_tiles[j] = 0; - } -} - -typedef struct KeyboardChar { - int x; - int y; - u8 symbol; -} KeyboardChar; - -static u8 cursor_position = 0; - -#define KEYBOARD_ROW_SIZE 12 -#define KEYBOARD_START_TILE_X (30 / 2 - KEYBOARD_ROW_SIZE / 2) -#define KEYBOARD_START_TILE_Y (20 / 2 - 3) - -KeyboardChar keyboard[] = { - {0, 0, '!'}, {0, 0, '?'}, {0, 0, '@'}, {0, 0, '#'}, {0, 0, '$'}, {0, 0, '%'}, {0, 0, '^'}, {0, 0, '&'}, {0, 0, '*'}, {0, 0, '"'}, {0, 0, '\''}, {0, 0, 0x7f}, - {0, 0, '('}, {0, 0, ')'}, {0, 0, '['}, {0, 0, ']'}, {0, 0, '{'}, {0, 0, '}'}, {0, 0, '<'}, {0, 0, '>'}, {0, 0, '+'}, {0, 0, '-'}, {0, 0, '='}, {0, 0, 0x14}, - {0, 0, '0'}, {0, 0, '1'}, {0, 0, '2'}, {0, 0, '3'}, {0, 0, '4'}, {0, 0, '5'}, {0, 0, '6'}, {0, 0, '7'}, {0, 0, '8'}, {0, 0, '9'}, {0, 0, '~'}, {0, 0, 0x18}, - {0, 0, 'a'}, {0, 0, 'b'}, {0, 0, 'c'}, {0, 0, 'd'}, {0, 0, 'e'}, {0, 0, 'f'}, {0, 0, 'g'}, {0, 0, 'h'}, {0, 0, 'i'}, {0, 0, 'j'}, {0, 0, '/'}, {0, 0, 0x19}, - {0, 0, 'k'}, {0, 0, 'l'}, {0, 0, 'm'}, {0, 0, 'n'}, {0, 0, 'o'}, {0, 0, 'p'}, {0, 0, 'q'}, {0, 0, 'r'}, {0, 0, 's'}, {0, 0, 't'}, {0, 0, '\\'}, {0, 0, 0x1b}, - {0, 0, 'u'}, {0, 0, 'v'}, {0, 0, 'w'}, {0, 0, 'x'}, {0, 0, 'y'}, {0, 0, 'z'}, {0, 0, ','}, {0, 0, '.'}, {0, 0, ';'}, {0, 0, ':'}, {0, 0, '_'}, {0, 0, 0x1a}, -}; - -void -toggle_keyboard(void) { - for (size_t i = 0; i < LEN(keyboard); ++i) { - OBJ_ATTR_0(i) ^= OBJ_HIDDEN; - } - OBJ_ATTR_0(127) ^= OBJ_HIDDEN; -} - -void -update_cursor(u8 pos) { - cursor_position = CLAMP(pos, 0, LEN(keyboard) - 1); - OBJ_ATTR_0(127) = (OBJ_ATTR_0(127) & ~0xFF) - | OBJ_Y_COORD(keyboard[cursor_position].y); - OBJ_ATTR_1(127) = (OBJ_ATTR_0(127) & ~0x1FF) - | OBJ_X_COORD(keyboard[cursor_position].x); -} - -int -initppu(Ppu *p, u8 hor, u8 ver, u8 pad) { - p->hor = hor; - p->ver = ver; - p->pad = pad; - p->width = (8 * p->hor + p->pad * 2); - p->height = (8 * p->ver + p->pad * 2); - - // Initialize display mode and bg palette. - DISP_CTRL = DISP_MODE_0 | DISP_BG_0 | DISP_BG_1 | DISP_OBJ; - - // Initialize backgrounds. - u8 cb_fg = 0; - u8 cb_bg = 1; - u8 sb_fg = 20; - u8 sb_bg = 21; - BG_CTRL(0) = BG_CHARBLOCK(cb_fg) | BG_SCREENBLOCK(sb_fg) | BG_PRIORITY(1); - BG_CTRL(1) = BG_CHARBLOCK(cb_bg) | BG_SCREENBLOCK(sb_bg) | BG_PRIORITY(2); - - // Clear front buffer. - p->fg = FG_FRONT; - p->bg = BG_FRONT; - - // Use DMA to clear VRAM. - u32 fill = 0; - dma_fill(p->fg, fill, KB(20), 3); - dma_fill(p->bg, fill, KB(20), 3); - - // Clear back buffer. - p->fg = FG_BACK; - p->bg = BG_BACK; - dma_fill(p->fg, fill, KB(20), 3); - dma_fill(p->bg, fill, KB(20), 3); - - // Initialize default palette. - PAL_BUFFER_BG[0] = COLOR_BLACK; - PAL_BUFFER_BG[1] = COLOR_WHITE; - PAL_BUFFER_BG[2] = COLOR_RED; - PAL_BUFFER_BG[3] = COLOR_BLUE; - for (size_t i = 0; i < 16; ++i) { - PAL_BUFFER_SPRITES[i] = COLOR_BLACK; - PAL_BUFFER_SPRITES[1 * 16] = COLOR_WHITE; - PAL_BUFFER_SPRITES[2 * 16] = COLOR_RED; - PAL_BUFFER_SPRITES[3 * 16] = COLOR_BLUE; - } - - // Initialize background memory map. - u16 *mem_map_fg = SCREENBLOCK_MEM[sb_fg]; - u16 *mem_map_bg = SCREENBLOCK_MEM[sb_bg]; - size_t k = 0; - for (size_t i = 0; i < 32 * 20; ++i, ++k) { - mem_map_fg[i] = k; - mem_map_bg[i] = k + 32 * 4; - } - - // Load font data into VRAM. - unpack_tiles(&bd_font, FONT_DATA, 256); - - // Initialize keyboard sprites. - int tile_x = KEYBOARD_START_TILE_X; - int tile_y = KEYBOARD_START_TILE_Y; - for (size_t i = 0; i < sizeof(keyboard) / sizeof(keyboard[0]); ++i) { - keyboard[i].x = tile_x * 8; - keyboard[i].y = tile_y * 8; - OBJ_ATTR_0(i) = OBJ_SHAPE_SQUARE | OBJ_Y_COORD(keyboard[i].y) | OBJ_HIDDEN; - OBJ_ATTR_1(i) = OBJ_SIZE_SMALL | OBJ_X_COORD(keyboard[i].x); - OBJ_ATTR_2(i) = (SPRITE_START_IDX + keyboard[i].symbol) | OBJ_PAL_BANK(0); - tile_x++; - if (tile_x - KEYBOARD_START_TILE_X >= KEYBOARD_ROW_SIZE) { - tile_x = KEYBOARD_START_TILE_X; - tile_y++; - } - } - OBJ_ATTR_0(127) = OBJ_SHAPE_SQUARE | OBJ_Y_COORD(keyboard[cursor_position].y) | OBJ_HIDDEN; - OBJ_ATTR_1(127) = OBJ_SIZE_SMALL | OBJ_X_COORD(keyboard[cursor_position].x); - OBJ_ATTR_2(127) = (SPRITE_START_IDX + 0xdb) | OBJ_PAL_BANK(3); - - return 1; -} diff --git a/src/uxn/devices/ppu.h b/src/uxn/devices/ppu.h deleted file mode 100644 index 0356b63..0000000 --- a/src/uxn/devices/ppu.h +++ /dev/null @@ -1,30 +0,0 @@ -#ifndef UXNGBA_PPU_H -#define UXNGBA_PPU_H - -#include -#include - -/* -Copyright (c) 2021 Devine Lu Linvega -Copyright (c) 2021 Andrew Alderwick -Copyright (c) 2021 Bad Diode - -Permission to use, copy, modify, and distribute this software for any -purpose with or without fee is hereby granted, provided that the above -copyright notice and this permission notice appear in all copies. - -THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES -WITH REGARD TO THIS SOFTWARE. -*/ - -typedef struct Ppu { - u32 *bg, *fg; - u16 hor, ver, pad, width, height; -} Ppu; - -int initppu(Ppu *p, u8 hor, u8 ver, u8 pad); -void putcolors(u8 *addr); -void putpixel(u32 *layer, u16 x, u16 y, u8 color); -void puticn(u32 *layer, u16 x, u16 y, u8 *sprite, u8 color, u8 flipx, u8 flipy); -void putchr(u32 *layer, u16 x, u16 y, u8 *sprite, u8 color, u8 flipx, u8 flipy); -#endif // UXNGBA_PPU_H diff --git a/src/uxn/uxn.c b/src/uxn/uxn.c deleted file mode 100644 index d6da3b9..0000000 --- a/src/uxn/uxn.c +++ /dev/null @@ -1,3956 +0,0 @@ -#include -#include "uxn.h" - -#define NO_STACK_CHECKS - -/* -Copyright (u) 2021 Devine Lu Linvega -Copyright (u) 2021 Andrew Alderwick - -Permission to use, copy, modify, and distribute this software for any -purpose with or without fee is hereby granted, provided that the above -copyright notice and this permission notice appear in all copies. - -THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES -WITH REGARD TO THIS SOFTWARE. -*/ - -IWRAM_CODE -int -evaluxn(Uxn *u, u16 vec) -{ - u8 instr; - u->ram.ptr = vec; - while(u->ram.ptr) { - instr = u->ram.dat[u->ram.ptr++]; - switch(instr) { -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-value" -#pragma GCC diagnostic ignored "-Wunused-variable" - case 0x00: /* BRK */ - case 0x20: /* BRK2 */ - case 0x40: /* BRKr */ - case 0x60: /* BRK2r */ - case 0x80: /* BRKk */ - case 0xa0: /* BRK2k */ - case 0xc0: /* BRKkr */ - case 0xe0: /* BRK2kr */ - __asm__( "evaluxn_00_BRK:" ); - { - u->ram.ptr = 0; - } - break; - case 0x01: /* LIT */ - case 0x81: /* LITk */ - __asm__( "evaluxn_01_LIT:" ); - { - u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x02: /* NOP */ - case 0x22: /* NOP2 */ - case 0x42: /* NOPr */ - case 0x62: /* NOP2r */ - case 0x82: /* NOPk */ - case 0xa2: /* NOP2k */ - case 0xc2: /* NOPkr */ - case 0xe2: /* NOP2kr */ - __asm__( "evaluxn_02_NOP:" ); - { - (void)u; - } - break; - case 0x03: /* POP */ - __asm__( "evaluxn_03_POP:" ); - { - u->wst.dat[u->wst.ptr - 1]; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x04: /* DUP */ - __asm__( "evaluxn_04_DUP:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x05: /* SWP */ - __asm__( "evaluxn_05_SWP:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = a; - u->wst.dat[u->wst.ptr - 1] = b; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x06: /* OVR */ - __asm__( "evaluxn_06_OVR:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x07: /* ROT */ - __asm__( "evaluxn_07_ROT:" ); - { - 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]; - u->wst.dat[u->wst.ptr - 3] = b; - u->wst.dat[u->wst.ptr - 2] = a; - u->wst.dat[u->wst.ptr - 1] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x08: /* EQU */ - __asm__( "evaluxn_08_EQU:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b == a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x09: /* NEQ */ - __asm__( "evaluxn_09_NEQ:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b != a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x0a: /* GTH */ - __asm__( "evaluxn_0a_GTH:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b > a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x0b: /* LTH */ - __asm__( "evaluxn_0b_LTH:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b < a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x0c: /* JMP */ - __asm__( "evaluxn_0c_JMP:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x0d: /* JCN */ - __asm__( "evaluxn_0d_JCN:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - if(u->wst.dat[u->wst.ptr - 2]) u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x0e: /* JSR */ - __asm__( "evaluxn_0e_JSR:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8; - u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff; - u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0x0f: /* STH */ - __asm__( "evaluxn_0f_STH:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->rst.dat[u->rst.ptr] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0x10: /* LDZ */ - __asm__( "evaluxn_10_LDZ:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x11: /* STZ */ - __asm__( "evaluxn_11_STZ:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u8 b = u->wst.dat[u->wst.ptr - 2]; - mempoke8(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x12: /* LDR */ - __asm__( "evaluxn_12_LDR:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x13: /* STR */ - __asm__( "evaluxn_13_STR:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u8 b = u->wst.dat[u->wst.ptr - 2]; - mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x14: /* LDA */ - __asm__( "evaluxn_14_LDA:" ); - { - u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); - u->wst.dat[u->wst.ptr - 2] = mempeek8(u->ram.dat, a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x15: /* STA */ - __asm__( "evaluxn_15_STA:" ); - { - u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); - u8 b = u->wst.dat[u->wst.ptr - 3]; - mempoke8(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 3; - } - break; - case 0x16: /* DEI */ - __asm__( "evaluxn_16_DEI:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr - 1] = devpeek8(&u->dev[a >> 4], a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x17: /* DEO */ - __asm__( "evaluxn_17_DEO:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - devpoke8(&u->dev[a >> 4], a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x18: /* ADD */ - __asm__( "evaluxn_18_ADD:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b + a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x19: /* SUB */ - __asm__( "evaluxn_19_SUB:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b - a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x1a: /* MUL */ - __asm__( "evaluxn_1a_MUL:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b * a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x1b: /* DIV */ - __asm__( "evaluxn_1b_DIV:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b / a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x1c: /* AND */ - __asm__( "evaluxn_1c_AND:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b & a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x1d: /* ORA */ - __asm__( "evaluxn_1d_ORA:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b | a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x1e: /* EOR */ - __asm__( "evaluxn_1e_EOR:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b ^ a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x1f: /* SFT */ - __asm__( "evaluxn_1f_SFT:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr - 2] = b >> (a & 0x07) << ((a & 0x70) >> 4); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x21: /* LIT2 */ - case 0xa1: /* LIT2k */ - __asm__( "evaluxn_21_LIT2:" ); - { - u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++); - u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr++); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0x23: /* POP2 */ - __asm__( "evaluxn_23_POP2:" ); - { - (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x24: /* DUP2 */ - __asm__( "evaluxn_24_DUP2:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b; - u->wst.dat[u->wst.ptr + 1] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0x25: /* SWP2 */ - __asm__( "evaluxn_25_SWP2:" ); - { - 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]; - u->wst.dat[u->wst.ptr - 4] = b; - u->wst.dat[u->wst.ptr - 3] = a; - u->wst.dat[u->wst.ptr - 2] = d; - u->wst.dat[u->wst.ptr - 1] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x26: /* OVR2 */ - __asm__( "evaluxn_26_OVR2:" ); - { - 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]; - u->wst.dat[u->wst.ptr] = d; - u->wst.dat[u->wst.ptr + 1] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0x27: /* ROT2 */ - __asm__( "evaluxn_27_ROT2:" ); - { - 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]; - u->wst.dat[u->wst.ptr - 6] = d; - u->wst.dat[u->wst.ptr - 5] = c; - u->wst.dat[u->wst.ptr - 4] = b; - u->wst.dat[u->wst.ptr - 3] = a; - u->wst.dat[u->wst.ptr - 2] = f; - u->wst.dat[u->wst.ptr - 1] = e; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 6, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x28: /* EQU2 */ - __asm__( "evaluxn_28_EQU2:" ); - { - 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)); - u->wst.dat[u->wst.ptr - 4] = b == a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 3; - } - break; - case 0x29: /* NEQ2 */ - __asm__( "evaluxn_29_NEQ2:" ); - { - 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)); - u->wst.dat[u->wst.ptr - 4] = b != a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 3; - } - break; - case 0x2a: /* GTH2 */ - __asm__( "evaluxn_2a_GTH2:" ); - { - 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)); - u->wst.dat[u->wst.ptr - 4] = b > a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 3; - } - break; - case 0x2b: /* LTH2 */ - __asm__( "evaluxn_2b_LTH2:" ); - { - 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)); - u->wst.dat[u->wst.ptr - 4] = b < a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 3; - } - break; - case 0x2c: /* JMP2 */ - __asm__( "evaluxn_2c_JMP2:" ); - { - u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x2d: /* JCN2 */ - __asm__( "evaluxn_2d_JCN2:" ); - { - u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); - if(u->wst.dat[u->wst.ptr - 3]) u->ram.ptr = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 3; - } - break; - case 0x2e: /* JSR2 */ - __asm__( "evaluxn_2e_JSR2:" ); - { - u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8; - u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff; - u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0x2f: /* STH2 */ - __asm__( "evaluxn_2f_STH2:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b; - u->rst.dat[u->rst.ptr + 1] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0x30: /* LDZ2 */ - __asm__( "evaluxn_30_LDZ2:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, a); - u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x31: /* STZ2 */ - __asm__( "evaluxn_31_STZ2:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); - mempoke16(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 3; - } - break; - case 0x32: /* LDR2 */ - __asm__( "evaluxn_32_LDR2:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); - u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x33: /* STR2 */ - __asm__( "evaluxn_33_STR2:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); - mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 3; - } - break; - case 0x34: /* LDA2 */ - __asm__( "evaluxn_34_LDA2:" ); - { - u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); - u->wst.dat[u->wst.ptr - 2] = mempeek8(u->ram.dat, a); - u->wst.dat[u->wst.ptr - 1] = mempeek8(u->ram.dat, a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x35: /* STA2 */ - __asm__( "evaluxn_35_STA2:" ); - { - u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); - u16 b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8)); - mempoke16(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 4; - } - break; - case 0x36: /* DEI2 */ - __asm__( "evaluxn_36_DEI2:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr - 1] = devpeek8(&u->dev[a >> 4], a); - u->wst.dat[u->wst.ptr] = devpeek8(&u->dev[a >> 4], a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x37: /* DEO2 */ - __asm__( "evaluxn_37_DEO2:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); - devpoke16(&u->dev[a >> 4], a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 3; - } - break; - case 0x38: /* ADD2 */ - __asm__( "evaluxn_38_ADD2:" ); - { - 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)); - u->wst.dat[u->wst.ptr - 4] = (b + a) >> 8; - u->wst.dat[u->wst.ptr - 3] = (b + a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x39: /* SUB2 */ - __asm__( "evaluxn_39_SUB2:" ); - { - 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)); - u->wst.dat[u->wst.ptr - 4] = (b - a) >> 8; - u->wst.dat[u->wst.ptr - 3] = (b - a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x3a: /* MUL2 */ - __asm__( "evaluxn_3a_MUL2:" ); - { - 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)); - u->wst.dat[u->wst.ptr - 4] = (b * a) >> 8; - u->wst.dat[u->wst.ptr - 3] = (b * a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x3b: /* DIV2 */ - __asm__( "evaluxn_3b_DIV2:" ); - { - 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)); - u->wst.dat[u->wst.ptr - 4] = (b / a) >> 8; - u->wst.dat[u->wst.ptr - 3] = (b / a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x3c: /* AND2 */ - __asm__( "evaluxn_3c_AND2:" ); - { - 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]; - u->wst.dat[u->wst.ptr - 4] = d & b; - u->wst.dat[u->wst.ptr - 3] = c & a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x3d: /* ORA2 */ - __asm__( "evaluxn_3d_ORA2:" ); - { - 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]; - u->wst.dat[u->wst.ptr - 4] = d | b; - u->wst.dat[u->wst.ptr - 3] = c | a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x3e: /* EOR2 */ - __asm__( "evaluxn_3e_EOR2:" ); - { - 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]; - u->wst.dat[u->wst.ptr - 4] = d ^ b; - u->wst.dat[u->wst.ptr - 3] = c ^ a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 2; - } - break; - case 0x3f: /* SFT2 */ - __asm__( "evaluxn_3f_SFT2:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); - u->wst.dat[u->wst.ptr - 3] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8; - u->wst.dat[u->wst.ptr - 2] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - u->wst.ptr -= 1; - } - break; - case 0x41: /* LITr */ - case 0xc1: /* LITkr */ - __asm__( "evaluxn_41_LITr:" ); - { - u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0x43: /* POPr */ - __asm__( "evaluxn_43_POPr:" ); - { - u->rst.dat[u->rst.ptr - 1]; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x44: /* DUPr */ - __asm__( "evaluxn_44_DUPr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0x45: /* SWPr */ - __asm__( "evaluxn_45_SWPr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = a; - u->rst.dat[u->rst.ptr - 1] = b; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0x46: /* OVRr */ - __asm__( "evaluxn_46_OVRr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0x47: /* ROTr */ - __asm__( "evaluxn_47_ROTr:" ); - { - 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]; - u->rst.dat[u->rst.ptr - 3] = b; - u->rst.dat[u->rst.ptr - 2] = a; - u->rst.dat[u->rst.ptr - 1] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0x48: /* EQUr */ - __asm__( "evaluxn_48_EQUr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b == a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x49: /* NEQr */ - __asm__( "evaluxn_49_NEQr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b != a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x4a: /* GTHr */ - __asm__( "evaluxn_4a_GTHr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b > a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x4b: /* LTHr */ - __asm__( "evaluxn_4b_LTHr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b < a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x4c: /* JMPr */ - __asm__( "evaluxn_4c_JMPr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x4d: /* JCNr */ - __asm__( "evaluxn_4d_JCNr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - if(u->rst.dat[u->rst.ptr - 2]) u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x4e: /* JSRr */ - __asm__( "evaluxn_4e_JSRr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8; - u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff; - u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0x4f: /* STHr */ - __asm__( "evaluxn_4f_STHr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->wst.dat[u->wst.ptr] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x50: /* LDZr */ - __asm__( "evaluxn_50_LDZr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0x51: /* STZr */ - __asm__( "evaluxn_51_STZr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u8 b = u->rst.dat[u->rst.ptr - 2]; - mempoke8(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x52: /* LDRr */ - __asm__( "evaluxn_52_LDRr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0x53: /* STRr */ - __asm__( "evaluxn_53_STRr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u8 b = u->rst.dat[u->rst.ptr - 2]; - mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x54: /* LDAr */ - __asm__( "evaluxn_54_LDAr:" ); - { - u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); - u->rst.dat[u->rst.ptr - 2] = mempeek8(u->ram.dat, a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x55: /* STAr */ - __asm__( "evaluxn_55_STAr:" ); - { - u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); - u8 b = u->rst.dat[u->rst.ptr - 3]; - mempoke8(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 3; - } - break; - case 0x56: /* DEIr */ - __asm__( "evaluxn_56_DEIr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr - 1] = devpeek8(&u->dev[a >> 4], a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0x57: /* DEOr */ - __asm__( "evaluxn_57_DEOr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - devpoke8(&u->dev[a >> 4], a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x58: /* ADDr */ - __asm__( "evaluxn_58_ADDr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b + a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x59: /* SUBr */ - __asm__( "evaluxn_59_SUBr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b - a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x5a: /* MULr */ - __asm__( "evaluxn_5a_MULr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b * a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x5b: /* DIVr */ - __asm__( "evaluxn_5b_DIVr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b / a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x5c: /* ANDr */ - __asm__( "evaluxn_5c_ANDr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b & a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x5d: /* ORAr */ - __asm__( "evaluxn_5d_ORAr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b | a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x5e: /* EORr */ - __asm__( "evaluxn_5e_EORr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b ^ a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x5f: /* SFTr */ - __asm__( "evaluxn_5f_SFTr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr - 2] = b >> (a & 0x07) << ((a & 0x70) >> 4); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x61: /* LIT2r */ - case 0xe1: /* LIT2kr */ - __asm__( "evaluxn_61_LIT2r:" ); - { - u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr++); - u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr++); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0x63: /* POP2r */ - __asm__( "evaluxn_63_POP2r:" ); - { - (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x64: /* DUP2r */ - __asm__( "evaluxn_64_DUP2r:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b; - u->rst.dat[u->rst.ptr + 1] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0x65: /* SWP2r */ - __asm__( "evaluxn_65_SWP2r:" ); - { - 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]; - u->rst.dat[u->rst.ptr - 4] = b; - u->rst.dat[u->rst.ptr - 3] = a; - u->rst.dat[u->rst.ptr - 2] = d; - u->rst.dat[u->rst.ptr - 1] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0x66: /* OVR2r */ - __asm__( "evaluxn_66_OVR2r:" ); - { - 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]; - u->rst.dat[u->rst.ptr] = d; - u->rst.dat[u->rst.ptr + 1] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0x67: /* ROT2r */ - __asm__( "evaluxn_67_ROT2r:" ); - { - 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]; - u->rst.dat[u->rst.ptr - 6] = d; - u->rst.dat[u->rst.ptr - 5] = c; - u->rst.dat[u->rst.ptr - 4] = b; - u->rst.dat[u->rst.ptr - 3] = a; - u->rst.dat[u->rst.ptr - 2] = f; - u->rst.dat[u->rst.ptr - 1] = e; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 6, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0x68: /* EQU2r */ - __asm__( "evaluxn_68_EQU2r:" ); - { - 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)); - u->rst.dat[u->rst.ptr - 4] = b == a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 3; - } - break; - case 0x69: /* NEQ2r */ - __asm__( "evaluxn_69_NEQ2r:" ); - { - 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)); - u->rst.dat[u->rst.ptr - 4] = b != a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 3; - } - break; - case 0x6a: /* GTH2r */ - __asm__( "evaluxn_6a_GTH2r:" ); - { - 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)); - u->rst.dat[u->rst.ptr - 4] = b > a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 3; - } - break; - case 0x6b: /* LTH2r */ - __asm__( "evaluxn_6b_LTH2r:" ); - { - 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)); - u->rst.dat[u->rst.ptr - 4] = b < a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 3; - } - break; - case 0x6c: /* JMP2r */ - __asm__( "evaluxn_6c_JMP2r:" ); - { - u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x6d: /* JCN2r */ - __asm__( "evaluxn_6d_JCN2r:" ); - { - u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); - if(u->rst.dat[u->rst.ptr - 3]) u->ram.ptr = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 3; - } - break; - case 0x6e: /* JSR2r */ - __asm__( "evaluxn_6e_JSR2r:" ); - { - u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8; - u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff; - u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0x6f: /* STH2r */ - __asm__( "evaluxn_6f_STH2r:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b; - u->wst.dat[u->wst.ptr + 1] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0x70: /* LDZ2r */ - __asm__( "evaluxn_70_LDZ2r:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, a); - u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0x71: /* STZ2r */ - __asm__( "evaluxn_71_STZ2r:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); - mempoke16(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 3; - } - break; - case 0x72: /* LDR2r */ - __asm__( "evaluxn_72_LDR2r:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); - u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0x73: /* STR2r */ - __asm__( "evaluxn_73_STR2r:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); - mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 3; - } - break; - case 0x74: /* LDA2r */ - __asm__( "evaluxn_74_LDA2r:" ); - { - u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); - u->rst.dat[u->rst.ptr - 2] = mempeek8(u->ram.dat, a); - u->rst.dat[u->rst.ptr - 1] = mempeek8(u->ram.dat, a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0x75: /* STA2r */ - __asm__( "evaluxn_75_STA2r:" ); - { - u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); - u16 b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8)); - mempoke16(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 4; - } - break; - case 0x76: /* DEI2r */ - __asm__( "evaluxn_76_DEI2r:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr - 1] = devpeek8(&u->dev[a >> 4], a); - u->rst.dat[u->rst.ptr] = devpeek8(&u->dev[a >> 4], a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0x77: /* DEO2r */ - __asm__( "evaluxn_77_DEO2r:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); - devpoke16(&u->dev[a >> 4], a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 3; - } - break; - case 0x78: /* ADD2r */ - __asm__( "evaluxn_78_ADD2r:" ); - { - 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)); - u->rst.dat[u->rst.ptr - 4] = (b + a) >> 8; - u->rst.dat[u->rst.ptr - 3] = (b + a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x79: /* SUB2r */ - __asm__( "evaluxn_79_SUB2r:" ); - { - 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)); - u->rst.dat[u->rst.ptr - 4] = (b - a) >> 8; - u->rst.dat[u->rst.ptr - 3] = (b - a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x7a: /* MUL2r */ - __asm__( "evaluxn_7a_MUL2r:" ); - { - 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)); - u->rst.dat[u->rst.ptr - 4] = (b * a) >> 8; - u->rst.dat[u->rst.ptr - 3] = (b * a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x7b: /* DIV2r */ - __asm__( "evaluxn_7b_DIV2r:" ); - { - 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)); - u->rst.dat[u->rst.ptr - 4] = (b / a) >> 8; - u->rst.dat[u->rst.ptr - 3] = (b / a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x7c: /* AND2r */ - __asm__( "evaluxn_7c_AND2r:" ); - { - 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]; - u->rst.dat[u->rst.ptr - 4] = d & b; - u->rst.dat[u->rst.ptr - 3] = c & a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x7d: /* ORA2r */ - __asm__( "evaluxn_7d_ORA2r:" ); - { - 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]; - u->rst.dat[u->rst.ptr - 4] = d | b; - u->rst.dat[u->rst.ptr - 3] = c | a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x7e: /* EOR2r */ - __asm__( "evaluxn_7e_EOR2r:" ); - { - 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]; - u->rst.dat[u->rst.ptr - 4] = d ^ b; - u->rst.dat[u->rst.ptr - 3] = c ^ a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 2; - } - break; - case 0x7f: /* SFT2r */ - __asm__( "evaluxn_7f_SFT2r:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); - u->rst.dat[u->rst.ptr - 3] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8; - u->rst.dat[u->rst.ptr - 2] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - u->rst.ptr -= 1; - } - break; - case 0x83: /* POPk */ - __asm__( "evaluxn_83_POPk:" ); - { - u->wst.dat[u->wst.ptr - 1]; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x84: /* DUPk */ - __asm__( "evaluxn_84_DUPk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr] = a; - u->wst.dat[u->wst.ptr + 1] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0x85: /* SWPk */ - __asm__( "evaluxn_85_SWPk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = a; - u->wst.dat[u->wst.ptr + 1] = b; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0x86: /* OVRk */ - __asm__( "evaluxn_86_OVRk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b; - u->wst.dat[u->wst.ptr + 1] = a; - u->wst.dat[u->wst.ptr + 2] = b; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 252, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 3; - } - break; - case 0x87: /* ROTk */ - __asm__( "evaluxn_87_ROTk:" ); - { - 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]; - u->wst.dat[u->wst.ptr] = b; - u->wst.dat[u->wst.ptr + 1] = a; - u->wst.dat[u->wst.ptr + 2] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 252, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 3; - } - break; - case 0x88: /* EQUk */ - __asm__( "evaluxn_88_EQUk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b == a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x89: /* NEQk */ - __asm__( "evaluxn_89_NEQk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b != a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x8a: /* GTHk */ - __asm__( "evaluxn_8a_GTHk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b > a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x8b: /* LTHk */ - __asm__( "evaluxn_8b_LTHk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b < a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x8c: /* JMPk */ - __asm__( "evaluxn_8c_JMPk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x8d: /* JCNk */ - __asm__( "evaluxn_8d_JCNk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - if(u->wst.dat[u->wst.ptr - 2]) u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x8e: /* JSRk */ - __asm__( "evaluxn_8e_JSRk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8; - u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff; - u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0x8f: /* STHk */ - __asm__( "evaluxn_8f_STHk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->rst.dat[u->rst.ptr] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0x90: /* LDZk */ - __asm__( "evaluxn_90_LDZk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x91: /* STZk */ - __asm__( "evaluxn_91_STZk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u8 b = u->wst.dat[u->wst.ptr - 2]; - mempoke8(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x92: /* LDRk */ - __asm__( "evaluxn_92_LDRk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x93: /* STRk */ - __asm__( "evaluxn_93_STRk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u8 b = u->wst.dat[u->wst.ptr - 2]; - mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x94: /* LDAk */ - __asm__( "evaluxn_94_LDAk:" ); - { - u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); - u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x95: /* STAk */ - __asm__( "evaluxn_95_STAk:" ); - { - u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); - u8 b = u->wst.dat[u->wst.ptr - 3]; - mempoke8(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x96: /* DEIk */ - __asm__( "evaluxn_96_DEIk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr] = devpeek8(&u->dev[a >> 4], a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x97: /* DEOk */ - __asm__( "evaluxn_97_DEOk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - devpoke8(&u->dev[a >> 4], a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0x98: /* ADDk */ - __asm__( "evaluxn_98_ADDk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b + a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x99: /* SUBk */ - __asm__( "evaluxn_99_SUBk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b - a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x9a: /* MULk */ - __asm__( "evaluxn_9a_MULk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b * a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x9b: /* DIVk */ - __asm__( "evaluxn_9b_DIVk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b / a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x9c: /* ANDk */ - __asm__( "evaluxn_9c_ANDk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b & a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x9d: /* ORAk */ - __asm__( "evaluxn_9d_ORAk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b | a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x9e: /* EORk */ - __asm__( "evaluxn_9e_EORk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b ^ a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0x9f: /* SFTk */ - __asm__( "evaluxn_9f_SFTk:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b >> (a & 0x07) << ((a & 0x70) >> 4); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0xa3: /* POP2k */ - __asm__( "evaluxn_a3_POP2k:" ); - { - (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0xa4: /* DUP2k */ - __asm__( "evaluxn_a4_DUP2k:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b; - u->wst.dat[u->wst.ptr + 1] = a; - u->wst.dat[u->wst.ptr + 2] = b; - u->wst.dat[u->wst.ptr + 3] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 251, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 4; - } - break; - case 0xa5: /* SWP2k */ - __asm__( "evaluxn_a5_SWP2k:" ); - { - 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]; - u->wst.dat[u->wst.ptr] = b; - u->wst.dat[u->wst.ptr + 1] = a; - u->wst.dat[u->wst.ptr + 2] = d; - u->wst.dat[u->wst.ptr + 3] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 251, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 4; - } - break; - case 0xa6: /* OVR2k */ - __asm__( "evaluxn_a6_OVR2k:" ); - { - 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]; - u->wst.dat[u->wst.ptr] = d; - u->wst.dat[u->wst.ptr + 1] = c; - u->wst.dat[u->wst.ptr + 2] = b; - u->wst.dat[u->wst.ptr + 3] = a; - u->wst.dat[u->wst.ptr + 4] = d; - u->wst.dat[u->wst.ptr + 5] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 249, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 6; - } - break; - case 0xa7: /* ROT2k */ - __asm__( "evaluxn_a7_ROT2k:" ); - { - 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]; - u->wst.dat[u->wst.ptr] = d; - u->wst.dat[u->wst.ptr + 1] = c; - u->wst.dat[u->wst.ptr + 2] = b; - u->wst.dat[u->wst.ptr + 3] = a; - u->wst.dat[u->wst.ptr + 4] = f; - u->wst.dat[u->wst.ptr + 5] = e; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 6, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 249, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 6; - } - break; - case 0xa8: /* EQU2k */ - __asm__( "evaluxn_a8_EQU2k:" ); - { - 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)); - u->wst.dat[u->wst.ptr] = b == a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0xa9: /* NEQ2k */ - __asm__( "evaluxn_a9_NEQ2k:" ); - { - 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)); - u->wst.dat[u->wst.ptr] = b != a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0xaa: /* GTH2k */ - __asm__( "evaluxn_aa_GTH2k:" ); - { - 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)); - u->wst.dat[u->wst.ptr] = b > a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0xab: /* LTH2k */ - __asm__( "evaluxn_ab_LTH2k:" ); - { - 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)); - u->wst.dat[u->wst.ptr] = b < a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0xac: /* JMP2k */ - __asm__( "evaluxn_ac_JMP2k:" ); - { - u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0xad: /* JCN2k */ - __asm__( "evaluxn_ad_JCN2k:" ); - { - u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); - if(u->wst.dat[u->wst.ptr - 3]) u->ram.ptr = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0xae: /* JSR2k */ - __asm__( "evaluxn_ae_JSR2k:" ); - { - u->rst.dat[u->rst.ptr] = u->ram.ptr >> 8; - u->rst.dat[u->rst.ptr + 1] = u->ram.ptr & 0xff; - u->ram.ptr = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xaf: /* STH2k */ - __asm__( "evaluxn_af_STH2k:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1], b = u->wst.dat[u->wst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b; - u->rst.dat[u->rst.ptr + 1] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xb0: /* LDZ2k */ - __asm__( "evaluxn_b0_LDZ2k:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a); - u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xb1: /* STZ2k */ - __asm__( "evaluxn_b1_STZ2k:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); - mempoke16(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0xb2: /* LDR2k */ - __asm__( "evaluxn_b2_LDR2k:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); - u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xb3: /* STR2k */ - __asm__( "evaluxn_b3_STR2k:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); - mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0xb4: /* LDA2k */ - __asm__( "evaluxn_b4_LDA2k:" ); - { - u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); - u->wst.dat[u->wst.ptr] = mempeek8(u->ram.dat, a); - u->wst.dat[u->wst.ptr + 1] = mempeek8(u->ram.dat, a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 2, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xb5: /* STA2k */ - __asm__( "evaluxn_b5_STA2k:" ); - { - u16 a = (u->wst.dat[u->wst.ptr - 1] | (u->wst.dat[u->wst.ptr - 2] << 8)); - u16 b = (u->wst.dat[u->wst.ptr - 3] | (u->wst.dat[u->wst.ptr - 4] << 8)); - mempoke16(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0xb6: /* DEI2k */ - __asm__( "evaluxn_b6_DEI2k:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u->wst.dat[u->wst.ptr] = devpeek8(&u->dev[a >> 4], a); - u->wst.dat[u->wst.ptr + 1] = devpeek8(&u->dev[a >> 4], a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 1, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xb7: /* DEO2k */ - __asm__( "evaluxn_b7_DEO2k:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); - devpoke16(&u->dev[a >> 4], a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } -#endif - } - break; - case 0xb8: /* ADD2k */ - __asm__( "evaluxn_b8_ADD2k:" ); - { - 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)); - u->wst.dat[u->wst.ptr] = (b + a) >> 8; - u->wst.dat[u->wst.ptr + 1] = (b + a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xb9: /* SUB2k */ - __asm__( "evaluxn_b9_SUB2k:" ); - { - 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)); - u->wst.dat[u->wst.ptr] = (b - a) >> 8; - u->wst.dat[u->wst.ptr + 1] = (b - a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xba: /* MUL2k */ - __asm__( "evaluxn_ba_MUL2k:" ); - { - 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)); - u->wst.dat[u->wst.ptr] = (b * a) >> 8; - u->wst.dat[u->wst.ptr + 1] = (b * a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xbb: /* DIV2k */ - __asm__( "evaluxn_bb_DIV2k:" ); - { - 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)); - u->wst.dat[u->wst.ptr] = (b / a) >> 8; - u->wst.dat[u->wst.ptr + 1] = (b / a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xbc: /* AND2k */ - __asm__( "evaluxn_bc_AND2k:" ); - { - 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]; - u->wst.dat[u->wst.ptr] = d & b; - u->wst.dat[u->wst.ptr + 1] = c & a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xbd: /* ORA2k */ - __asm__( "evaluxn_bd_ORA2k:" ); - { - 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]; - u->wst.dat[u->wst.ptr] = d | b; - u->wst.dat[u->wst.ptr + 1] = c | a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xbe: /* EOR2k */ - __asm__( "evaluxn_be_EOR2k:" ); - { - 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]; - u->wst.dat[u->wst.ptr] = d ^ b; - u->wst.dat[u->wst.ptr + 1] = c ^ a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 4, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xbf: /* SFT2k */ - __asm__( "evaluxn_bf_SFT2k:" ); - { - u8 a = u->wst.dat[u->wst.ptr - 1]; - u16 b = (u->wst.dat[u->wst.ptr - 2] | (u->wst.dat[u->wst.ptr - 3] << 8)); - u->wst.dat[u->wst.ptr] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8; - u->wst.dat[u->wst.ptr + 1] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->wst.ptr < 3, 0)) { - u->wst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xc3: /* POPkr */ - __asm__( "evaluxn_c3_POPkr:" ); - { - u->rst.dat[u->rst.ptr - 1]; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xc4: /* DUPkr */ - __asm__( "evaluxn_c4_DUPkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr] = a; - u->rst.dat[u->rst.ptr + 1] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xc5: /* SWPkr */ - __asm__( "evaluxn_c5_SWPkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = a; - u->rst.dat[u->rst.ptr + 1] = b; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xc6: /* OVRkr */ - __asm__( "evaluxn_c6_OVRkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b; - u->rst.dat[u->rst.ptr + 1] = a; - u->rst.dat[u->rst.ptr + 2] = b; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 252, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 3; - } - break; - case 0xc7: /* ROTkr */ - __asm__( "evaluxn_c7_ROTkr:" ); - { - 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]; - u->rst.dat[u->rst.ptr] = b; - u->rst.dat[u->rst.ptr + 1] = a; - u->rst.dat[u->rst.ptr + 2] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 252, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 3; - } - break; - case 0xc8: /* EQUkr */ - __asm__( "evaluxn_c8_EQUkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b == a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xc9: /* NEQkr */ - __asm__( "evaluxn_c9_NEQkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b != a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xca: /* GTHkr */ - __asm__( "evaluxn_ca_GTHkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b > a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xcb: /* LTHkr */ - __asm__( "evaluxn_cb_LTHkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b < a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xcc: /* JMPkr */ - __asm__( "evaluxn_cc_JMPkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xcd: /* JCNkr */ - __asm__( "evaluxn_cd_JCNkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - if(u->rst.dat[u->rst.ptr - 2]) u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xce: /* JSRkr */ - __asm__( "evaluxn_ce_JSRkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8; - u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff; - u->ram.ptr += (s8)a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xcf: /* STHkr */ - __asm__( "evaluxn_cf_STHkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->wst.dat[u->wst.ptr] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 254, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 1; - } - break; - case 0xd0: /* LDZkr */ - __asm__( "evaluxn_d0_LDZkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xd1: /* STZkr */ - __asm__( "evaluxn_d1_STZkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u8 b = u->rst.dat[u->rst.ptr - 2]; - mempoke8(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xd2: /* LDRkr */ - __asm__( "evaluxn_d2_LDRkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xd3: /* STRkr */ - __asm__( "evaluxn_d3_STRkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u8 b = u->rst.dat[u->rst.ptr - 2]; - mempoke8(u->ram.dat, u->ram.ptr + (s8)a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xd4: /* LDAkr */ - __asm__( "evaluxn_d4_LDAkr:" ); - { - u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); - u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xd5: /* STAkr */ - __asm__( "evaluxn_d5_STAkr:" ); - { - u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); - u8 b = u->rst.dat[u->rst.ptr - 3]; - mempoke8(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xd6: /* DEIkr */ - __asm__( "evaluxn_d6_DEIkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr] = devpeek8(&u->dev[a >> 4], a); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xd7: /* DEOkr */ - __asm__( "evaluxn_d7_DEOkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - devpoke8(&u->dev[a >> 4], a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xd8: /* ADDkr */ - __asm__( "evaluxn_d8_ADDkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b + a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xd9: /* SUBkr */ - __asm__( "evaluxn_d9_SUBkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b - a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xda: /* MULkr */ - __asm__( "evaluxn_da_MULkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b * a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xdb: /* DIVkr */ - __asm__( "evaluxn_db_DIVkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b / a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xdc: /* ANDkr */ - __asm__( "evaluxn_dc_ANDkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b & a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xdd: /* ORAkr */ - __asm__( "evaluxn_dd_ORAkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b | a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xde: /* EORkr */ - __asm__( "evaluxn_de_EORkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b ^ a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xdf: /* SFTkr */ - __asm__( "evaluxn_df_SFTkr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b >> (a & 0x07) << ((a & 0x70) >> 4); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xe3: /* POP2kr */ - __asm__( "evaluxn_e3_POP2kr:" ); - { - (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xe4: /* DUP2kr */ - __asm__( "evaluxn_e4_DUP2kr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->rst.dat[u->rst.ptr] = b; - u->rst.dat[u->rst.ptr + 1] = a; - u->rst.dat[u->rst.ptr + 2] = b; - u->rst.dat[u->rst.ptr + 3] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 251, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 4; - } - break; - case 0xe5: /* SWP2kr */ - __asm__( "evaluxn_e5_SWP2kr:" ); - { - 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]; - u->rst.dat[u->rst.ptr] = b; - u->rst.dat[u->rst.ptr + 1] = a; - u->rst.dat[u->rst.ptr + 2] = d; - u->rst.dat[u->rst.ptr + 3] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 251, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 4; - } - break; - case 0xe6: /* OVR2kr */ - __asm__( "evaluxn_e6_OVR2kr:" ); - { - 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]; - u->rst.dat[u->rst.ptr] = d; - u->rst.dat[u->rst.ptr + 1] = c; - u->rst.dat[u->rst.ptr + 2] = b; - u->rst.dat[u->rst.ptr + 3] = a; - u->rst.dat[u->rst.ptr + 4] = d; - u->rst.dat[u->rst.ptr + 5] = c; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 249, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 6; - } - break; - case 0xe7: /* ROT2kr */ - __asm__( "evaluxn_e7_ROT2kr:" ); - { - 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]; - u->rst.dat[u->rst.ptr] = d; - u->rst.dat[u->rst.ptr + 1] = c; - u->rst.dat[u->rst.ptr + 2] = b; - u->rst.dat[u->rst.ptr + 3] = a; - u->rst.dat[u->rst.ptr + 4] = f; - u->rst.dat[u->rst.ptr + 5] = e; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 6, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 249, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 6; - } - break; - case 0xe8: /* EQU2kr */ - __asm__( "evaluxn_e8_EQU2kr:" ); - { - 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)); - u->rst.dat[u->rst.ptr] = b == a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xe9: /* NEQ2kr */ - __asm__( "evaluxn_e9_NEQ2kr:" ); - { - 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)); - u->rst.dat[u->rst.ptr] = b != a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xea: /* GTH2kr */ - __asm__( "evaluxn_ea_GTH2kr:" ); - { - 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)); - u->rst.dat[u->rst.ptr] = b > a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xeb: /* LTH2kr */ - __asm__( "evaluxn_eb_LTH2kr:" ); - { - 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)); - u->rst.dat[u->rst.ptr] = b < a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 254, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 1; - } - break; - case 0xec: /* JMP2kr */ - __asm__( "evaluxn_ec_JMP2kr:" ); - { - u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xed: /* JCN2kr */ - __asm__( "evaluxn_ed_JCN2kr:" ); - { - u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); - if(u->rst.dat[u->rst.ptr - 3]) u->ram.ptr = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xee: /* JSR2kr */ - __asm__( "evaluxn_ee_JSR2kr:" ); - { - u->wst.dat[u->wst.ptr] = u->ram.ptr >> 8; - u->wst.dat[u->wst.ptr + 1] = u->ram.ptr & 0xff; - u->ram.ptr = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xef: /* STH2kr */ - __asm__( "evaluxn_ef_STH2kr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1], b = u->rst.dat[u->rst.ptr - 2]; - u->wst.dat[u->wst.ptr] = b; - u->wst.dat[u->wst.ptr + 1] = a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->wst.ptr > 253, 0)) { - u->wst.error = 2; - goto error; - } -#endif - u->wst.ptr += 2; - } - break; - case 0xf0: /* LDZ2kr */ - __asm__( "evaluxn_f0_LDZ2kr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a); - u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xf1: /* STZ2kr */ - __asm__( "evaluxn_f1_STZ2kr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); - mempoke16(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xf2: /* LDR2kr */ - __asm__( "evaluxn_f2_LDR2kr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a); - u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, u->ram.ptr + (s8)a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xf3: /* STR2kr */ - __asm__( "evaluxn_f3_STR2kr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); - mempoke16(u->ram.dat, u->ram.ptr + (s8)a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xf4: /* LDA2kr */ - __asm__( "evaluxn_f4_LDA2kr:" ); - { - u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); - u->rst.dat[u->rst.ptr] = mempeek8(u->ram.dat, a); - u->rst.dat[u->rst.ptr + 1] = mempeek8(u->ram.dat, a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 2, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xf5: /* STA2kr */ - __asm__( "evaluxn_f5_STA2kr:" ); - { - u16 a = (u->rst.dat[u->rst.ptr - 1] | (u->rst.dat[u->rst.ptr - 2] << 8)); - u16 b = (u->rst.dat[u->rst.ptr - 3] | (u->rst.dat[u->rst.ptr - 4] << 8)); - mempoke16(u->ram.dat, a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xf6: /* DEI2kr */ - __asm__( "evaluxn_f6_DEI2kr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u->rst.dat[u->rst.ptr] = devpeek8(&u->dev[a >> 4], a); - u->rst.dat[u->rst.ptr + 1] = devpeek8(&u->dev[a >> 4], a + 1); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 1, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xf7: /* DEO2kr */ - __asm__( "evaluxn_f7_DEO2kr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); - devpoke16(&u->dev[a >> 4], a, b); -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } -#endif - } - break; - case 0xf8: /* ADD2kr */ - __asm__( "evaluxn_f8_ADD2kr:" ); - { - 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)); - u->rst.dat[u->rst.ptr] = (b + a) >> 8; - u->rst.dat[u->rst.ptr + 1] = (b + a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xf9: /* SUB2kr */ - __asm__( "evaluxn_f9_SUB2kr:" ); - { - 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)); - u->rst.dat[u->rst.ptr] = (b - a) >> 8; - u->rst.dat[u->rst.ptr + 1] = (b - a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xfa: /* MUL2kr */ - __asm__( "evaluxn_fa_MUL2kr:" ); - { - 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)); - u->rst.dat[u->rst.ptr] = (b * a) >> 8; - u->rst.dat[u->rst.ptr + 1] = (b * a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xfb: /* DIV2kr */ - __asm__( "evaluxn_fb_DIV2kr:" ); - { - 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)); - u->rst.dat[u->rst.ptr] = (b / a) >> 8; - u->rst.dat[u->rst.ptr + 1] = (b / a) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xfc: /* AND2kr */ - __asm__( "evaluxn_fc_AND2kr:" ); - { - 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]; - u->rst.dat[u->rst.ptr] = d & b; - u->rst.dat[u->rst.ptr + 1] = c & a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xfd: /* ORA2kr */ - __asm__( "evaluxn_fd_ORA2kr:" ); - { - 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]; - u->rst.dat[u->rst.ptr] = d | b; - u->rst.dat[u->rst.ptr + 1] = c | a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xfe: /* EOR2kr */ - __asm__( "evaluxn_fe_EOR2kr:" ); - { - 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]; - u->rst.dat[u->rst.ptr] = d ^ b; - u->rst.dat[u->rst.ptr + 1] = c ^ a; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 4, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; - case 0xff: /* SFT2kr */ - __asm__( "evaluxn_ff_SFT2kr:" ); - { - u8 a = u->rst.dat[u->rst.ptr - 1]; - u16 b = (u->rst.dat[u->rst.ptr - 2] | (u->rst.dat[u->rst.ptr - 3] << 8)); - u->rst.dat[u->rst.ptr] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) >> 8; - u->rst.dat[u->rst.ptr + 1] = (b >> (a & 0x0f) << ((a & 0xf0) >> 4)) & 0xff; -#ifndef NO_STACK_CHECKS - if(__builtin_expect(u->rst.ptr < 3, 0)) { - u->rst.error = 1; - goto error; - } - if(__builtin_expect(u->rst.ptr > 253, 0)) { - u->rst.error = 2; - goto error; - } -#endif - u->rst.ptr += 2; - } - break; -#pragma GCC diagnostic pop - } - } - return 1; -#ifndef NO_STACK_CHECKS -error: - return 0; -#endif -} - -Device * -portuxn(Uxn *u, u8 id, char *name, void (*talkfn)(Device *d, u8 b0, u8 w)) -{ - Device *d = &u->dev[id]; - d->addr = id * 0x10; - d->u = u; - d->mem = u->ram.dat; - d->talk = talkfn; - (void)name; - return d; -} diff --git a/src/uxn/uxn.h b/src/uxn/uxn.h deleted file mode 100644 index a4ab428..0000000 --- a/src/uxn/uxn.h +++ /dev/null @@ -1,56 +0,0 @@ -#ifndef UXNGBA_UXN_H -#define UXNGBA_UXN_H - -#include - -/* -Copyright (c) 2021 Devine Lu Linvega - -Permission to use, copy, modify, and distribute this software for any -purpose with or without fee is hereby granted, provided that the above -copyright notice and this permission notice appear in all copies. - -THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES -WITH REGARD TO THIS SOFTWARE. -*/ - -#define PAGE_PROGRAM 0x0100 - -typedef struct { - u8 ptr, kptr, error; - u8 dat[256]; -} Stack; - -typedef struct { - u16 ptr; - u8 *dat; -} Memory; - -typedef struct Device { - struct Uxn *u; - u8 addr, dat[16], *mem; - void (*talk)(struct Device *d, u8, u8); -} Device; - -typedef struct Uxn { - Stack wst, rst, *src, *dst; - Memory ram; - Device dev[16]; -} Uxn; - -struct Uxn; - -static inline void mempoke8(u8 *m, u16 a, u8 b) { m[a] = b; } -static inline u8 mempeek8(u8 *m, u16 a) { return m[a]; } -static inline void mempoke16(u8 *m, u16 a, u16 b) { mempoke8(m, a, b >> 8); mempoke8(m, a + 1, b); } -static inline u16 mempeek16(u8 *m, u16 a) { return (mempeek8(m, a) << 8) + mempeek8(m, a + 1); } -static inline void devpoke8(Device *d, u8 a, u8 b) { d->dat[a & 0xf] = b; d->talk(d, a & 0x0f, 1); } -static inline u8 devpeek8(Device *d, u8 a) { d->talk(d, a & 0x0f, 0); return d->dat[a & 0xf]; } -static inline void devpoke16(Device *d, u8 a, u16 b) { devpoke8(d, a, b >> 8); devpoke8(d, a + 1, b); } -static inline u16 devpeek16(Device *d, u16 a) { return (devpeek8(d, a) << 8) + devpeek8(d, a + 1); } - -int loaduxn(Uxn *c, char *filepath); -int bootuxn(Uxn *c); -int evaluxn(Uxn *u, u16 vec); -Device *portuxn(Uxn *u, u8 id, char *name, void (*talkfn)(Device *, u8, u8)); -#endif // UXNGBA_UXN_H -- cgit v1.2.1