--- hugo-2.12/bios.c 2004-05-26 22:54:15.000000000 +0200 +++ hugo-2.13-pre/bios.c 2005-09-27 19:58:15.000000000 +0200 @@ -323,7 +323,7 @@ #endif -void handle_bios(void) +int handle_bios(void) { #ifdef CD_DEBUG static int last_op = -1, last_ax = -1, last_bx = -1, last_cx = -1, last_dx = -1; @@ -1093,4 +1093,5 @@ put_8bit_addr( (UInt16)(reg_pc), CDBIOS_replace[imm_operand( (UInt16)(reg_pc + 1))][0]); put_8bit_addr( (UInt16)(reg_pc + 1), CDBIOS_replace[imm_operand( (UInt16)(reg_pc + 1))][1]); } + return 0; } --- hugo-2.12/bios.h 2004-05-26 22:54:15.000000000 +0200 +++ hugo-2.13-pre/bios.h 2005-09-27 19:58:15.000000000 +0200 @@ -1,7 +1,7 @@ #ifndef INCLUDE_BIOS_H #define INCLUDE_BIOS_H -void handle_bios(void); +int handle_bios(void); /* Perform the bios hooking function */ #endif --- hugo-2.12/hugo.6 1970-01-01 01:00:00.000000000 +0100 +++ hugo-2.13-pre/hugo.6 2009-01-13 14:33:38.000000000 +0200 @@ -0,0 +1,86 @@ +.TH Hu-Go! "6" "April 2005" "Hu-Go! 2.12" "Games" +.SH NAME +Hu-Go! \- manual page for Hu-Go! 2.12 +.SH SYNOPSIS +.B hugo +[\fIOPTION\fR...] \fI<rom filename> <BRAM filename>\fR +.SH DESCRIPTION +hugo \fB\-\-\fR a program to play pc engine games (roms, cds and various kind of +dumps) +.TP +\fB\-a\fR, \fB\-\-aspect\-ratio[\fR=\fI0\fR/1] +Keep aspect ratio of pc engine in fullscreen mode +(default is 0) +.TP +\fB\-c\fR, \fB\-\-cd\-emulation=\fR<CD emulation level> +CD emulation mode (default is 0, rom only) +.TP +\fB\-d\fR, \fB\-\-debug\-startup[\fR=\fI0\fR/1] +Launch debugger on startup (default is 0) +.TP +\fB\-e\fR, \fB\-\-eagle[\fR=\fI0\fR/1] +Use eagle mode for rendering, if available +(default is 0) +.TP +\fB\-f\fR, \fB\-\-fullscreen[\fR=\fI0\fR/1] +Start game in fullscreen (default is 0) +.TP +\fB\-i\fR, \fB\-\-cd\-device=\fR<CD device> +CD device to use (if CD emulation mode = 1, +default is /dev/cdrom) +.TP +\fB\-m\fR, \fB\-\-no\-bios\-hooking[\fR=\fI0\fR/1] +No hard bios hooking (slower but more +compatible, default is 0) +.TP +\fB\-n\fR, \fB\-\-netplay=\fR<server ip or hostname> +Enable Netplay and set server name +.TP +\fB\-o\fR, \fB\-\-overlay[\fR=\fI0\fR/1] +Use hardware scaling mode for rendering, if +available (default is 0) +.TP +\fB\-s\fR, \fB\-\-stereo[\fR=\fI0\fR/1] +Render sound in stereo (default is 0) +.TP +\fB\-S\fR, \fB\-\-scanline[\fR=\fI0\fR/1] +Use scanline mode for rendering, if available +(default is 0) +.TP +\fB\-t\fR, \fB\-\-tracks\-number=\fR<track number> +Number of tracks when emulating a single iso +(default is 22) +.TP +\fB\-u\fR, \fB\-\-us\-decryption[\fR=\fI0\fR/1] +Decrypt roms using the US \-> JAP decryption +algorythm (default is 0) +.TP +\fB\-w\fR, \fB\-\-window\-size=\fR<zoom factor> +Zoom factor when in windowed mode (Between 1 and +4, default is 1) +.TP +\-?, \fB\-\-help\fR +Give this help list +.TP +\fB\-\-usage\fR +Give a short usage message +.TP +\fB\-V\fR, \fB\-\-version\fR +Print program version +.PP +Mandatory or optional arguments to long options are also mandatory or optional +for any corresponding short options. +.SH "REPORTING BUGS" +Report bugs to <zeograd@zeograd.com>. +.SH "SEE ALSO" +The full documentation for +.B Hu-Go! +is maintained as a Texinfo manual. If the +.B info +and +.B Hu-Go! +programs are properly installed at your site, the command +.IP +.B info Hu-Go! +.PP +should give you access to the complete manual. --- hugo-2.12/hugod.6 1970-01-01 01:00:00.000000000 +0100 +++ hugo-2.13-pre/hugod.6 2009-01-13 14:33:13.000000000 +0200 @@ -0,0 +1,20 @@ +.TH Hu-Go! Netplay Server "6" +.SH NAME +hugo_server \- server for multiplay +.SH SYNOPSIS +.B hugo_server +.I "[options] ..." +.SH "DESCRIPTION" +This manual page documents briefly the +.BR hugo_server command. +This manual page was written for the Debian GNU/Linux distribution +because the original program does not have a manual page. +Instead, it has documentation in the GNU Info format; see below. +.br +This man should be completed before any release +.PP +.B hugo_server +is a program that run a server for connecting multiple hugo clients +.SH AUTHOR +This manual page was written by Olivier Jolly <olivier.jolly@pcedev.com>, +for the Debian GNU/Linux system (but may be used by others). --- hugo-2.12/defs.h 2003-02-18 09:26:48.000000000 +0100 +++ hugo-2.13-pre/defs.h 2005-09-27 19:58:15.000000000 +0200 @@ -58,7 +58,7 @@ typedef struct op { int (*func_exe)(void); Int16 addr_mode; - Char * opname; + char * opname; // short int filler[3]; // force align to power-of-2 (?) } operation; --- hugo-2.12/gfx.c 2005-04-05 21:53:14.000000000 +0200 +++ hugo-2.13-pre/gfx.c 2005-10-27 10:14:46.000000000 +0200 @@ -25,6 +25,11 @@ #include "utils.h" #include "config.h" +#if defined(GTK) +#include <gtk/gtk.h> +#endif + + typedef struct { UChar r,g,b; } rgb_map_struct; --- hugo-2.12/gtk_main.c 2005-03-14 21:17:23.000000000 +0100 +++ hugo-2.13-pre/gtk_main.c 2005-10-28 10:55:05.000000000 +0200 @@ -4,6 +4,7 @@ #include "callbacks.h" #include "sys_inp.h" #include "iniconfig.h" +#include "utils.h" #if defined(SDL) @@ -86,7 +87,6 @@ static int gui_configuration_index = 0; -static int player_index = 0; //! Setter for gui_configuration_index void set_gui_configuration_index(int new_index) --- hugo-2.12/h6280.c 2005-03-27 23:23:53.000000000 +0200 +++ hugo-2.13-pre/h6280.c 2005-10-27 10:14:46.000000000 +0200 @@ -63,16 +63,8 @@ return( (UChar) (PageR[memreg][addr])); } -#if !defined(INLINED_ACCESSORS) - -#define get_8bit_addr(addr) Rd6502((addr)) - -#define put_8bit_addr(addr,byte) Wr6502((addr),(byte)) - -#define get_16bit_addr(addr) (Rd6502(addr) + (Rd6502((UInt16)(addr + 1)) << 8)) - -#else +#if defined(INLINED_ACCESSORS) // This is the more generalized access routine: inline UChar get_8bit_addr(UInt16 addr) { @@ -2835,7 +2827,7 @@ static void Int6502 (UChar Type) { - UInt16 J; + UInt16 J = 0; if ((Type == INT_NMI) || (!(reg_p & FL_I))) { --- hugo-2.12/hard_pce.h 2004-05-26 22:54:15.000000000 +0200 +++ hugo-2.13-pre/hard_pce.h 2005-10-27 09:30:58.000000000 +0200 @@ -64,8 +64,8 @@ UChar IO_read (UInt16 A); void bank_set (UChar P, UChar V); -void (*write_memory_function)(UInt16,UChar); -UChar (*read_memory_function)(UInt16); +extern void (*write_memory_function)(UInt16,UChar); +extern UChar (*read_memory_function)(UInt16); #define Wr6502(A,V) ((*write_memory_function)((A),(V))) --- hugo-2.12/hugo.c 2005-03-28 20:18:28.000000000 +0200 +++ hugo-2.13-pre/hugo.c 2005-10-27 10:14:46.000000000 +0200 @@ -1,4 +1,6 @@ + #include "hugo.h" +#include "utils.h" //! name of the backup ram filename @@ -196,7 +198,14 @@ } else { +#if defined (MORPHOS) + // Build and execute the MUI GUI here! + // since no game was specified on the + // command line + InitInterface_MUI(); +#else printf ("No game specified\n"); +#endif } } #endif --- hugo-2.12/iniconfig.c 2005-04-05 22:19:10.000000000 +0200 +++ hugo-2.13-pre/iniconfig.c 2005-10-27 09:33:49.000000000 +0200 @@ -16,7 +16,8 @@ #include "iniconfig.h" #include "utils.h" -#if !defined(WIN32) && !defined(SOLARIS) +#if !defined(WIN32) && !defined(SOLARIS) && !defined(MORPHOS) && !defined(__APPLE__) +#define HAVE_ARGP_H 1 #include <argp.h> #endif @@ -382,7 +383,7 @@ } } -#if !defined(WIN32) && !defined(SOLARIS) +#if defined(HAVE_ARGP_H) //! program header for GNU argp function const char *argp_program_version = "Hu-Go! 2.12"; @@ -553,13 +554,13 @@ void parse_commandline (int argc, char **argv) { -#if defined(WIN32) || defined(SOLARIS) +#if !defined(HAVE_ARGP_H) char next_arg, i, arg_error = 0; #endif Log ("--[ PARSING COMMAND LINE ]--------------------------\n"); -#if !defined(WIN32) && !defined(SOLARIS) +#if defined(HAVE_ARGP_H) argp_parse (&argp, argc, argv, 0, 0, &option); #else next_arg = 0; --- hugo-2.12/instr-switch.c 1970-01-01 01:00:00.000000000 +0100 +++ hugo-2.13-pre/instr-switch.c 2004-05-24 20:50:36.000000000 +0200 @@ -0,0 +1,2132 @@ +//#define STANDALONE +#if STANDALONE +typedef int Char; +typedef int UChar; +typedef int UInt16; +extern int cycles; +extern int reg_p, reg_a, reg_x, reg_y, reg_pc, reg_s; +extern int FL_T, FL_N, FL_V, FL_Z, FL_C, FL_B, FL_D, FL_I; +extern int flnz_list[]; +extern UChar* mmr; +extern UChar *PageR[8]; + +extern UChar get_8bit_addr(UInt16 addr); +extern void put_8bit_addr(UInt16 addr, UChar byte); +extern UInt16 get_16bit_addr(UInt16 addr); +extern UChar get_8bit_zp(UChar zp_addr); +extern UInt16 get_16bit_zp(UChar zp_addr); +extern void put_8bit_zp(UChar zp_addr, UChar byte); +extern void push_8bit(UChar byte); +extern UChar pull_8bit(void); +extern void push_16bit(UInt16 addr); +extern UInt16 pull_16bit(void); + +extern UChar abs_operand(UInt16 addr); +extern UChar absx_operand(UInt16 addr); +extern UChar absy_operand(UInt16 addr); +extern UChar zpind_operand(UInt16 addr); +extern UChar zpindx_operand(UInt16 addr); +extern UChar zpindy_operand(UInt16 addr); +extern UChar zp_operand(UChar zp_addr); +extern UChar zpx_operand(UChar zp_addr); +extern UChar zpy_operand(UChar zp_addr); +#endif + +/* optimized flag computation */ +//grep 'reg_p[^c]' instr-switch.c | grep -v 'reg_p =' | grep -v 'reg_p &=' +/* #define FAST_FLAGS */ +#ifdef FAST_FLAGS +/* unless I once more made sth stupid FAST_FLAGS does not improve speed */ +/* optimized */ +#define SET_NV(x) ((x)&0xC0) +/* nothing to optimize */ +#define SET_CTST(x) ((x) ? 0:FL_C) +/* optimized */ +#define SET_C01(x) ((x)&0x01) +/* not optimized (use shift; ensure reg_p is 8 bit) */ +#if 0 +#define SET_C80(x) (((x)&0x80) ? FL_C:0) +#else +#define SET_C80(x) (((x)&0x80) >> 7) +#endif +/* nothing to optimize */ +#define SET_Z(x) ((x) ? 0:FL_Z) +/* nothing to optimize */ +#define CLEAR_NVTZ (reg_p & ~(FL_N|FL_V|FL_T|FL_Z)) +/* nothing to optimize */ +#define CLEAR_NTZC (reg_p & ~(FL_N|FL_T|FL_Z|FL_C)) +/* optimized */ +#define GET_C (reg_p & FL_C) +/* optimized */ +#define GET_C80 ((reg_p & FL_C) << 7) +#define IS_SET_T (reg_p & FL_T) +#define IS_SET_C (reg_p & FL_C) +#define IS_SET_N (reg_p & FL_N) +#define IS_SET_Z (reg_p & FL_Z) +#define IS_SET_V (reg_p & FL_V) +#else +#define SET_N(x) (((x)&0x80) ? FL_N:0) +#define SET_V(x) (((x)&0x40) ? FL_V:0) +#define SET_NV(x) SET_N(x) | SET_V(x) +#define SET_C(x) ((x) ? FL_C:0) +#define SET_CTST(x) ((x) ? 0:FL_C) +#define SET_C01(x) SET_C((x)&0x01) +#define SET_C80(x) SET_C((x)&0x80) +#define SET_Z(x) ((x) ? 0:FL_Z) +#define CLEAR_NVTZ (reg_p & ~(FL_N|FL_V|FL_T|FL_Z)) +#define CLEAR_NTZC (reg_p & ~(FL_N|FL_T|FL_Z|FL_C)) +#define GET_C ((reg_p & FL_C) ? 1:0) +#define GET_C80 ((reg_p & FL_C) ? 0x80:0) +#define IS_SET_T (reg_p & FL_T) +#define IS_SET_C (reg_p & FL_C) +#define IS_SET_N (reg_p & FL_N) +#define IS_SET_Z (reg_p & FL_Z) +#define IS_SET_V (reg_p & FL_V) +#endif + +#if STANDALONE +void foo() { + int err; +#endif + + switch (PageR[reg_pc>>13][reg_pc]) { + case 0x00: /* brek, AM_IMMED, "BRK" */ + push_16bit(reg_pc+2); + reg_p &= ~FL_T; + push_8bit(reg_p|FL_B); + reg_p =(reg_p & ~FL_D) | FL_I; + reg_pc=get_16bit_addr(0xFFF6); + cycles+=8; + break; + case 0x01: /* ora_zpindx, AM_ZPINDX, "ORA" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp |= zpindx_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=10; + } else { + chk_flnz_8bit(reg_a |= zpindx_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x02: /* sxy, AM_IMPL, "SXY" */ + { + UChar temp = reg_y; + reg_p &= ~FL_T; + reg_y = reg_x; + reg_x = temp; + reg_pc++; + cycles+=3; + } + break; + case 0x03: /* st0, AM_IMMED, "ST0" */ + reg_p &= ~FL_T; + IO_write(0,imm_operand(reg_pc+1)); + reg_pc+=2; + cycles+=4; + break; + case 0x04: /* tsb_zp, AM_ZP, "TSB" */ + { + UChar zp_addr = imm_operand(reg_pc+1); + UChar temp = get_8bit_zp(zp_addr); + UChar temp1 = reg_a | temp; + reg_p = CLEAR_NVTZ | SET_NV(temp1) | SET_Z(temp & reg_a); + put_8bit_zp(zp_addr, temp1); + reg_pc+=2; + cycles+=6; + } + break; + case 0x05: /* ora_zp, AM_ZP, "ORA" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp |= zp_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=7; + } else { + chk_flnz_8bit(reg_a |= zp_operand(reg_pc+1)); + cycles+=4; + } + reg_pc+=2; + break; + case 0x06: /* asl_zp, AM_ZP, "ASL" */ + { + UChar zp_addr = imm_operand(reg_pc+1); + UChar temp1 = get_8bit_zp(zp_addr); + UChar temp = temp1<<1; + reg_p = CLEAR_NTZC | SET_C80(temp1) | flnz_list[temp]; + cycles+=6; + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + } + break; + case 0x07: /* rmb0, AM_ZP, "RMB0" */ + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) & (~0x01)); + reg_pc+=2; + cycles+=7; + } + break; + case 0x08: /* php, AM_IMPL, "PHP" */ + reg_p &= ~FL_T; + push_8bit(reg_p); + reg_pc++; + cycles+=3; + break; + case 0x09: /* ora_imm, AM_IMMED, "ORA" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp |= imm_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=5; + } else { + chk_flnz_8bit(reg_a |= imm_operand(reg_pc+1)); + cycles+=2; + } + reg_pc+=2; + break; + case 0x0A: /* asl_a, AM_IMPL, "ASL" */ + { + UChar temp1 = reg_a; + reg_a<<=1; + reg_p = CLEAR_NTZC | SET_C80(temp1) | flnz_list[reg_a]; + cycles+=2; + reg_pc++; + } + break; + case 0x0B: /* handle_bp0, AM_IMPL, "BP0" */ + handle_bp0(); + break; + case 0x0C: /* tsb_abs, AM_ABS, "TSB" */ + { + UInt16 abs_addr = get_16bit_addr(reg_pc+1); + UChar temp = get_8bit_addr(abs_addr); + UChar temp1 = reg_a | temp; + reg_p = CLEAR_NVTZ | SET_NV(temp1) | SET_Z(temp & reg_a); + cycles+=7; + put_8bit_addr(abs_addr, temp1); + reg_pc+=3; + } + break; + case 0x0D: /* ora_abs, AM_ABS, "ORA" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp |= abs_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=8; + } else { + chk_flnz_8bit(reg_a |= abs_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x0E: /* asl_abs, AM_ABS, "ASL" */ + { + UInt16 temp_addr = get_16bit_addr(reg_pc+1); + UChar temp1 = get_8bit_addr(temp_addr); + UChar temp = temp1<<1; + reg_p = CLEAR_NTZC | SET_C80(temp1) | flnz_list[temp]; + cycles+=7; + put_8bit_addr(temp_addr,temp); + reg_pc+=3; + } + break; + case 0x0F: /* bbr0, AM_PSREL, "BBR0" */ + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x01) { + reg_pc+=3; + cycles+=6; + } else { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } + break; + case 0x10: /* bpl, AM_REL, "BPL" */ + reg_p &= ~FL_T; + if (IS_SET_N) { + reg_pc+=2; + cycles+=2; + } else { + reg_pc+=(Char)imm_operand(reg_pc+1)+2; + cycles+=4; + } + break; + case 0x11: /* ora_zpindy, AM_ZPINDY, "ORA" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp |= zpindy_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=10; + } else { + chk_flnz_8bit(reg_a |= zpindy_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x12: /* ora_zpind, AM_ZPIND, "ORA" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp |= zpind_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=10; + } else { + chk_flnz_8bit(reg_a |= zpind_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x13: /* st1, AM_IMMED, "ST1" */ + reg_p &= ~FL_T; + IO_write(2,imm_operand(reg_pc+1)); + reg_pc+=2; + cycles+=4; + break; + case 0x14: /* trb_zp, AM_ZP, "TRB" */ + { + UChar zp_addr = imm_operand(reg_pc+1); + UChar temp = get_8bit_zp(zp_addr); + UChar temp1 = (~reg_a) & temp; + reg_p = CLEAR_NVTZ | SET_NV(temp1) | SET_Z(temp & reg_a); + put_8bit_zp(zp_addr, temp1); + reg_pc+=2; + cycles+=6; + } + break; + case 0x15: /* ora_zpx, AM_ZPX, "ORA" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp |= zpx_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=7; + } else { + chk_flnz_8bit(reg_a |= zpx_operand(reg_pc+1)); + cycles+=4; + } + reg_pc+=2; + break; + case 0x16: /* asl_zpx, AM_ZPX, "ASL" */ + { + UChar zp_addr = imm_operand(reg_pc+1)+reg_x; + UChar temp1 = get_8bit_zp(zp_addr); + UChar temp = temp1<<1; + reg_p = CLEAR_NTZC | SET_C80(temp1) | flnz_list[temp]; + cycles+=6; + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + } + break; + case 0x17: /* rmb1, AM_ZP, "RMB1" */ + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) & (~0x02)); + reg_pc+=2; + cycles+=7; + } + break; + case 0x18: /* clc, AM_IMPL, "CLC" */ + reg_p &= ~(FL_T|FL_C); + reg_pc++; + cycles+=2; + break; + case 0x19: /* ora_absy, AM_ABSY, "ORA" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp |= absy_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=8; + } else { + chk_flnz_8bit(reg_a |= absy_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x1A: /* inc_a, AM_IMPL, "INC" */ + chk_flnz_8bit(++reg_a); + reg_pc++; + cycles+=2; + break; + case 0x1B: /* handle_bp1, AM_IMPL, "BP1" */ + handle_bp1(); + break; + case 0x1C: /* trb_abs, AM_ABS, "TRB" */ + { + UInt16 abs_addr = get_16bit_addr(reg_pc+1); + UChar temp = get_8bit_addr(abs_addr); + UChar temp1 = (~reg_a) & temp; + reg_p = CLEAR_NVTZ | SET_NV(temp1) | SET_Z(temp & reg_a); + cycles+=7; + put_8bit_addr(abs_addr, temp1); + reg_pc+=3; + } + break; + case 0x1D: /* ora_absx, AM_ABSX, "ORA" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp |= absx_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=8; + } else { + chk_flnz_8bit(reg_a |= absx_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x1E: /* asl_absx, AM_ABSX, "ASL" */ + { + UInt16 temp_addr = get_16bit_addr(reg_pc+1)+reg_x; + UChar temp1 = get_8bit_addr(temp_addr); + UChar temp = temp1<<1; + reg_p = CLEAR_NTZC | SET_C80(temp1) | flnz_list[temp]; + cycles+=7; + put_8bit_addr(temp_addr,temp); + reg_pc+=3; + } + break; + case 0x1F: /* bbr1, AM_PSREL, "BBR1" */ + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x02) { + reg_pc+=3; + cycles+=6; + } else { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } + break; + case 0x20: /* jsr, AM_ABS, "JSR" */ + reg_p &= ~FL_T; + push_16bit(reg_pc+2); + reg_pc = get_16bit_addr(reg_pc+1); + cycles+=7; + break; + case 0x21: /* and_zpindx, AM_ZPINDX, "AND" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp &= zpindx_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=10; + } else { + chk_flnz_8bit(reg_a &= zpindx_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x22: /* sax, AM_IMPL, "SAX" */ + { + UChar temp = reg_x; + reg_p &= ~FL_T; + reg_x = reg_a; + reg_a = temp; + reg_pc++; + cycles+=3; + } + break; + case 0x23: /* st2, AM_IMMED, "ST2" */ + reg_p &= ~FL_T; + IO_write(3,imm_operand(reg_pc+1)); + reg_pc+=2; + cycles+=4; + break; + case 0x24: /* bit_zp, AM_ZP, "BIT" */ + { + UChar temp = zp_operand(reg_pc+1); + reg_p = CLEAR_NVTZ | SET_NV(temp) | SET_Z(reg_a&temp); + reg_pc+=2; + cycles+=4; + } + break; + case 0x25: /* and_zp, AM_ZP, "AND" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp &= zp_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=7; + } else { + chk_flnz_8bit(reg_a &= zp_operand(reg_pc+1)); + cycles+=4; + } + reg_pc+=2; + break; + case 0x26: /* rol_zp, AM_ZP, "ROL" */ + { + UChar flg_tmp = GET_C; + UChar zp_addr = imm_operand(reg_pc+1); + UChar temp1 = get_8bit_zp(zp_addr); + UChar temp = (temp1<<1)+flg_tmp; + reg_p = CLEAR_NTZC | SET_C80(temp1) | flnz_list[temp]; + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + cycles+=6; + } + break; + case 0x27: /* rmb2, AM_ZP, "RMB2" */ + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) & (~0x04)); + reg_pc+=2; + cycles+=7; + } + break; + case 0x28: /* plp, AM_IMPL, "PLP" */ + reg_p = pull_8bit(); + reg_pc++; + cycles+=4; + break; + case 0x29: /* and_imm, AM_IMMED, "AND" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp &= imm_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=5; + } else { + chk_flnz_8bit(reg_a &= imm_operand(reg_pc+1)); + cycles+=2; + } + reg_pc+=2; + break; + case 0x2A: /* rol_a, AM_IMPL, "ROL" */ + { + UChar flg_tmp = GET_C; + UChar temp = reg_a; + reg_a = (reg_a<<1)+flg_tmp; + reg_p = CLEAR_NTZC | SET_C80(temp) | flnz_list[reg_a]; + reg_pc++; + cycles+=2; + } + break; + case 0x2B: /* handle_bp2, AM_IMPL, "BP2" */ + handle_bp2(); + break; + case 0x2C: /* bit_abs, AM_ABS, "BIT" */ + { + UChar temp = abs_operand(reg_pc+1); + reg_p = CLEAR_NVTZ | SET_NV(temp) | SET_Z(reg_a&temp); + reg_pc+=3; + cycles+=5; + } + break; + case 0x2D: /* and_abs, AM_ABS, "AND" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp &= abs_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=8; + } else { + chk_flnz_8bit(reg_a &= abs_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x2E: /* rol_abs, AM_ABS, "ROL" */ + { + UChar flg_tmp = GET_C; + UInt16 temp_addr = get_16bit_addr(reg_pc+1); + UChar temp1 = get_8bit_addr(temp_addr); + UChar temp = (temp1<<1)+flg_tmp; + reg_p = CLEAR_NTZC | SET_C80(temp1) | flnz_list[temp]; + cycles+=7; + put_8bit_addr(temp_addr, temp); + reg_pc+=3; + } + break; + case 0x2F: /* bbr2, AM_PSREL, "BBR2" */ + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x04) { + reg_pc+=3; + cycles+=6; + } else { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } + break; + case 0x30: /* bmi, AM_REL, "BMI" */ + reg_p &= ~FL_T; + if (IS_SET_N) { + reg_pc+=(Char)imm_operand(reg_pc+1)+2; + cycles+=4; + } else { + reg_pc+=2; + cycles+=2; + } + break; + case 0x31: /* and_zpindy, AM_ZPINDY, "AND" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp &= zpindy_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=10; + } else { + chk_flnz_8bit(reg_a &= zpindy_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x32: /* and_zpind, AM_ZPIND, "AND" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp &= zpind_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=10; + } else { + chk_flnz_8bit(reg_a &= zpind_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x33: /* halt, AM_IMPL, "???" */ + err = 1; + break; + case 0x34: /* bit_zpx, AM_ZPX, "BIT" */ + { + UChar temp = zpx_operand(reg_pc+1); + reg_p = CLEAR_NVTZ | SET_NV(temp) | SET_Z(reg_a&temp); + reg_pc+=2; + cycles+=4; + } + break; + case 0x35: /* and_zpx, AM_ZPX, "AND" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp &= zpx_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=7; + } else { + chk_flnz_8bit(reg_a &= zpx_operand(reg_pc+1)); + cycles+=4; + } + reg_pc+=2; + break; + case 0x36: /* rol_zpx, AM_ZPX, "ROL" */ + { + UChar flg_tmp = GET_C; + UChar zp_addr = imm_operand(reg_pc+1)+reg_x; + UChar temp1 = get_8bit_zp(zp_addr); + UChar temp = (temp1<<1)+flg_tmp; + reg_p = CLEAR_NTZC | SET_C80(temp1) | flnz_list[temp]; + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + cycles+=6; + } + break; + case 0x37: /* rmb3, AM_ZP, "RMB3" */ + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) & (~0x08)); + reg_pc+=2; + cycles+=7; + } + break; + case 0x38: /* sec, AM_IMPL, "SEC" */ + reg_p = (reg_p|FL_C) & ~FL_T; + reg_pc++; + cycles+=2; + break; + case 0x39: /* and_absy, AM_ABSY, "AND" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp &= absy_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=8; + } else { + chk_flnz_8bit(reg_a &= absy_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x3A: /* dec_a, AM_IMPL, "DEC" */ + chk_flnz_8bit(--reg_a); + reg_pc++; + cycles+=2; + break; + case 0x3B: /* handle_bp3, AM_IMPL, "BP3" */ + handle_bp3(); + break; + case 0x3C: /* bit_absx, AM_ABSX, "BIT" */ + { + UChar temp = absx_operand(reg_pc+1); + reg_p = CLEAR_NVTZ | SET_NV(temp) | SET_Z(reg_a&temp); + reg_pc+=3; + cycles+=5; + } + break; + case 0x3D: /* and_absx, AM_ABSX, "AND" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp &= absx_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=8; + } else { + chk_flnz_8bit(reg_a &= absx_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x3E: /* rol_absx, AM_ABSX, "ROL" */ + { + UChar flg_tmp = GET_C; + UInt16 temp_addr = get_16bit_addr(reg_pc+1)+reg_x; + UChar temp1 = get_8bit_addr(temp_addr); + UChar temp = (temp1<<1)+flg_tmp; + reg_p = CLEAR_NTZC | SET_C80(temp1) | flnz_list[temp]; + cycles+=7; + put_8bit_addr(temp_addr, temp); + reg_pc+=3; + } + break; + case 0x3F: /* bbr3, AM_PSREL, "BBR3" */ + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x08) { + reg_pc+=3; + cycles+=6; + } else { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } + break; + case 0x40: /* rti, AM_IMPL, "RTI" */ + reg_p = pull_8bit() & ~FL_B; + reg_pc = pull_16bit(); + cycles+=7; + break; + case 0x41: /* eor_zpindx, AM_ZPINDX, "EOR" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp ^= zpindx_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=10; + } else { + chk_flnz_8bit(reg_a ^= zpindx_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x42: + { + UChar temp = reg_y; + reg_p &= ~FL_T; + reg_y = reg_a; + reg_a = temp; + reg_pc++; + cycles+=3; + } + break; + case 0x43: + { + int i; + UChar bitfld = imm_operand(reg_pc+1); + for (i = 0; i < 8; i++) { + if (bitfld & (1 << i)) { + reg_a = mmr[i]; + } + } + reg_p &= ~FL_T; + reg_pc+=2; + cycles+=4; + } + break; + case 0x44: + reg_p &= ~FL_T; + push_16bit(reg_pc+1); + reg_pc+=(Char)imm_operand(reg_pc+1)+2; + cycles+=8; + break; + case 0x45: + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp ^= zp_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=7; + } else { + chk_flnz_8bit(reg_a ^= zp_operand(reg_pc+1)); + cycles+=4; + } + reg_pc+=2; + break; + case 0x46: + { + UChar zp_addr = imm_operand(reg_pc+1); + UChar temp1 = get_8bit_zp(zp_addr); + UChar temp = temp1/2; + reg_p = CLEAR_NTZC | SET_C01(temp1) | flnz_list[temp]; + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + cycles+=6; + } + break; + case 0x47: + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) & (~0x10)); + reg_pc+=2; + cycles+=7; + } + break; + case 0x48: + reg_p &= ~FL_T; + push_8bit(reg_a); + reg_pc++; + cycles+=3; + break; + case 0x49: + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp ^= imm_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=5; + } else { + chk_flnz_8bit(reg_a ^= imm_operand(reg_pc+1)); + cycles+=2; + } + reg_pc+=2; + break; + case 0x4A: + { + UChar temp = reg_a; + reg_a/=2; + reg_p = CLEAR_NTZC | SET_C01(temp) | flnz_list[reg_a]; + reg_pc++; + cycles+=2; + } + break; + case 0x4B: + handle_bp4(); + break; + case 0x4C: + reg_p &= ~FL_T; + reg_pc = get_16bit_addr(reg_pc+1); + cycles+=4; + break; + case 0x4D: + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp ^= abs_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=8; + } else { + chk_flnz_8bit(reg_a ^= abs_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x4E: + { + UInt16 temp_addr = get_16bit_addr(reg_pc+1); + UChar temp1 = get_8bit_addr(temp_addr); + UChar temp = temp1/2; + reg_p = CLEAR_NTZC | SET_C01(temp1) | flnz_list[temp]; + cycles+=7; + put_8bit_addr(temp_addr, temp); + reg_pc+=3; + } + break; + case 0x4F: + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x10) { + reg_pc+=3; + cycles+=6; + } else { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } + break; + case 0x50: + reg_p &= ~FL_T; + if (IS_SET_V) { + reg_pc+=2; + cycles+=2; + } else { + reg_pc+=(Char)imm_operand(reg_pc+1)+2; + cycles+=4; + } + break; + case 0x51: + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp ^= zpindy_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=10; + } else { + chk_flnz_8bit(reg_a ^= zpindy_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x52: /* eor_zpind, AM_ZPIND, "EOR" */ + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp ^= zpind_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=10; + } else { + chk_flnz_8bit(reg_a ^= zpind_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x53: /* tam, AM_IMMED, "TAM" */ + { + UInt16 i; + UChar bitfld = imm_operand(reg_pc+1); + for (i = 0; i < 8; i++) { + if (bitfld & (1 << i)) { + mmr[i] = reg_a; + bank_set(i, reg_a); + } + } + reg_p &= ~FL_T; + reg_pc+=2; + cycles+=5; + } + break; + case 0x54: /* nop, AM_IMPL, "CSL" */ + reg_p &= ~FL_T; + reg_pc++; + cycles+=2; + break; + case 0x55: + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp ^= zpx_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=7; + } else { + chk_flnz_8bit(reg_a ^= zpx_operand(reg_pc+1)); + cycles+=4; + } + reg_pc+=2; + break; + case 0x56: + { + UChar zp_addr = imm_operand(reg_pc+1)+reg_x; + UChar temp1 = get_8bit_zp(zp_addr); + UChar temp = temp1/2; + reg_p = CLEAR_NTZC | SET_C01(temp1) | flnz_list[temp]; + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + cycles+=6; + } + break; + case 0x57: + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) & (~0x20)); + reg_pc+=2; + cycles+=7; + } + break; + case 0x58: + reg_p &= ~(FL_T|FL_I); + reg_pc++; + cycles+=2; + break; + case 0x59: + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp ^= absy_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=8; + } else { + chk_flnz_8bit(reg_a ^= absy_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x5A: + reg_p &= ~FL_T; + push_8bit(reg_y); + reg_pc++; + cycles+=3; + break; + case 0x5B: + handle_bp5(); + break; + case 0x5C: /* halt, AM_IMPL, "???" */ + err = 1; + break; + case 0x5D: + if (IS_SET_T) { + UChar temp = get_8bit_zp(reg_x); + chk_flnz_8bit(temp ^= absx_operand(reg_pc+1)); + put_8bit_zp(reg_x, temp); + cycles+=8; + } else { + chk_flnz_8bit(reg_a ^= absx_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x5E: + { + UInt16 temp_addr = get_16bit_addr(reg_pc+1)+reg_x; + UChar temp1 = get_8bit_addr(temp_addr); + UChar temp = temp1/2; + reg_p = CLEAR_NTZC | SET_C01(temp1) | flnz_list[temp]; + cycles+=7; + put_8bit_addr(temp_addr, temp); + reg_pc+=3; + } + break; + case 0x5F: /* bbr5, AM_PSREL, "BBR5" */ + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x20) { + reg_pc+=3; + cycles+=6; + } else { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } + break; + case 0x60: /* rts, AM_IMPL, "RTS" */ + reg_p &= ~FL_T; + reg_pc = pull_16bit()+1; + cycles+=7; + break; + case 0x61: /* adc_zpindx, AM_ZPINDX, "ADC" */ + if (IS_SET_T) { + put_8bit_zp(reg_x, adc(get_8bit_zp(reg_x), zpindx_operand(reg_pc+1))); + cycles+=10; + } else { + reg_a = adc(reg_a, zpindx_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x62: /* cla, AM_IMPL, "CLA" */ + reg_p &= ~FL_T; + reg_a = 0; + reg_pc++; + cycles+=2; + break; + case 0x63: /* halt, AM_IMPL, "???" */ + err = 1; + break; + case 0x64: + reg_p &= ~FL_T; + put_8bit_zp(imm_operand(reg_pc+1), 0); + reg_pc+=2; + cycles+=4; + break; + case 0x65: + if (IS_SET_T) { + put_8bit_zp(reg_x, adc(get_8bit_zp(reg_x), zp_operand(reg_pc+1))); + cycles+=7; + } else { + reg_a = adc(reg_a, zp_operand(reg_pc+1)); + cycles+=4; + } + reg_pc+=2; + break; + case 0x66: + { + UChar flg_tmp = GET_C80; + UChar zp_addr = imm_operand(reg_pc+1); + UChar temp1 = get_8bit_zp(zp_addr); + UChar temp = (temp1/2)+flg_tmp; + reg_p = CLEAR_NTZC | SET_C01(temp1) | flnz_list[temp]; + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + cycles+=6; + } + break; + case 0x67: /* rmb6, AM_ZP, "RMB6" */ + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) & (~0x40)); + reg_pc+=2; + cycles+=7; + } + break; + case 0x68: /* pla, AM_IMPL, "PLA" */ + chk_flnz_8bit(reg_a = pull_8bit()); + reg_pc++; + cycles+=4; + break; + case 0x69: /* adc_imm, AM_IMMED, "ADC" */ + if (IS_SET_T) { + put_8bit_zp(reg_x, adc(get_8bit_zp(reg_x), imm_operand(reg_pc+1))); + cycles+=5; + } else { + reg_a = adc(reg_a, imm_operand(reg_pc+1)); + cycles+=2; + } + reg_pc+=2; + break; + case 0x6A: + { + UChar flg_tmp = GET_C80; + UChar temp = reg_a; + reg_a = (reg_a/2)+flg_tmp; + reg_p = CLEAR_NTZC | SET_C01(temp) | flnz_list[reg_a]; + reg_pc++; + cycles+=2; + } + break; + case 0x6B: + handle_bp6(); + break; + case 0x6C: + reg_p &= ~FL_T; + reg_pc = get_16bit_addr(get_16bit_addr(reg_pc+1)); + cycles+=7; + break; + case 0x6D: + if (IS_SET_T) { + put_8bit_zp(reg_x, adc(get_8bit_zp(reg_x), abs_operand(reg_pc+1))); + cycles+=8; + } else { + reg_a = adc(reg_a, abs_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x6E: + { + UChar flg_tmp = GET_C80; + UInt16 temp_addr = get_16bit_addr(reg_pc+1); + UChar temp1 = get_8bit_addr(temp_addr); + UChar temp = (temp1/2)+flg_tmp; + reg_p = CLEAR_NTZC | SET_C01(temp1) | flnz_list[temp]; + cycles+=7; + put_8bit_addr(temp_addr, temp); + reg_pc+=3; + } + break; + case 0x6F: + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x40) { + reg_pc+=3; + cycles+=6; + } else { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } + break; + case 0x70: + reg_p &= ~FL_T; + if (IS_SET_V) { + reg_pc+=(Char)imm_operand(reg_pc+1)+2; + cycles+=4; + } else { + reg_pc+=2; + cycles+=2; + } + break; + case 0x71: + if (IS_SET_T) { + put_8bit_zp(reg_x, adc(get_8bit_zp(reg_x), zpindy_operand(reg_pc+1))); + cycles+=10; + } else { + reg_a = adc(reg_a, zpindy_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x72: + if (IS_SET_T) { + put_8bit_zp(reg_x, adc(get_8bit_zp(reg_x), zpind_operand(reg_pc+1))); + cycles+=10; + } else { + reg_a = adc(reg_a, zpind_operand(reg_pc+1)); + cycles+=7; + } + reg_pc+=2; + break; + case 0x73: + { + UInt16 from, to, len; + reg_p &= ~FL_T; + from = get_16bit_addr(reg_pc+1); + to = get_16bit_addr(reg_pc+3); + len = get_16bit_addr(reg_pc+5); + cycles+=(6 * len) + 17; + while (len-- != 0) { + put_8bit_addr(to++, get_8bit_addr(from++)); + } + reg_pc+=7; + } + break; + case 0x74: + reg_p &= ~FL_T; + put_8bit_zp(imm_operand(reg_pc+1)+reg_x, 0); + reg_pc+=2; + cycles+=4; + break; + case 0x75: + if (IS_SET_T) { + put_8bit_zp(reg_x, adc(get_8bit_zp(reg_x), zpx_operand(reg_pc+1))); + cycles+=7; + } else { + reg_a = adc(reg_a, zpx_operand(reg_pc+1)); + cycles+=4; + } + reg_pc+=2; + break; + case 0x76: + { + UChar flg_tmp = GET_C80; + UChar zp_addr = imm_operand(reg_pc+1)+reg_x; + UChar temp1 = get_8bit_zp(zp_addr); + UChar temp = (temp1/2)+flg_tmp; + reg_p = CLEAR_NTZC | SET_C01(temp1) | flnz_list[temp]; + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + cycles+=6; + } + break; + case 0x77: + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) & (~0x80)); + reg_pc+=2; + cycles+=7; + } + break; + case 0x78: + reg_p = (reg_p|FL_I) & ~FL_T; + reg_pc++; + cycles+=2; + break; + case 0x79: /* adc_absy, AM_ABSY, "ADC" */ + if (IS_SET_T) { + put_8bit_zp(reg_x, adc(get_8bit_zp(reg_x), absy_operand(reg_pc+1))); + cycles+=8; + } else { + reg_a = adc(reg_a, absy_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x7A: /* ply, AM_IMPL, "PLY" */ + chk_flnz_8bit(reg_y = pull_8bit()); + reg_pc++; + cycles+=4; + break; + case 0x7B: /* handle_bp7, AM_IMPL, "BP7" */ + handle_bp7(); + break; + case 0x7C: /* jmp_absindx,AM_ABSINDX, "JMP" */ + reg_p &= ~FL_T; + reg_pc = get_16bit_addr(get_16bit_addr(reg_pc+1)+reg_x); + cycles+=7; + break; + case 0x7D: /* adc_absx, AM_ABSX, "ADC" */ + if (IS_SET_T) { + put_8bit_zp(reg_x, adc(get_8bit_zp(reg_x), absx_operand(reg_pc+1))); + cycles+=8; + } else { + reg_a = adc(reg_a, absx_operand(reg_pc+1)); + cycles+=5; + } + reg_pc+=3; + break; + case 0x7E: + { + UChar flg_tmp = GET_C80; + UInt16 temp_addr = get_16bit_addr(reg_pc+1)+reg_x; + UChar temp1 = get_8bit_addr(temp_addr); + UChar temp = (temp1/2)+flg_tmp; + reg_p = CLEAR_NTZC | SET_C01(temp1) | flnz_list[temp]; + cycles+=7; + put_8bit_addr(temp_addr, temp); + reg_pc+=3; + } + break; + case 0x7F: + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x80) { + reg_pc+=3; + cycles+=6; + } else { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } + break; + case 0x80: + reg_p &= ~FL_T; + reg_pc+=(Char)imm_operand(reg_pc+1)+2; + cycles+=4; + break; + case 0x81: + reg_p &= ~FL_T; + cycles+=7; + put_8bit_addr(get_16bit_zp(imm_operand(reg_pc+1)+reg_x), reg_a); + reg_pc+=2; + break; + case 0x82: + reg_p &= ~FL_T; + reg_x = 0; + reg_pc++; + cycles+=2; + break; + case 0x83: /* tstins_zp, AM_TST_ZP, "TST" */ + { + UChar imm = imm_operand(reg_pc+1); + UChar temp = zp_operand(reg_pc+2); + reg_p = CLEAR_NVTZ | SET_NV(temp) | SET_Z(temp&imm); + cycles+=7; + reg_pc+=3; + } + break; + case 0x84: /* sty_zp, AM_ZP, "STY" */ + reg_p &= ~FL_T; + put_8bit_zp(imm_operand(reg_pc+1), reg_y); + reg_pc+=2; + cycles+=4; + break; + case 0x85: /* sta_zp, AM_ZP, "STA" */ + reg_p &= ~FL_T; + put_8bit_zp(imm_operand(reg_pc+1), reg_a); + reg_pc+=2; + cycles+=4; + break; + case 0x86: /* stx_zp, AM_ZP, "STX" */ + reg_p &= ~FL_T; + put_8bit_zp(imm_operand(reg_pc+1), reg_x); + reg_pc+=2; + cycles+=4; + break; + case 0x87: + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) | 0x01); + reg_pc+=2; + cycles+=7; + } + break; + case 0x88: + chk_flnz_8bit(--reg_y); + reg_pc++; + cycles+=2; + break; + case 0x89: + { + UChar temp = imm_operand(reg_pc+1); + reg_p = CLEAR_NVTZ | SET_NV(temp) | SET_Z(reg_a&temp); + reg_pc+=2; + cycles+=2; + } + break; + case 0x8A: + chk_flnz_8bit(reg_a = reg_x); + reg_pc++; + cycles+=2; + break; + case 0x8B: + handle_bp8(); + break; + case 0x8C: + reg_p &= ~FL_T; + cycles+=5; + put_8bit_addr(get_16bit_addr(reg_pc+1), reg_y); + reg_pc+=3; + break; + case 0x8D: + reg_p &= ~FL_T; + cycles+=5; + put_8bit_addr(get_16bit_addr(reg_pc+1), reg_a); + reg_pc+=3; + break; + case 0x8E: + reg_p &= ~FL_T; + cycles+=5; + put_8bit_addr(get_16bit_addr(reg_pc+1), reg_x); + reg_pc+=3; + break; + case 0x8F: + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x01) { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } else { + reg_pc+=3; + cycles+=6; + } + break; + case 0x90: + reg_p &= ~FL_T; + if (IS_SET_C) { + reg_pc+=2; + cycles+=2; + } else { + reg_pc+=(Char)imm_operand(reg_pc+1)+2; + cycles+=4; + } + break; + case 0x91: + reg_p &= ~FL_T; + cycles+=7; + put_8bit_addr(get_16bit_zp(imm_operand(reg_pc+1))+reg_y, reg_a); + reg_pc+=2; + break; + case 0x92: + reg_p &= ~FL_T; + cycles+=7; + put_8bit_addr(get_16bit_zp(imm_operand(reg_pc+1)), reg_a); + reg_pc+=2; + break; + case 0x93: + { + UChar imm = imm_operand(reg_pc+1); + UChar temp = abs_operand(reg_pc+2); + reg_p = CLEAR_NVTZ | SET_NV(temp) | SET_Z(temp&imm); + cycles+=8; + reg_pc+=4; + break; + } + case 0x94: + reg_p &= ~FL_T; + put_8bit_zp(imm_operand(reg_pc+1)+reg_x, reg_y); + reg_pc+=2; + cycles+=4; + break; + case 0x95: + reg_p &= ~FL_T; + put_8bit_zp(imm_operand(reg_pc+1)+reg_x, reg_a); + reg_pc+=2; + cycles+=4; + break; + case 0x96: + reg_p &= ~FL_T; + put_8bit_zp(imm_operand(reg_pc+1)+reg_y, reg_x); + reg_pc+=2; + cycles+=4; + break; + case 0x97: + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) | 0x02); + reg_pc+=2; + cycles+=7; + } + break; + case 0x98: + chk_flnz_8bit(reg_a = reg_y); + reg_pc++; + cycles+=2; + break; + case 0x99: + reg_p &= ~FL_T; + cycles+=5; + put_8bit_addr(get_16bit_addr(reg_pc+1)+reg_y, reg_a); + reg_pc+=3; + break; + case 0x9A: + reg_p &= ~FL_T; + reg_s = reg_x; + reg_pc++; + cycles+=2; + break; + case 0x9B: + handle_bp9(); + break; + case 0x9C: + reg_p &= ~FL_T; + cycles+=5; + put_8bit_addr(get_16bit_addr(reg_pc+1), 0); + reg_pc+=3; + break; + case 0x9D: + reg_p &= ~FL_T; + cycles+=5; + put_8bit_addr(get_16bit_addr(reg_pc+1)+reg_x, reg_a); + reg_pc+=3; + break; + case 0x9E: + reg_p &= ~FL_T; + cycles+=5; + put_8bit_addr((get_16bit_addr(reg_pc+1)+reg_x), 0); + reg_pc+=3; + break; + case 0x9F: + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x02) { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } else { + reg_pc+=3; + cycles+=6; + } + break; + case 0xA0: + chk_flnz_8bit(reg_y = imm_operand(reg_pc+1)); + reg_pc+=2; + cycles+=2; + break; + case 0xA1: + chk_flnz_8bit(reg_a = zpindx_operand(reg_pc+1)); + reg_pc+=2; + cycles+=7; + break; + case 0xA2: + chk_flnz_8bit(reg_x = imm_operand(reg_pc+1)); + reg_pc+=2; + cycles+=2; + break; + case 0xA3: /* tstins_zpx, AM_TST_ZPX, "TST" */ + { + UChar imm = imm_operand(reg_pc+1); + UChar temp = zpx_operand(reg_pc+2); + reg_p = CLEAR_NVTZ | SET_NV(temp) | SET_Z(temp&imm); + cycles+=7; + reg_pc+=3; + } + break; + case 0xA4: /* ldy_zp, AM_ZP, "LDY" */ + chk_flnz_8bit(reg_y = zp_operand(reg_pc+1)); + reg_pc+=2; + cycles+=4; + break; + case 0xA5: /* lda_zp, AM_ZP, "LDA" */ + chk_flnz_8bit(reg_a = zp_operand(reg_pc+1)); + reg_pc+=2; + cycles+=4; + break; + case 0xA6: /* ldx_zp, AM_ZP, "LDX" */ + chk_flnz_8bit(reg_x = zp_operand(reg_pc+1)); + reg_pc+=2; + cycles+=4; + break; + case 0xA7: /* smb2, AM_ZP, "SMB2" */ + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) | 0x04); + reg_pc+=2; + cycles+=7; + } + break; + case 0xA8: + chk_flnz_8bit(reg_y = reg_a); + reg_pc++; + cycles+=2; + break; + case 0xA9: + chk_flnz_8bit(reg_a = imm_operand(reg_pc+1)); + reg_pc+=2; + cycles+=2; + break; + case 0xAA: + chk_flnz_8bit(reg_x = reg_a); + reg_pc++; + cycles+=2; + break; + case 0xAB: + handle_bp10(); + break; + case 0xAC: + chk_flnz_8bit(reg_y = abs_operand(reg_pc+1)); + reg_pc+=3; + cycles+=5; + break; + case 0xAD: + chk_flnz_8bit(reg_a = abs_operand(reg_pc+1)); + reg_pc+=3; + cycles+=5; + break; + case 0xAE: + chk_flnz_8bit(reg_x = abs_operand(reg_pc+1)); + reg_pc+=3; + cycles+=5; + break; + case 0xAF: + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x04) { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } else { + reg_pc+=3; + cycles+=6; + } + break; + case 0xB0: /* bcs, AM_REL, "BCS" */ + reg_p &= ~FL_T; + if (IS_SET_C) { + reg_pc+=(Char)imm_operand(reg_pc+1)+2; + cycles+=4; + } else { + reg_pc+=2; + cycles+=2; + } + break; + case 0xB1: /* lda_zpindy, AM_ZPINDY, "LDA" */ + chk_flnz_8bit(reg_a = zpindy_operand(reg_pc+1)); + reg_pc+=2; + cycles+=7; + break; + case 0xB2: /* lda_zpind, AM_ZPIND, "LDA" */ + chk_flnz_8bit(reg_a = zpind_operand(reg_pc+1)); + reg_pc+=2; + cycles+=7; + break; + case 0xB3: /* tstins_absx,AM_TST_ABSX,"TST" */ + { + UChar imm = imm_operand(reg_pc+1); + UChar temp = absx_operand(reg_pc+2); + reg_p = CLEAR_NVTZ | SET_NV(temp) | SET_Z(temp&imm); + cycles+=8; + reg_pc+=4; + } + break; + case 0xB4: + chk_flnz_8bit(reg_y = zpx_operand(reg_pc+1)); + reg_pc+=2; + cycles+=4; + break; + case 0xB5: + chk_flnz_8bit(reg_a = zpx_operand(reg_pc+1)); + reg_pc+=2; + cycles+=4; + break; + case 0xB6: /* ldx_zpy, AM_ZPY, "LDX" */ + chk_flnz_8bit(reg_x = zpy_operand(reg_pc+1)); + reg_pc+=2; + cycles+=4; + break; + case 0xB7: /* smb3, AM_ZP, "SMB3" */ + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) | 0x08); + reg_pc+=2; + cycles+=7; + } + break; + case 0xB8: /* clv, AM_IMPL, "CLV" */ + reg_p &= ~(FL_V|FL_T); + reg_pc++; + cycles+=2; + break; + case 0xB9: /* lda_absy, AM_ABSY, "LDA" */ + chk_flnz_8bit(reg_a = absy_operand(reg_pc+1)); + reg_pc+=3; + cycles+=5; + break; + case 0xBA: /* tsx, AM_IMPL, "TSX" */ + chk_flnz_8bit(reg_x = reg_s); + reg_pc++; + cycles+=2; + break; + case 0xBB: /* handle_bp11,AM_IMPL, "BPB" */ + handle_bp11(); + break; + case 0xBC: /* ldy_absx, AM_ABSX, "LDY" */ + chk_flnz_8bit(reg_y = absx_operand(reg_pc+1)); + reg_pc+=3; + cycles+=5; + break; + case 0xBD: /* lda_absx, AM_ABSX, "LDA" */ + chk_flnz_8bit(reg_a = absx_operand(reg_pc+1)); + reg_pc+=3; + cycles+=5; + break; + case 0xBE: /* ldx_absy, AM_ABSY, "LDX" */ + chk_flnz_8bit(reg_x = absy_operand(reg_pc+1)); + reg_pc+=3; + cycles+=5; + break; + case 0xBF: /* bbs3, AM_PSREL, "BBS3" */ + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x08) { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } else { + reg_pc+=3; + cycles+=6; + } + break; + case 0xC0: /* cpy_imm, AM_IMMED, "CPY" */ + { + UChar temp = imm_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_y < temp) | flnz_list[(UChar)(reg_y-temp)]; + reg_pc+=2; + cycles+=2; + } + break; + case 0xC1: /* cmp_zpindx, AM_ZPINDX, "CMP" */ + { + UChar temp = zpindx_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_a < temp) | flnz_list[(UChar)(reg_a-temp)]; + reg_pc+=2; + cycles+=7; + } + break; + case 0xC2: + reg_p &= ~FL_T; + reg_y = 0; + reg_pc++; + cycles+=2; + break; + case 0xC3: + { + UInt16 from, to, len; + reg_p &= ~FL_T; + from = get_16bit_addr(reg_pc+1); + to = get_16bit_addr(reg_pc+3); + len = get_16bit_addr(reg_pc+5); + cycles+=(6 * len) + 17; + while (len-- != 0) { + put_8bit_addr(to--, get_8bit_addr(from--)); + } + reg_pc+=7; + } + break; + case 0xC4: + { + UChar temp = zp_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_y < temp) | flnz_list[(UChar)(reg_y-temp)]; + reg_pc+=2; + cycles+=4; + } + break; + case 0xC5: + { + UChar temp = zp_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_a < temp) | flnz_list[(UChar)(reg_a-temp)]; + reg_pc+=2; + cycles+=4; + } + break; + case 0xC6: + { + UChar temp; + UChar zp_addr = imm_operand(reg_pc+1); + chk_flnz_8bit(temp = get_8bit_zp(zp_addr)-1); + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + cycles+=6; + } + break; + case 0xC7: + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) | 0x10); + reg_pc+=2; + cycles+=7; + } + break; + case 0xC8: + chk_flnz_8bit(++reg_y); + reg_pc++; + cycles+=2; + break; + case 0xC9: + { + UChar temp = imm_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_a < temp) | flnz_list[(UChar)(reg_a-temp)]; + reg_pc+=2; + cycles+=2; + } + break; + case 0xCA: + chk_flnz_8bit(--reg_x); + reg_pc++; + cycles+=2; + break; + case 0xCB: + handle_bp12(); + break; + case 0xCC: + { + UChar temp = abs_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_y < temp) | flnz_list[(UChar)(reg_y-temp)]; + reg_pc+=3; + cycles+=5; + } + break; + case 0xCD: + { + UChar temp = abs_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_a < temp) | flnz_list[(UChar)(reg_a-temp)]; + reg_pc+=3; + cycles+=5; + } + break; + case 0xCE: + { + UChar temp; + UInt16 temp_addr = get_16bit_addr(reg_pc+1); + chk_flnz_8bit(temp = get_8bit_addr(temp_addr)-1); + cycles+=7; + put_8bit_addr(temp_addr, temp); + reg_pc+=3; + } + break; + case 0xCF: + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x10) { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } else { + reg_pc+=3; + cycles+=6; + } + break; + case 0xD0: /* bne, AM_REL, "BNE" */ + reg_p &= ~FL_T; + if (IS_SET_Z) { + reg_pc+=2; + cycles+=2; + } else { + reg_pc+=(Char)imm_operand(reg_pc+1)+2; + cycles+=4; + } + break; + case 0xD1: /* cmp_zpindy, AM_ZPINDY, "CMP" */ + { + UChar temp = zpindy_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_a < temp) | flnz_list[(UChar)(reg_a-temp)]; + reg_pc+=2; + cycles+=7; + } + break; + case 0xD2: /* cmp_zpind, AM_ZPIND, "CMP" */ + { + UChar temp = zpind_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_a < temp) | flnz_list[(UChar)(reg_a-temp)]; + reg_pc+=2; + cycles+=7; + } + break; + case 0xD3: /* tin, AM_XFER, "TIN" */ + { + UInt16 from, to, len; + reg_p &= ~FL_T; + from = get_16bit_addr(reg_pc+1); + to = get_16bit_addr(reg_pc+3); + len = get_16bit_addr(reg_pc+5); + cycles+=(6 * len) + 17; + while (len-- != 0) { + put_8bit_addr(to, get_8bit_addr(from++)); + } + reg_pc+=7; + } + break; + case 0xD4: + reg_p &= ~FL_T; + reg_pc++; + cycles+=2; + break; + case 0xD5: + { + UChar temp = zpx_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_a < temp) | flnz_list[(UChar)(reg_a-temp)]; + reg_pc+=2; + cycles+=4; + } + break; + case 0xD6: + { + UChar temp; + UChar zp_addr = imm_operand(reg_pc+1)+reg_x; + chk_flnz_8bit(temp = get_8bit_zp(zp_addr)-1); + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + cycles+=6; + } + break; + case 0xD7: + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) | 0x20); + reg_pc+=2; + cycles+=7; + } + break; + case 0xD8: + reg_p &= ~(FL_T|FL_D); + reg_pc++; + cycles+=2; + break; + case 0xD9: + { + UChar temp = absy_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_a < temp) | flnz_list[(UChar)(reg_a-temp)]; + reg_pc+=3; + cycles+=5; + } + break; + case 0xDA: + reg_p &= ~FL_T; + push_8bit(reg_x); + reg_pc++; + cycles+=3; + break; + case 0xDB: + handle_bp13(); + break; + case 0xDC: /* halt, AM_IMPL, "???" */ + err = 1; + break; + case 0xDD: + { + UChar temp = absx_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_a < temp) | flnz_list[(UChar)(reg_a-temp)]; + reg_pc+=3; + cycles+=5; + } + break; + case 0xDE: + { + UChar temp; + UInt16 temp_addr = get_16bit_addr(reg_pc+1)+reg_x; + chk_flnz_8bit(temp = get_8bit_addr(temp_addr)-1); + cycles+=7; + put_8bit_addr(temp_addr, temp); + reg_pc+=3; + } + break; + case 0xDF: + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x20) { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } else { + reg_pc+=3; + cycles+=6; + } + break; + case 0xE0: + { + UChar temp = imm_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_x < temp) | flnz_list[(UChar)(reg_x-temp)]; + reg_pc+=2; + cycles+=2; + } + break; + case 0xE1: + sbc(zpindx_operand(reg_pc+1)); + reg_pc+=2; + cycles+=7; + break; + case 0xE2: /* halt, AM_IMPL, "???" */ + err = 1; + break; + case 0xE3: + { + UInt16 from, to, len, alternate; + reg_p &= ~FL_T; + from = get_16bit_addr(reg_pc+1); + to = get_16bit_addr(reg_pc+3); + len = get_16bit_addr(reg_pc+5); + alternate = 0; + cycles+=(6 * len) + 17; + while (len-- != 0) { + put_8bit_addr(to+alternate, get_8bit_addr(from++)); + alternate ^= 1; + } + reg_pc+=7; + } + break; + case 0xE4: + { + UChar temp = zp_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_x < temp) | flnz_list[(UChar)(reg_x-temp)]; + reg_pc+=2; + cycles+=4; + } + break; + case 0xE5: + sbc(zp_operand(reg_pc+1)); + reg_pc+=2; + cycles+=4; + break; + case 0xE6: + { + UChar temp; + UChar zp_addr = imm_operand(reg_pc+1); + chk_flnz_8bit(temp = get_8bit_zp(zp_addr)+1); + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + cycles+=6; + } + break; + case 0xE7: + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) | 0x40); + reg_pc+=2; + cycles+=7; + } + break; + case 0xE8: + chk_flnz_8bit(++reg_x); + reg_pc++; + cycles+=2; + break; + case 0xE9: + sbc(imm_operand(reg_pc+1)); + reg_pc+=2; + cycles+=2; + break; + case 0xEA: + reg_p &= ~FL_T; + reg_pc++; + cycles+=2; + break; + case 0xEB: + handle_bp14(); + break; + case 0xEC: + { + UChar temp = abs_operand(reg_pc+1); + reg_p = CLEAR_NTZC | SET_CTST(reg_x < temp) | flnz_list[(UChar)(reg_x-temp)]; + reg_pc+=3; + cycles+=5; + } + break; + case 0xED: + sbc(abs_operand(reg_pc+1)); + reg_pc+=3; + cycles+=5; + break; + case 0xEE: /* inc_abs, AM_ABS, "INC" */ + { + UChar temp; + UInt16 temp_addr = get_16bit_addr(reg_pc+1); + chk_flnz_8bit(temp = get_8bit_addr(temp_addr)+1); + cycles+=7; + put_8bit_addr(temp_addr, temp); + reg_pc+=3; + } + break; + case 0xEF: /* bbs6, AM_PSREL, "BBS6" */ + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x40) { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } else { + reg_pc+=3; + cycles+=6; + } + break; + case 0xF0: /* beq, AM_REL, "BEQ" */ + reg_p &= ~FL_T; + if (IS_SET_Z) { + reg_pc+=(Char)imm_operand(reg_pc+1)+2; + cycles+=4; + } else { + reg_pc+=2; + cycles+=2; + } + break; + case 0xF1: /* sbc_zpindy, AM_ZPINDY, "SBC" */ + sbc(zpindy_operand(reg_pc+1)); + reg_pc+=2; + cycles+=7; + break; + case 0xF2: + sbc(zpind_operand(reg_pc+1)); + reg_pc+=2; + cycles+=7; + break; + case 0xF3: + { + UInt16 from, to, len, alternate; + reg_p &= ~FL_T; + from = get_16bit_addr(reg_pc+1); + to = get_16bit_addr(reg_pc+3); + len = get_16bit_addr(reg_pc+5); + alternate = 0; + cycles+=(6 * len) + 17; + while (len-- != 0) { + put_8bit_addr(to++, get_8bit_addr(from+alternate)); + alternate ^= 1; + } + reg_pc+=7; + } + break; + case 0xF4: + reg_p |= FL_T; + reg_pc++; + cycles+=2; + break; + case 0xF5: + sbc(zpx_operand(reg_pc+1)); + reg_pc+=2; + cycles+=4; + break; + case 0xF6: + { + UChar temp; + UChar zp_addr = imm_operand(reg_pc+1)+reg_x; + chk_flnz_8bit(temp = get_8bit_zp(zp_addr)+1); + put_8bit_zp(zp_addr, temp); + reg_pc+=2; + cycles+=6; + } + break; + case 0xF7: + { + UChar temp = imm_operand(reg_pc+1); + reg_p &= ~FL_T; + put_8bit_zp(temp, get_8bit_zp(temp) | 0x80); + reg_pc+=2; + cycles+=7; + } + break; + case 0xF8: /* sed, AM_IMPL, "SED" */ + reg_p = (reg_p|FL_D) & ~FL_T; + reg_pc++; + cycles+=2; + break; + case 0xF9: /* sbc_absy, AM_ABSY, "SBC" */ + sbc(absy_operand(reg_pc+1)); + reg_pc+=3; + cycles+=5; + break; + case 0xFA: /* plx, AM_IMPL, "PLX" */ + chk_flnz_8bit(reg_x = pull_8bit()); + reg_pc++; + cycles+=4; + break; + case 0xFB: /* handle_bp15,AM_IMPL, "BPF" */ + handle_bp15(); + break; + case 0xFC: /* handle_bios,AM_IMPL, "???" */ + handle_bios(); + break; + case 0xFD: /* sbc_absx, AM_ABSX, "SBC" */ + sbc(absx_operand(reg_pc+1)); + reg_pc+=3; + cycles+=5; + break; + case 0xFE: + { + UChar temp; + UInt16 temp_addr = get_16bit_addr(reg_pc+1)+reg_x; + chk_flnz_8bit(temp = get_8bit_addr(temp_addr)+1); + cycles+=7; + put_8bit_addr(temp_addr, temp); + reg_pc+=3; + } + break; + case 0xFF: + reg_p &= ~FL_T; + if (zp_operand(reg_pc+1)&0x80) { + reg_pc+=(Char)imm_operand(reg_pc+2)+3; + cycles+=8; + } else { + reg_pc+=3; + cycles+=6; + } + break; + } +#if STANDALONE +} +#endif + +#undef adc +#undef sbc --- hugo-2.12/list_rom.c 2004-05-26 22:54:15.000000000 +0200 +++ hugo-2.13-pre/list_rom.c 2005-10-27 10:14:46.000000000 +0200 @@ -9769,7 +9769,7 @@ if (pce_romlist_size < 1) { - fprintf(stdout, "Invalid number of roms specified in roms.db (%d)\n", i); + fprintf(stdout, "Invalid number of roms specified in roms.db (%d)\n", pce_romlist_size); return; } @@ -9806,7 +9808,7 @@ } pce_romlist[i].note = strdup(line); - if (fscanf(rlf, "%d\n", &pce_romlist[i].flags) == EOF) { + if (fscanf(rlf, "%hd\n", &pce_romlist[i].flags) == EOF) { pce_build_romlist_fail(rlf, i); return; } --- hugo-2.12/miniunz.c 2005-03-28 16:10:48.000000000 +0200 +++ hugo-2.13-pre/miniunz.c 2005-10-27 15:40:52.000000000 +0200 @@ -129,7 +129,6 @@ char *filename_withoutpath; char *p; int err = UNZ_OK; - FILE *fout = NULL; void *buf; uInt size_buf; unz_file_info file_info; @@ -149,7 +148,9 @@ if (buf == NULL) { Log ("Error allocating memory\n"); - return UNZ_INTERNALERROR; + return (char*)UNZ_INTERNALERROR; + // ugly as hell (should return null) + // and use some err variable (passed as arg or global like errno) } p = filename_withoutpath = filename_inzip; @@ -163,7 +164,6 @@ if ((*filename_withoutpath) != '\0') { const char *write_filename; - int skip = 0; write_filename = filename_withoutpath; @@ -247,7 +247,6 @@ size_t * unzipped_size) { unzFile uf; - int err; char *return_value; if (zipfilename == NULL) --- hugo-2.12/miniunz.h 2005-03-28 16:12:30.000000000 +0200 +++ hugo-2.13-pre/miniunz.h 2005-09-27 19:58:15.000000000 +0200 @@ -20,7 +20,7 @@ char *find_possible_filename_in_zip (char *zipfilename); //! Extract file content from zip archive -int extract_file_in_memory (char *zipfilename, char *archivedfile, - size_t * unzipped_size); +char* extract_file_in_memory (char *zipfilename, char *archivedfile, + size_t * unzipped_size); #endif --- hugo-2.12/mix.c 2003-11-12 22:39:40.000000000 +0100 +++ hugo-2.13-pre/mix.c 2005-10-27 10:14:46.000000000 +0200 @@ -472,7 +472,7 @@ } -void WriteBuffer(char *buf, int ch, unsigned dwSize) +void WriteBuffer(SChar *buf, int ch, unsigned dwSize) { static UInt32 fixed_n[6] = { 0, 0, 0, 0, 0, 0 }; UInt32 fixed_inc; @@ -501,7 +501,7 @@ */ 0, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 21, 24, 27, 31, 35, 39, 44, 50, 56, 64 }; - UInt16 lbal, rbal; + UInt16 lbal, rbal = 0; SChar sample; if (!(io.PSG[ch][PSG_DDA_REG] & PSG_DDA_ENABLE) || io.psg_channel_disabled[ch]) --- hugo-2.12/mix.h 2003-10-15 00:02:58.000000000 +0200 +++ hugo-2.13-pre/mix.h 2005-10-27 09:30:58.000000000 +0200 @@ -4,7 +4,7 @@ #include "pce.h" #include "sound.h" -void (*update_sound[4])(); +extern void (*update_sound[4])(); UInt32 WriteBufferAdpcm8(UChar *buf, UInt32 begin, @@ -13,8 +13,8 @@ SInt32* PreviousValue ); -void WriteBuffer(char *buf, - int ch, - unsigned dwSize); +void WriteBuffer(SChar *buf, + int ch, + unsigned dwSize); #endif --- hugo-2.12/netplay.c 2004-06-15 22:01:39.000000000 +0200 +++ hugo-2.13-pre/netplay.c 2005-10-27 15:40:52.000000000 +0200 @@ -16,6 +16,14 @@ #include "netplay.h" +#include <stdlib.h> +#include <string.h> + +#if defined(GTK) +#include <gtk/gtk.h> +#endif + + extern int gtk_stop_asked; #define DEBUG @@ -387,7 +395,7 @@ #endif return 1; default: - fprintf (stderr, "Internal warning: impossible case (%s:%s)\n", + fprintf (stderr, "Internal warning: impossible case (%s:%d)\n", __FILE__, __LINE__); return 0; } --- hugo-2.12/osd_keyboard.c 2005-03-12 14:32:30.000000000 +0100 +++ hugo-2.13-pre/osd_keyboard.c 2005-10-27 10:14:46.000000000 +0200 @@ -1,6 +1,7 @@ #include "osd_keyboard.h" #include "hard_pce.h" #include "sound.h" +#include "utils.h" #if defined(NETPLAY_DEBUG) #include <sys/timeb.h> @@ -2064,8 +2065,6 @@ int handle_digest_packet () { - - int allocated_slots; int input_index; if (incoming_packet->len != PACKET_STATUS_LENGTH) --- hugo-2.12/osd_linux_sdl_machine.c 2005-04-05 21:53:14.000000000 +0200 +++ hugo-2.13-pre/osd_linux_sdl_machine.c 2005-10-27 09:30:58.000000000 +0200 @@ -11,7 +11,7 @@ UChar gamepad = 0; // gamepad detected ? -UChar* XBuf; +extern UChar* XBuf; // The screen buffer where we draw before blitting it on screen int gamepad_driver = 0; --- hugo-2.12/pce.c 2005-03-28 16:17:45.000000000 +0200 +++ hugo-2.13-pre/pce.c 2005-10-27 10:14:46.000000000 +0200 @@ -159,33 +159,11 @@ char* server_hostname = NULL; -/* -#################################### -#################################### -#################################### -#################################### -2KILL :: BEGIN -#################################### -#################################### -#################################### -#################################### -*/ #if defined(EXTERNAL_DAT) && defined(ALLEGRO) DATAFILE *datafile; // A pointer to the datafile where we keep bitmaps... // Make things looks cleaner. #endif -/* -#################################### -#################################### -#################################### -#################################### -2KILL :: END -#################################### -#################################### -#################################### -#################################### -*/ char *bmdefault = NULL; // Name of the backup memory @@ -236,18 +214,6 @@ // beg_lsn -> beginning in number of sector (2048 bytes) // length -> number of sector -/* -#################################### -#################################### -#################################### -#################################### -2KILL :: END -#################################### -#################################### -#################################### -#################################### -*/ - volatile SChar key_delay = 0; // delay to avoid too many key strokes @@ -311,32 +277,9 @@ "PSELECT", "PRUN", "PAUTOI", "PAUTOII", "PXAXIS", "PYAXIS"}; - -/* -#################################### -#################################### -#################################### -#################################### -2KILL :: BEGIN -#################################### -#################################### -#################################### -#################################### -*/ #ifdef ALLEGRO PACKFILE *packed_iso_FILE = NULL; #endif -/* -#################################### -#################################### -#################################### -#################################### -2KILL :: END -#################################### -#################################### -#################################### -#################################### -*/ UInt32 packed_iso_filesize = 0; @@ -394,7 +337,7 @@ } -#if defined(ALLEGRO) +#if defined(ALLEGRO) || (MORPHOS) void interrupt_60hz (void) #elif defined(SDL) UInt32 interrupt_60hz (UInt32 interval, void *param) @@ -427,17 +370,6 @@ #endif }; -/* -#################################### -#################################### -#################################### -#################################### -2KILL :: BEGIN -#################################### -#################################### -#################################### -#################################### -*/ #ifdef ALLEGRO /* @@ -448,17 +380,6 @@ END_OF_FUNCTION (interrupt_60hz); #endif -/* -#################################### -#################################### -#################################### -#################################### -2KILL :: END -#################################### -#################################### -#################################### -#################################### -*/ #if defined(ALLEGRO) @@ -502,9 +423,9 @@ Date.da_mon, Date.da_year, __DATE__); #elif defined(LINUX) - Log ("Creating Linux log file version 2.12 of %s ($Revision: 1.66 $)\n", __DATE__); + Log ("Creating Linux log file version 2.12 of %s ($Revision: 1.69 $)\n", __DATE__); #elif defined(WIN32) - Log ("Creating Win32 log file version 2.12 of %s ($Revision: 1.66 $)\n", __DATE__); + Log ("Creating Win32 log file version 2.12 of %s ($Revision: 1.69 $)\n", __DATE__); #endif } @@ -559,9 +480,6 @@ break; } - - - // Now most track are audio for (current_track = 3; current_track < bcdbin[nb_max_track]; @@ -713,18 +631,6 @@ int result; UInt32 dummy; -/* -#################################### -#################################### -#################################### -#################################### -2KILL :: BEGIN -#################################### -#################################### -#################################### -#################################### -*/ - for (result = bcdbin[nb_max_track]; result > 0x01; result--) { if ((sector >= CD_track[binbcd[result]].beg_lsn) && @@ -741,7 +647,7 @@ } #ifndef FINAL_RELEASE - fprintf (stderr, "Loading sector n�%d.\n", pce_cd_sectoraddy); + fprintf (stderr, "Loading sector n %d.\n", pce_cd_sectoraddy); #endif dummy = (sector - CD_track[binbcd[result]].beg_lsn) * 2048; @@ -764,17 +670,6 @@ ISQ_position += 2048; #endif -/* -#################################### -#################################### -#################################### -#################################### -2KILL :: END -#################################### -#################################### -#################################### -#################################### -*/ } @@ -791,17 +686,17 @@ if (cd_buf != NULL) if ((sector >= first_sector) && - (sector <= first_sector + CD_BUF_LENGTH - 1)) + (sector <= first_sector + CD_BUF_LENGTH - 1)) { - memcpy (p, cd_buf + 2048 * (sector - first_sector), 2048); - return; - } + memcpy (p, cd_buf + 2048 * (sector - first_sector), 2048); + return; + } else { - for (i = 0; i < CD_BUF_LENGTH; i++) - osd_cd_read (cd_buf + 2048 * i, sector + i); - first_sector = sector; - memcpy (p, cd_buf, 2048); + for (i = 0; i < CD_BUF_LENGTH; i++) + osd_cd_read (cd_buf + 2048 * i, sector + i); + first_sector = sector; + memcpy (p, cd_buf, 2048); } else { @@ -851,18 +746,19 @@ */ for (i = 0; i < 2048; i += 4) - *(UInt32 *) & p[i] = 0xDEADBEEF; - + *(UInt32 *) & p[i] = 0xDEADBEEF; + return; } if (sector == CD_track[result].beg_lsn) - { /* We're reading the first sector, the header */ + { + /* We're reading the first sector, the header */ if (force_header) - { - memcpy (p, ISO_header, 0x800); - return; - } + { + memcpy (p, ISO_header, 0x800); + return; + } } fseek (iso_FILE, (sector - CD_track[result].beg_lsn) * 2048, SEEK_SET); @@ -897,18 +793,18 @@ for (result = 0; result < 2048; result++) { if ((result & 15) == 0) - { - fprintf (stderr, "%03x: ", result); - } + { + fprintf (stderr, "%03x: ", result); + } fprintf (stderr, "%02x", cd_sector_buffer[result]); if ((result & 15) == 15) - { - fprintf (stderr, "\n"); - } + { + fprintf (stderr, "\n"); + } else - { - fprintf (stderr, " "); - } + { + fprintf (stderr, " "); + } } #endif @@ -923,23 +819,23 @@ for (result = 0; result < 2048; result++) { - if ((result & 15) == 0) - { - fprintf (g, "%03x: ", result); - } - fprintf (g, "%02x", cd_sector_buffer[result]); - if ((result & 15) == 15) - { - fprintf (g, "\n"); - } - else - { - fprintf (g, " "); - } + if ((result & 15) == 0) + { + fprintf (g, "%03x: ", result); + } + fprintf (g, "%02x", cd_sector_buffer[result]); + if ((result & 15) == 15) + { + fprintf (g, "\n"); + } + else + { + fprintf (g, " "); + } } - + fclose (g); - + } #endif #endif @@ -1974,9 +1870,10 @@ { FILE* f; -#define POSSIBLE_LOCATION_COUNT 5 +#define POSSIBLE_LOCATION_COUNT 6 const char* POSSIBLE_LOCATION[POSSIBLE_LOCATION_COUNT] = { - "./","../","/usr/local/lib/hugo/","/usr/lib/hugo/","c:/" + "./","../","/usr/local/lib/hugo/","/usr/lib/hugo/","c:/", + "roms/" }; #define POSSIBLE_FILENAME_COUNT 4 @@ -2044,6 +1941,11 @@ { int CD_emulation_bak = CD_emulation; int return_value; + +#ifdef MORPHOS + // Store syscard path as cdsystem path + strcpy(cdsystem_path, syscard_location); +#endif CD_emulation = 0; return_value = CartLoad(cdsystem_path); @@ -2210,7 +2112,7 @@ if ((unzipped_rom_size & 0x1FFF) == 0) { /* No header */ - ROM = unzipped_rom; + ROM = (UChar*)unzipped_rom; } else { @@ -2280,7 +2182,7 @@ fprintf (stderr, "Couldn't get shared memory (%d bytes)\n", fsize); else { - ROM = (char *) shmat (shm_rom_handle, NULL, 0); + ROM = (UChar*) shmat (shm_rom_handle, NULL, 0); if (ROM == NULL) fprintf (stderr, "Couldn't attach shared memory\n"); } @@ -2684,7 +2586,7 @@ InitPCE (char *name, char *backmemname) { int i = 0, ROMmask; - unsigned long CRC; + unsigned long CRC = 0; int dummy; char *tmp_dummy; char local_us_encoded_card = 0; --- hugo-2.12/sound.c 2004-05-26 22:54:16.000000000 +0200 +++ hugo-2.13-pre/sound.c 2005-09-27 19:58:15.000000000 +0200 @@ -32,11 +32,11 @@ char MP3_playing = 0; // is MP3 playing ? -char *sbuf[6]; +SChar* sbuf[6]; // the buffer where the "DATA-TO-SEND-TO-THE-SOUND-CARD" go // one for each channel -char *adpcmbuf; +UChar* adpcmbuf; // the buffer filled with adpcm data UChar new_adpcm_play = 0; @@ -106,9 +106,9 @@ sound_driver=3; // USE SDL! for (silent = 0; silent < 6; silent++) - sbuf[silent] = (char *) calloc(sizeof(char), SBUF_SIZE_BYTE); + sbuf[silent] = (SChar *) calloc(sizeof(SChar), SBUF_SIZE_BYTE); - adpcmbuf = (char *) calloc(sizeof(char), SBUF_SIZE_BYTE); + adpcmbuf = (UChar *) calloc(sizeof(SChar), SBUF_SIZE_BYTE); silent = 1; @@ -296,7 +296,7 @@ voice_start(PCM_voice); */ - big_buf = (unsigned char *) malloc (sbuf_size); + big_buf = (Uchar *) malloc (sbuf_size * sizeof(UChar)); set_volume (gen_vol, 0); @@ -432,7 +432,7 @@ Log ("Buffer %d will be filled\n", ch); #endif Log ("Buffer %d will be filled\n", ch); - WriteBuffer (&sbuf[ch][0], ch, dwNewPos * ds_nChannels); + WriteBuffer (sbuf[ch], ch, dwNewPos * ds_nChannels); // write DATA 'til dwNewPos #ifdef SOUND_DEBUG --- hugo-2.12/sound.h 2004-05-26 22:54:16.000000000 +0200 +++ hugo-2.13-pre/sound.h 2005-09-27 19:58:15.000000000 +0200 @@ -47,17 +47,17 @@ #endif -extern unsigned char * big_buf; +extern UChar * big_buf; extern UChar gen_vol; extern UInt32 sbuf_size; -extern char* sbuf[6];//[SBUF_SIZE_BYTE]; +extern SChar* sbuf[6];//[SBUF_SIZE_BYTE]; // the buffer where the "DATA-TO-SEND-TO-THE-SOUND-CARD" go // one for each channel -extern char* adpcmbuf; +extern UChar* adpcmbuf; extern UChar new_adpcm_play; // Have we begun a new adpcm sample (i.e. must be reset adpcm index/prev value) @@ -88,7 +88,7 @@ int InitSound(void); void TrashSound(void); void write_psg(int ch); -void WriteBuffer(char *, int, unsigned); +void WriteBuffer(SChar *, int, unsigned); void write_adpcm(void); void dump_audio_chunck(UChar* content, int length); --- hugo-2.12/sprite.c 2005-04-05 21:53:14.000000000 +0200 +++ hugo-2.13-pre/sprite.c 2005-10-28 10:55:05.000000000 +0200 @@ -85,7 +85,7 @@ static void plane2pixel (int no) { - unsigned long M; + UInt32 M; UChar *C = VRAM + no * 32; UInt32 L; UChar *C2 = VRAM2 + no * 8 * 4; @@ -158,7 +158,7 @@ // 2 longs -> 16 nibbles => 32 loops for a 16*16 spr for (i = 0; i < 32; i++, C++, C2 += 4) { - long L; + Int32 L; M = C[0]; L = ((M & 0x88) >> 3) | ((M & 0x44) << 6) | ((M & 0x22) << 15) | @@ -278,12 +278,12 @@ for (i = 0; i < h; i++, P += WIDTH, C2 += 4, C += 2) #endif { - unsigned long L; + UInt32 L; UChar J; J = (C[0] | C[1] | C[16] | C[17]); if (!J) continue; - L = C2[0] + (C2[1] << 8) + (C2[2] << 16) + (C2[3] << 24); + L = C2[0] | (C2[1] << 8) | (C2[2] << 16) | (C2[3] << 24); if (J & 0x80) P[0] = PAL ((L >> 4) & 15); if (J & 0x40) @@ -328,7 +328,7 @@ Description: convert a sprite from VRAM to normal format Parameters: UChar *P (the place where to draw i.e. XBuf[...]) UChar *C (the buffer toward the sprite to draw) - unsigned long *C2 (the buffer of precalculated sprite) + UChar *C2 (the buffer of precalculated sprite) UChar *R (address of the palette of this sprite [in PAL] ) int h (the number of line to draw) int inc (the value to increment the sprite buffer) @@ -394,15 +394,15 @@ } void -PutSpriteHandleFull (UChar * P, UChar * C, unsigned long *C2, UChar * R, +PutSpriteHandleFull (UChar * P, UChar * C, UChar *C2, UChar * R, int h, int inc) { int i, J; unsigned long L; #if defined(NEW_GFX_ENGINE) - for (i = 0; i < h; i++, C += inc, C2 += inc, P += XBUF_WIDTH) + for (i = 0; i < h; i++, C += inc, C2 += inc*4, P += XBUF_WIDTH) #else - for (i = 0; i < h; i++, C += inc, C2 += inc, P += WIDTH) + for (i = 0; i < h; i++, C += inc, C2 += inc*4, P += WIDTH) #endif { @@ -419,7 +419,11 @@ continue; if (J == 65535) { - L = C2[1]; //sp2pixel(C+1); +#if defined(WORDS_BIGENDIAN) + L = C2[4] + (C2[5] << 8) + (C2[6] << 16) + (C2[7] << 24); +#else + L = ((UInt32*)C2)[1]; //sp2pixel(C+1); +#endif P[0] = PAL ((L >> 4) & 15); P[1] = PAL ((L >> 12) & 15); P[2] = PAL ((L >> 20) & 15); @@ -428,7 +432,11 @@ P[5] = PAL ((L >> 8) & 15); P[6] = PAL ((L >> 16) & 15); P[7] = PAL ((L >> 24) & 15); - L = C2[0]; //sp2pixel(C); +#if defined(WORDS_BIGENDIAN) + L = C2[0] + (C2[1] << 8) + (C2[2] << 16) + (C2[3] << 24); +#else + L = ((UInt32*)C2)[0]; //sp2pixel(C); +#endif P[8] = PAL ((L >> 4) & 15); P[9] = PAL ((L >> 12) & 15); P[10] = PAL ((L >> 20) & 15); @@ -443,7 +451,11 @@ } - L = C2[1]; //sp2pixel(C+1); +#if defined(WORDS_BIGENDIAN) + L = C2[4] + (C2[5] << 8) + (C2[6] << 16) + (C2[7] << 24); +#else + L = ((UInt32*)C2)[1]; //sp2pixel(C+1); +#endif if (J & 0x8000) P[0] = PAL ((L >> 4) & 15); if (J & 0x4000) @@ -460,7 +472,11 @@ P[6] = PAL ((L >> 16) & 15); if (J & 0x0100) P[7] = PAL ((L >> 24) & 15); - L = C2[0]; //sp2pixel(C); +#if defined(WORDS_BIGENDIAN) + L = C2[0] + (C2[1] << 8) + (C2[2] << 16) + (C2[3] << 24); +#else + L = ((UInt32*)C2)[0]; //sp2pixel(C); +#endif if (J & 0x80) P[8] = PAL ((L >> 4) & 15); if (J & 0x40) @@ -482,15 +498,15 @@ static void -PutSpriteHflip (UChar * P, UChar * C, unsigned long *C2, UChar * R, int h, +PutSpriteHflip (UChar * P, UChar * C, UChar *C2, UChar * R, int h, int inc) { int i, J; - unsigned long L; + UInt32 L; #if defined(NEW_GFX_ENGINE) - for (i = 0; i < h; i++, C += inc, C2 += inc, P += XBUF_WIDTH) + for (i = 0; i < h; i++, C += inc, C2 += inc*4, P += XBUF_WIDTH) #else - for (i = 0; i < h; i++, C += inc, C2 += inc, P += WIDTH) + for (i = 0; i < h; i++, C += inc, C2 += inc*4, P += WIDTH) #endif { J = @@ -504,7 +520,11 @@ */ if (!J) continue; - L = C2[1]; //sp2pixel(C+1); +#if defined(WORDS_BIGENDIAN) + L = C2[4] + (C2[5] << 8) + (C2[6] << 16) + (C2[7] << 24); +#else + L = ((UInt32*)C2)[1]; //sp2pixel(C+1); +#endif if (J & 0x8000) P[15] = PAL ((L >> 4) & 15); if (J & 0x4000) @@ -521,7 +541,11 @@ P[9] = PAL ((L >> 16) & 15); if (J & 0x0100) P[8] = PAL ((L >> 24) & 15); - L = C2[0]; //sp2pixel(C); +#if defined(WORDS_BIGENDIAN) + L = C2[0] + (C2[1] << 8) + (C2[2] << 16) + (C2[3] << 24); +#else + L = ((UInt32*)C2)[0]; //sp2pixel(C); +#endif if (J & 0x80) P[7] = PAL ((L >> 4) & 15); if (J & 0x40) @@ -549,7 +573,7 @@ Parameters: UChar *P : A Pointer in the buffer where we got to draw the sprite UChar *C : A pointer in the video mem where data are available - unsigned long *C2 : A pointer in the VRAMS mem + UChar *C2 : A pointer in the VRAMS mem UChar *R : A pointer to the current palette int h : height of the sprite int inc : value of the incrementation for the data @@ -564,7 +588,7 @@ UChar * M, UChar pr) { int i, J; - unsigned long L; + UInt32 L; #if defined(NEW_GFX_ENGINE) for (i = 0; i < h; i++, C += inc, C2 += inc * 4, P += XBUF_WIDTH, M += XBUF_WIDTH) @@ -629,7 +653,7 @@ int inc, UChar * M, UChar pr) { int i, J; - unsigned long L; + UInt32 L; #if defined(NEW_GFX_ENGINE) for (i = 0; i < h; i++, C += inc, C2 += inc * 4, P += XBUF_WIDTH, M += XBUF_WIDTH) @@ -693,7 +717,7 @@ { int i; UInt16 J; - unsigned long L; + UInt32 L; #if defined(NEW_GFX_ENGINE) for (i = 0; i < h; i++, C += inc, C2 += inc * 4, P += XBUF_WIDTH, M += XBUF_WIDTH) @@ -818,7 +842,7 @@ int h, int inc, UChar * M, UChar pr) { int i, J; - unsigned long L; + UInt32 L; #if defined(NEW_GFX_ENGINE) for (i = 0; i < h; i++, C += inc, C2 += inc * 4, P += XBUF_WIDTH, M += XBUF_WIDTH) @@ -1100,9 +1124,6 @@ return; } -char tmp_str[10]; -extern int vheight; -extern char *sbuf[]; /***************************************************************************** --- hugo-2.12/utils.c 2005-04-05 21:53:14.000000000 +0200 +++ hugo-2.13-pre/utils.c 2005-10-27 10:14:46.000000000 +0200 @@ -128,7 +128,7 @@ wait_next_vsync() { #ifndef BENCHMARK - static double lasttime = 0, lastcurtime = 0, frametime = 0.1; + static double lasttime = 0, lastcurtime = 0; double curtime; const double deltatime = (1.0 / 60.0);