Djam/hugo-emu
1
0
Fork 0
mirror of https://abf.rosa.ru/djam/hugo-emu.git synced 2025-02-24 06:12:59 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
hugo-emu/hugo-2.12-x86_64-fixes-backport.patch
Rosa a46a3c684c Automatic import for version 2.12
2012-02-01 21:09:14 +04:00

3268 lines
82 KiB
Diff
Raw Permalink Blame History

--- 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);
Reference in a new issue View git blame Copy permalink