From a46a3c684c4c4a5989adcb2f2aa0ac0f9adce06c Mon Sep 17 00:00:00 2001 From: Rosa Date: Wed, 1 Feb 2012 21:09:14 +0400 Subject: [PATCH] Automatic import for version 2.12 --- .abf.yml | 2 + hugo-2.12-gcc4.patch | 11 + hugo-2.12-x86_64-fixes-backport.patch | 3268 +++++++++++++++++++++++++ hugo-2.12-x86_64fix.patch | 12 + hugo-48.png | Bin 0 -> 1850 bytes hugo.spec | 166 ++ 6 files changed, 3459 insertions(+) create mode 100644 .abf.yml create mode 100644 hugo-2.12-gcc4.patch create mode 100644 hugo-2.12-x86_64-fixes-backport.patch create mode 100644 hugo-2.12-x86_64fix.patch create mode 100644 hugo-48.png create mode 100644 hugo.spec diff --git a/.abf.yml b/.abf.yml new file mode 100644 index 0000000..abc4687 --- /dev/null +++ b/.abf.yml @@ -0,0 +1,2 @@ +sources: + "hugo-2.12.tar.bz2": 60d8f4d10bad629c61eb14e5488e8374c02d0e4a diff --git a/hugo-2.12-gcc4.patch b/hugo-2.12-gcc4.patch new file mode 100644 index 0000000..07c5093 --- /dev/null +++ b/hugo-2.12-gcc4.patch @@ -0,0 +1,11 @@ +--- hugo-2.12/pce.h~ 2005-04-05 21:53:14.000000000 +0200 ++++ hugo-2.12/pce.h 2005-11-07 09:44:11.321321624 +0100 +@@ -196,7 +196,7 @@ + extern UChar language; + // the current language + +-extern int BaseClock, UPeriod; ++extern int UPeriod; + + extern UChar US_encoded_card; + // Do we have to swap even and odd bytes in the rom diff --git a/hugo-2.12-x86_64-fixes-backport.patch b/hugo-2.12-x86_64-fixes-backport.patch new file mode 100644 index 0000000..755ea6a --- /dev/null +++ b/hugo-2.12-x86_64-fixes-backport.patch @@ -0,0 +1,3268 @@ +--- 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 \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 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 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 ++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 ++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 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 . ++.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 , ++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 ++#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 + #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 ++#include ++ ++#if defined(GTK) ++#include ++#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 +@@ -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); + + diff --git a/hugo-2.12-x86_64fix.patch b/hugo-2.12-x86_64fix.patch new file mode 100644 index 0000000..c24fa79 --- /dev/null +++ b/hugo-2.12-x86_64fix.patch @@ -0,0 +1,12 @@ +diff -Nurp hugo-2.12/configure.ac hugo-2.12-fix/configure.ac +--- hugo-2.12/configure.ac 2005-03-27 20:41:37.000000000 +0300 ++++ hugo-2.12-fix/configure.ac 2005-11-07 15:50:21.000000000 +0200 +@@ -583,7 +583,7 @@ case $target_alias in + + AM_CONDITIONAL(ALLEGRO_DJGPP, true) + ;; +- *i?86-?inux*) ++ *i?86-?inux*|x86_64-?inux*) + echo "Linux build enabled" + + HUGO_TARGET_MACHINE="LINUX" diff --git a/hugo-48.png b/hugo-48.png new file mode 100644 index 0000000000000000000000000000000000000000..7c07ead7260828eed759ba1e35d44be67934cc7f GIT binary patch literal 1850 zcmV-A2gUe_P)FDV9_VfM02-w)z!^6ez@9XmN^QdtJ%F4>p($fS2 z1)OLE-`Ge1lYlJb7)Vuj|!1} zc_Sb!siUK^hzcwj2L8}NG&eN<#~hlOlHHyOo^S{E;B!}2SjM;5z^>D{gQA?MyqQ+|*q>8LByM0&s+n;e77vYmR>F`8SwRKjs|(J;nBB=? z*vGA*kcs->sCjW!!mMuj&P({{t?aA{$D=;Uzhr`cc9Dp6f?*5(@!*PY3Q-JYmI#7%Wc>J! zBp@XC?u(O;b^7X&cW7>df;^yuKl$0L`tQ)ns4V#Cz~8YxgJ?+|GjE$(iW5KjYbauc=R{sVm>uz{RzL%AG9!{^Q-w zsOsRz`|z^-`LO-=$l=wn{rc!-S2U)IGH6#U?YAuQ!ZV(K3HtJlTSf)_{LSdri-2iV zk&suCiadd5T;tcEz@t>9kv!nljNr2@{{Gwm006+FT>k$2r#WBY00001bW%=J06^y0 zW&i*H0b)x>L;#2d9Y_EG010qNS#tmY3qAk<3qApxg3uoT000McNliru(*pz&G&yTA zB}V`N1G7m)K~#90WB5-ZU>Mavo(3jAKQ?A&T4-3jm<0$}Sy{EU7fDJk0&!SyYG7t% z1u9jPkx`YEwFn8ZNKKV(X;E}@lLU$bWhvFb40MRLwv4K(1t%v&^u>u2+pk|=Z(*T2 zeY!R)D_r$chz6ju-C9}%fGkc8jb6W)0@$n<+8s@vZ z=f}h-%ggI4D=XXBBq}SXtEd1qC@3peZ{2EMTB<1}<#q0yyoU#qyu5sRI)k!|jBrnn zUO)hko*uu5NEAQ6b3#HwcenDXQ(UgD3unzr+rItUvSruay_;QDmc-0Vx(0U#2jOYc z^!WMB8XEYI9-U%jWU*=$GdFi47gxaAwOp%L%U`;rZf}3>)vKU{gd|`nx$Ef($HX)M zHR$O{q@_J@bWGFK)GREF0csEx-6$m$bn&8Re*R@oPn*k^)ydV6oz2hB-ya_@;o`D$ z?_QTZdzy50&AGTzf`a4|6YbmE=b4*doHsA%HPq8w+>ersT`uc$~%ORJTO zYhzFl*SmLlZ{B1BZCJh9*wj>COpJ652Y?!Ka^j7Q4&~9=qvO}oqFGbZq^|B8 z7`Qhe;812}dupn+sHk6j{5)r8hJ79$^@4(IMMc~7Q{P{o>WM~+~ z#KgqLw&u$hOCh0XP!=Uw1CR?Xz?f7-M8qm8O6JZjVuS)UM7K6XD_FeSI@w z%{buildroot}%{_datadir}/applications/mandriva-%{name}.desktop +[Desktop Entry] +Encoding=UTF-8 +Name=Hugo +Comment=Hu-Go! +Exec=%{_gamesbindir}/hugo +Icon=%{name} +Terminal=false +Type=Application +StartupNotify=true +Categories=Game;Emulator; +EOF + +%files +%defattr(-,root,root) +%doc AUTHORS INSTALL NEWS README +%attr(0755,root,games) %{_gamesbindir}/%{name} +%{_gamesbindir}/hugod +%{_datadir}/applications/mandriva-%{name}.desktop +%dir %{_datadir}/%{name} +%{_datadir}/%{name}/* +%{_iconsdir}/*.png +%{_mandir}/man6/%{name}*.6* + + +%clean +rm -rf %{buildroot} + +%if %mdkversion < 200900 +%post +%{update_menus} + +%postun +%{clean_menus} +%endif + + + +%changelog +* Fri Jul 29 2011 Andrey Bondrov 2.12-11 ++ Revision: 692192 +- imported package hugo + + +* Thu Jul 21 2011 Andrey Bondrov 2.12-11mdv2011.0 +- Import from PLF +- Remove PLF reference + +* Wed Jan 20 2010 Götz Waschk 2.12-10plf2010.1 +- update menu + +* Tue Jan 13 2009 Guillaume Bedot 2.12-9plf2009.1 +- utf8 changelog + +* Tue Jan 13 2009 Guillaume Bedot 2.12-8plf2009.1 +- fixed 64bit build (segfaulted) +- added man pages +- fixed license +- dropped old-style menu + +* Sun Dec 21 2008 Götz Waschk 2.12-7plf2009.1 +- rebuild + +* Sun Dec 16 2007 Guillaume Bedot 2.12-6plf2008.1 +- fix desktop file + +* Tue Aug 1 2006 Götz Waschk 2.12-5plf2007.0 +- xdg menu + +* Mon Dec 19 2005 Götz Waschk 2.12-4plf +- fix directory conflict +- Rebuild + +* Mon Nov 7 2005 Anssi Hannula 2.12-3plf +- fix x86_64 build (patch2) +- distsuffix + +* Mon Nov 7 2005 Götz Waschk 2.12-2plf +- fix buildrequires +- patch for gcc 4 + +* Sun Apr 10 2005 Guillaume Bedot 2.12-1plf +- New release with some bug fixes :) + +* Mon Mar 14 2005 Götz Waschk 2.11-1plf +- update file list +- fix buildrequires +- drop patches +- fix URL +- fix License +- new version + +* Thu Feb 17 2005 Götz Waschk 2.10-4plf +- fix build + +* Mon Jul 21 2003 Götz Waschk 2.10-3plf +- buildrequires fix + +* Fri Jul 18 2003 Götz Waschk 2.10-2plf +- patch to fix build with current gcc +- quiet tar + +* Thu Apr 10 2003 Olivier Thauvin 2.10-1plf +- => plf +- games path +- somes minor fix + +* Tue Mar 04 2003 Guillaume Bedot 2.10-1mdk +- Update to 2.10. + +* Tue Feb 25 2003 Guillaume Bedot 2.10-0-20030225 +- Update to latest CVS. +- Added menu entry and icons for the GUI. + +* Thu Feb 13 2003 Guillaume Bedot 2.10-0-13022003 +- First try to package Hu-Go!