#
# Makefile for Thunder SDL
#
-# by James L. Hammons
+# by James Hammons
# (C) 2009 Underground Software
# This software is licensed under the GPL v3 or later
#
SDLLIBTYPE = --static-libs
MSG = Mac OS X
-else # *nix
+else # *nix
SYSTYPE = __GCCUNIX__
EXESUFFIX =
//
// 6808 disassembler
//
-// by James L. Hammons
+// by James Hammons
//
-// (c) 2004 Underground Software
+// (c) 2004, 2014 Underground Software
//
#include "dis6808.h"
//
// Display bytes in mem in hex
//
-static void DisplayBytes(uint16 src, uint32 dst)
+static void DisplayBytes(uint16_t src, uint32_t dst)
{
WriteLog("%04X: ", src);
- uint8 cnt = 0; // Init counter...
+ uint8_t cnt = 0; // Init counter...
if (src > dst)
dst += 0x10000; // That should fix the FFFF bug...
- for(uint32 i=src; i<dst; i++)
+ for(uint32_t i=src; i<dst; i++)
{
WriteLog("%02X ", soundCPU.RdMem(i));
cnt++; // Bump counter...
//
// Decode a 6808 instruction
//
-int Decode6808(uint16 pc)
+int Decode6808(uint16_t pc)
{
char outbuf[80];
- uint16 addr = pc, offset;
- uint8 opcode = soundCPU.RdMem(addr++); // Get the opcode
+ uint16_t addr = pc, offset;
+ uint8_t opcode = soundCPU.RdMem(addr++); // Get the opcode
switch (op_mat[opcode]) // Decode the addressing mode...
{
sprintf(outbuf, "%s $%04X ", mnemonics[opcode], offset);
break;
case 3: // Relative
-// sprintf(outbuf, "%s $%04X", mnemonics[opcode], ++addr + (int16)(int8)soundCPU.RdMem(addr));
- offset = addr + 1 + (int16)(int8)soundCPU.RdMem(addr);
+// sprintf(outbuf, "%s $%04X", mnemonics[opcode], ++addr + (int16_t)(int8_t)soundCPU.RdMem(addr));
+ offset = addr + 1 + (int16_t)(int8_t)soundCPU.RdMem(addr);
addr++;
sprintf(outbuf, "%s $%04X ", mnemonics[opcode], offset);
break;
//
-// DIS6809.H
+// DIS6808.H
//
-// by James L. Hammons
-// (C) 2004 Underground Software
+// by James Hammons
+// (C) 2004, 2014 Underground Software
//
-#ifndef __DIS6809_H__
-#define __DIS6809_H__
+#ifndef __DIS6808_H__
+#define __DIS6808_H__
-#include "types.h"
+#include <stdint.h>
-int Decode6808(uint16 pc);
+int Decode6808(uint16_t pc);
-#endif // __DIS6809_H__
+#endif // __DIS6808_H__
//
// 6809 disassembler
//
-// by James L. Hammons
+// by James Hammons
//
-// (c) 2004 Underground Software
+// (c) 2004, 2014 Underground Software
//
#include "dis6809.h"
//
// Display bytes in mem in hex
//
-static void DisplayBytes(V6809REGS regs, uint16 src, uint32 dst)
+static void DisplayBytes(V6809REGS regs, uint16_t src, uint32_t dst)
{
WriteLog("%04X: ", src);
- uint8 cnt = 0; // Init counter...
+ uint8_t cnt = 0; // Init counter...
if (src > dst)
dst += 0x10000; // That should fix the FFFF bug...
- for(uint32 i=src; i<dst; i++)
+ for(uint32_t i=src; i<dst; i++)
{
WriteLog("%02X ", regs.RdMem(i));
cnt++; // Bump counter...
//
// Decode a 6809 instruction at 'addr'
//
-//int Decode6809(uint16 pc)
+//int Decode6809(uint16_t pc)
int Decode6809(V6809REGS regs)
{
char outbuf[80], mnem[6], tmp[30];
- uint8 opcode2, operand;
+ uint8_t opcode2, operand;
- uint16 addr = regs.pc, offset;
+ uint16_t addr = regs.pc, offset;
- uint8 opcode = regs.RdMem(addr++); // Get the opcode
- uint8 admode = op_mat1[opcode]; // addressing mode
+ uint8_t opcode = regs.RdMem(addr++); // Get the opcode
+ uint8_t admode = op_mat1[opcode]; // addressing mode
strcpy(mnem, mnemonics[opcode]); // Copy page 1 opcode
if (opcode == 0x10) // Extended opcode?
break;
case 3: // Relative
//DISNOWOK--FIX
-// sprintf(outbuf, "%s $%04X", mnem, ++addr + (int16)((int8)regs.RdMem(addr)));
- offset = addr + 1 + (int16)(int8)regs.RdMem(addr);
+// sprintf(outbuf, "%s $%04X", mnem, ++addr + (int16_t)((int8_t)regs.RdMem(addr)));
+ offset = addr + 1 + (int16_t)(int8_t)regs.RdMem(addr);
addr++;
sprintf(outbuf, "%s $%04X", mnem, offset);
break;
case 4: // Long Relative
-// sprintf(outbuf, "%s $%04X", mnem, addr + (int16)((regs.RdMem(addr++) << 8) | regs.RdMem(addr++)) + 2);
- offset = addr + (int16)((regs.RdMem(addr) << 8) | regs.RdMem(addr + 1)) + 2;
+// sprintf(outbuf, "%s $%04X", mnem, addr + (int16_t)((regs.RdMem(addr++) << 8) | regs.RdMem(addr++)) + 2);
+ offset = addr + (int16_t)((regs.RdMem(addr) << 8) | regs.RdMem(addr + 1)) + 2;
addr += 2;
sprintf(outbuf, "%s $%04X", mnem, offset);
break;
case 7: // Indexed (the tough one!)
{
operand = regs.RdMem(addr++); // Get IDX byte
- uint8 reg = ((operand & 0x60) >> 5), idxind = ((operand & 0x10) >> 4),
+ uint8_t reg = ((operand & 0x60) >> 5), idxind = ((operand & 0x10) >> 4),
lo_nyb = (operand & 0x0F), boff;
- uint16 woff;
+ uint16_t woff;
strcpy(tmp, "??");
if (!(operand & 0x80)) // Hi bit set? Then decode 4 bit offset
//
// DIS6809.H
//
-// by James L. Hammons
-// (C) 2004 Underground Software
+// by James Hammons
+// (C) 2004, 2014 Underground Software
//
#ifndef __DIS6809_H__
//
// Thunder Graphic User Interface
//
-// by James L. Hammons
-// (c) 2004, 2009 Underground Software
+// by James Hammons
+// (c) 2004, 2014 Underground Software
//
-// JLH = James L. Hammons <jlhamm@acm.org>
+// JLH = James Hammons <jlhamm@acm.org>
//
// WHO WHEN WHAT
// --- ---------- ------------------------------------------------------------
extern SDL_Surface * screen;
-extern uint8 my_scr[0x14000]; // Screen buffer...
-extern uint8 gram1[]; // Game RAM (do here??)
-extern uint8 hScrollOffset; // Horizontal scroll offset
-extern uint8 vScrollOffset; // Vertical scroll offset
-extern uint32 voffsets[8];
-extern uint8 voice_rom[]; // PCM data pointer
+extern uint8_t my_scr[0x14000]; // Screen buffer...
+extern uint8_t gram1[]; // Game RAM (do here??)
+extern uint8_t hScrollOffset; // Horizontal scroll offset
+extern uint8_t vScrollOffset; // Vertical scroll offset
+extern uint32_t voffsets[8];
+extern uint8_t voice_rom[]; // PCM data pointer
extern fstream tr; // Tracelog
// Global shit
-uint16 text_life; // How long text is visible
+uint16_t text_life; // How long text is visible
bool show_text; // Whether or not to show text
-uint16 show_which_msg; // Which message to show
+uint16_t show_which_msg; // Which message to show
bool show_gui; // Whether or not to show GUI
-uint16 selection; // Which GUI item currently selected
-uint16 snd_num;
-uint16 gui_debounce; // GUI key debounce value
-uint16 num_coins; // Number of coins dropped
-uint16 blink = 0; // Used to blink player 1 & 2 start buttons
-uint16 flash = 23; // Used to flash GUI lights
-uint16 iline = 0; // Used to roll line
-uint16 dcurcol = 179; // dipswitch cursor color
+uint16_t selection; // Which GUI item currently selected
+uint16_t snd_num;
+uint16_t gui_debounce; // GUI key debounce value
+uint16_t num_coins; // Number of coins dropped
+uint16_t blink = 0; // Used to blink player 1 & 2 start buttons
+uint16_t flash = 23; // Used to flash GUI lights
+uint16_t iline = 0; // Used to roll line
+uint16_t dcurcol = 179; // dipswitch cursor color
int dcurdir = 1; // Initially going up...
bool blink_on = false;
bool game_refresh; // Refresh rate user set
bool do_decrement; // Flag to handle decrement...
bool user_selected_something; // Flag for well, you know...
-uint16 dswitch; // Which dipswitch is selected...
+uint16_t dswitch; // Which dipswitch is selected...
// The following are global for the sound routines...
bool snd_go = false;
bool chan1_go = false, chan2_go = false, chan3_go = false;
bool chan4_go = false, chan5_go = false, chan6_go = false;
-uint8 * sndp1, * sndp2, * sndp3, * sndp4, * sndp5, * sndp6;
-uint32 rom_pos, end_pos;
-uint32 spos1, end_pos1;
-uint32 spos2, end_pos2;
-uint32 spos3, end_pos3;
-uint32 spos4, end_pos4;
-uint32 spos5, end_pos5;
-uint32 spos6, end_pos6;
+uint8_t * sndp1, * sndp2, * sndp3, * sndp4, * sndp5, * sndp6;
+uint32_t rom_pos, end_pos;
+uint32_t spos1, end_pos1;
+uint32_t spos2, end_pos2;
+uint32_t spos3, end_pos3;
+uint32_t spos4, end_pos4;
+uint32_t spos5, end_pos5;
+uint32_t spos6, end_pos6;
float sample1;
-uint8 prevSamp1;
-int8 delta_x1;
+uint8_t prevSamp1;
+int8_t delta_x1;
float sample2;
-uint8 prevSamp2;
-int8 delta_x2;
+uint8_t prevSamp2;
+int8_t delta_x2;
-uint8 * snd_array[3] = { sunknown, scya, scamera }; // From RESOURCE.H
-uint32 snd_lens[3] = { sunknownlen, scyalen, scameralen };
+uint8_t * snd_array[3] = { sunknown, scya, scamera }; // From RESOURCE.H
+uint32_t snd_lens[3] = { sunknownlen, scyalen, scameralen };
// Bitmaps
-uint8 bmp1[] = {
+uint8_t bmp1[] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,1,1,0,0,0,1,1,0,0,1,0,0,1,0,0,0,0,0,0,
0,1,0,0,0,0,1,0,0,1,0,1,0,0,1,0,1,1,1,1,0,
0,0,1,1,0,0,0,1,1,0,0,1,0,0,1,0,1,1,1,1,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};
-uint8 bmp2[] = {
+uint8_t bmp2[] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,1,1,1,0,0,0,1,1,0,0,1,0,0,1,0,0,0,0,0,0,
0,0,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,1,1,1,0,
0,1,1,1,0,0,0,1,1,0,0,1,0,0,1,0,1,1,1,1,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};
-uint8 bmp3[] = {
+uint8_t bmp3[] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,1,0,0,0,0,1,1,1,0,0,0,1,1,0,0,1,1,1,0,0,
0,1,1,1,0,0,1,0,0,1,0,0,1,1,1,0,1,1,1,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0
};
-uint8 boptions[] = { // 35x9
+uint8_t boptions[] = { // 35x9
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,1,1,0,0,1,1,1,0,0,0,0,1,1,0,1,1,1,0,0,1,1,0,0,1,0,0,1,0,0,1,1,0,0,
0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};
-uint8 bn0[] = {
+uint8_t bn0[] = {
0,0,0,0,0,0,
0,0,1,1,0,0,
0,1,0,0,1,0,
0,0,1,1,0,0,
0,0,0,0,0,0
};
-uint8 bn1[] = {
+uint8_t bn1[] = {
0,0,0,0,0,0,
0,0,1,0,0,0,
0,1,1,0,0,0,
0,1,1,1,0,0,
0,0,0,0,0,0
};
-uint8 bn2[] = {
+uint8_t bn2[] = {
0,0,0,0,0,0,
0,1,1,1,0,0,
0,0,0,0,1,0,
0,1,1,1,1,0,
0,0,0,0,0,0
};
-uint8 bn3[] = {
+uint8_t bn3[] = {
0,0,0,0,0,0,
0,1,1,1,0,0,
0,0,0,0,1,0,
0,1,1,1,0,0,
0,0,0,0,0,0
};
-uint8 bn4[] = {
+uint8_t bn4[] = {
0,0,0,0,0,0,
0,0,0,1,0,0,
0,1,0,1,0,0,
0,0,0,1,0,0,
0,0,0,0,0,0
};
-uint8 bn5[] = {
+uint8_t bn5[] = {
0,0,0,0,0,0,
0,1,1,1,1,0,
0,1,0,0,0,0,
0,1,1,1,0,0,
0,0,0,0,0,0
};
-uint8 bn6[] = {
+uint8_t bn6[] = {
0,0,0,0,0,0,
0,0,1,1,0,0,
0,1,0,0,0,0,
0,0,1,1,0,0,
0,0,0,0,0,0
};
-uint8 bn7[] = {
+uint8_t bn7[] = {
0,0,0,0,0,0,
0,1,1,1,1,0,
0,0,0,0,1,0,
0,0,1,0,0,0,
0,0,0,0,0,0
};
-uint8 bn8[] = {
+uint8_t bn8[] = {
0,0,0,0,0,0,
0,0,1,1,0,0,
0,1,0,0,1,0,
0,0,1,1,0,0,
0,0,0,0,0,0
};
-uint8 bn9[] = {
+uint8_t bn9[] = {
0,0,0,0,0,0,
0,0,1,1,0,0,
0,1,0,0,1,0,
0,0,1,1,0,0,
0,0,0,0,0,0
};
-uint8 bnA[] = {
+uint8_t bnA[] = {
0,0,0,0,0,0,
0,0,1,1,0,0,
0,1,0,0,1,0,
0,1,0,0,1,0,
0,0,0,0,0,0
};
-uint8 bnB[] = {
+uint8_t bnB[] = {
0,0,0,0,0,0,
0,1,1,1,0,0,
0,1,0,0,1,0,
0,1,1,1,0,0,
0,0,0,0,0,0
};
-uint8 bnC[] = {
+uint8_t bnC[] = {
0,0,0,0,0,0,
0,0,1,1,0,0,
0,1,0,0,1,0,
0,0,1,1,0,0,
0,0,0,0,0,0
};
-uint8 bnD[] = {
+uint8_t bnD[] = {
0,0,0,0,0,0,
0,1,1,1,0,0,
0,1,0,0,1,0,
0,1,1,1,0,0,
0,0,0,0,0,0
};
-uint8 bnE[] = {
+uint8_t bnE[] = {
0,0,0,0,0,0,
0,1,1,1,1,0,
0,1,0,0,0,0,
0,1,1,1,1,0,
0,0,0,0,0,0
};
-uint8 bnF[] = {
+uint8_t bnF[] = {
0,0,0,0,0,0,
0,1,1,1,1,0,
0,1,0,0,0,0,
//
// Draw the small icons...
//
-void DrawSmallIcons(uint16 icon_not_to_draw)
+void DrawSmallIcons(uint16_t icon_not_to_draw)
{
- uint8 * iconmem;
- uint8 xl, yl;
- uint8 * sIcons[12] = { inoguis, icoinus, ipl1sts, ipl2sts, ii30hzs, ii60hzs,
+ uint8_t * iconmem;
+ uint8_t xl, yl;
+ uint8_t * sIcons[12] = { inoguis, icoinus, ipl1sts, ipl2sts, ii30hzs, ii60hzs,
idipsws, ichecks, ikeycns, isnapss, iresets, ibyebys };
- uint8 xlens[12] = { 31, 18, 32, 35, 37, 37, 29, 23, 28, 32, 19, 19 };
- uint8 ylens[12] = { 31, 18, 19, 19, 21, 21, 23, 20, 16, 17, 20, 23 };
- uint8 xpos[11] = { 33, 48, 63, 78, 104, 0, 184, 210, 225, 240, 255 };
- uint8 iconidx[11] = { 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 6 };
+ uint8_t xlens[12] = { 31, 18, 32, 35, 37, 37, 29, 23, 28, 32, 19, 19 };
+ uint8_t ylens[12] = { 31, 18, 19, 19, 21, 21, 23, 20, 16, 17, 20, 23 };
+ uint8_t xpos[11] = { 33, 48, 63, 78, 104, 0, 184, 210, 225, 240, 255 };
+ uint8_t iconidx[11] = { 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 6 };
if (game_refresh) iconidx[9] = 5; // 60 Hz...
for(int i=0; i<5; i++)
{
- uint16 idx = i + icon_not_to_draw; // Get correct start pos.
+ uint16_t idx = i + icon_not_to_draw; // Get correct start pos.
if (idx > 10) idx -= 11;
iconmem = sIcons[iconidx[idx]];
xl = xlens[iconidx[idx]]; yl = ylens[iconidx[idx]];
- uint32 scadr = hScrollOffset + voffsets[vScrollOffset];
+ uint32_t scadr = hScrollOffset + voffsets[vScrollOffset];
scadr += 320*((224-yl)/2); // Center vertically
scadr += xpos[i] - (xl/2); // Center around horiz. pos.
- uint16 bmpptr = 0;
+ uint16_t bmpptr = 0;
for(int yy=0; yy<yl; yy++)
{
for(int xx=0; xx<xl; xx++)
{
- uint8 b = iconmem[bmpptr++];
+ uint8_t b = iconmem[bmpptr++];
if (b) my_scr[scadr+xx+yy*320] = b;
}
}
}
for(int i=10; i>5; i--)
{
- uint16 idx = i + icon_not_to_draw; // Get correct start pos.
+ uint16_t idx = i + icon_not_to_draw; // Get correct start pos.
if (idx > 10) idx -= 11;
iconmem = sIcons[iconidx[idx]];
xl = xlens[iconidx[idx]]; yl = ylens[iconidx[idx]];
- uint32 scadr = hScrollOffset + voffsets[vScrollOffset];
+ uint32_t scadr = hScrollOffset + voffsets[vScrollOffset];
scadr += 320*((224-yl)/2); // Center vertically
scadr += xpos[i] - (xl/2); // Center around horiz. pos.
- uint16 bmpptr = 0;
+ uint16_t bmpptr = 0;
for(int yy=0; yy<yl; yy++)
{
for(int xx=0; xx<xl; xx++)
{
- uint8 b = iconmem[bmpptr++];
+ uint8_t b = iconmem[bmpptr++];
if (b) my_scr[scadr+xx+yy*320] = b;
}
}
//
// Draw the large (selected) icon
//
-void DrawLargeIcon(uint16 icon)
+void DrawLargeIcon(uint16_t icon)
{
- uint8 * iconmem;
- uint8 xl, yl;
- uint8 * lIcons[11] = { inoguib, icoinub, ipl1stb, ipl2stb, ii30hzb, ii60hzb,
+ uint8_t * iconmem;
+ uint8_t xl, yl;
+ uint8_t * lIcons[11] = { inoguib, icoinub, ipl1stb, ipl2stb, ii30hzb, ii60hzb,
idipswb, ikeycnb, isnapsb, iresetb, ibyebyb };
- uint8 xlens[11] = { 44, 45, 50, 52, 59, 59, 42, 45, 48, 58, 42 };
- uint8 ylens[11] = { 44, 40, 33, 29, 52, 52, 34, 45, 37, 40, 50 };
+ uint8_t xlens[11] = { 44, 45, 50, 52, 59, 59, 42, 45, 48, 58, 42 };
+ uint8_t ylens[11] = { 44, 40, 33, 29, 52, 52, 34, 45, 37, 40, 50 };
- uint8 gsubs1[24] = { 21, 21, 20, 19, 168, 168, 31, 155, 68, 68, 67, 66,
+ uint8_t gsubs1[24] = { 21, 21, 20, 19, 168, 168, 31, 155, 68, 68, 67, 66,
36, 36, 35, 34, 188, 188, 183, 181, 81, 81, 85, 80 },
gsubs2[24] = { 20, 20, 19, 19, 31, 31, 155, 155, 67, 67, 66, 66,
35, 35, 34, 34, 183, 183, 181, 181, 85, 85, 80, 80 },
xl = xlens[6]; yl = ylens[6];
}
- uint32 scadr = hScrollOffset + voffsets[vScrollOffset];
+ uint32_t scadr = hScrollOffset + voffsets[vScrollOffset];
scadr += 320*((224-yl)/2); // Center vertically
scadr += (288-xl)/2; // Center horizontally
- uint16 bmpptr = 0;
+ uint16_t bmpptr = 0;
for(int yy=0; yy<yl; yy++)
{
for(int xx=0; xx<xl; xx++)
{
- uint8 b = iconmem[bmpptr++];
+ uint8_t b = iconmem[bmpptr++];
if (b)
{
if ((icon == PL1START) && (b == 235) && (num_coins) && !blink_on)
36,35,34; 188,183,181; 81,85,80 */
if (icon == NOGUI)
{
- uint8 fln = (23 - flash) + 1; // Want to go forward (maybe fix it?)
+ uint8_t fln = (23 - flash) + 1; // Want to go forward (maybe fix it?)
switch (b)
{
case 36: { b = gsubs1[fln]; break; }
//
void DrawDipswitch(void)
{
- uint8 dseloff[16] = { 0, 1, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11, 11, 12 };
- uint8 * dtxt[13] = { idstext1, idstext2, idstext3, idstext4, idstext5,
+ uint8_t dseloff[16] = { 0, 1, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11, 11, 12 };
+ uint8_t * dtxt[13] = { idstext1, idstext2, idstext3, idstext4, idstext5,
idstext2, idstext6, idstext7, idstext8, idstext9,
idstext10, idstext11, idstext12 };
- uint8 dtx[13] = { 48, 80, 96, 82, 60, 80, 76, 57, 33, 50, 62, 65, 63 },
+ uint8_t dtx[13] = { 48, 80, 96, 82, 60, 80, 76, 57, 33, 50, 62, 65, 63 },
dty[13] = { 7, 9, 7, 9, 7, 9, 7, 7, 7, 9, 7, 9, 7 };
- uint32 dtxtoff[13] = { 4*320+24, 14*320-78, 25*320+24, 32*320-80,
+ uint32_t dtxtoff[13] = { 4*320+24, 14*320-78, 25*320+24, 32*320-80,
39*320+24, 49*320-78,
4*320+24, 11*320-55, 18*320+24, 25*320-48,
32*320+24, 42*320-63, 53*320+24 };
- uint32 scadr, bmpptr;
+ uint32_t scadr, bmpptr;
//dsx = //26x65
- uint32 dbase = hScrollOffset + voffsets[vScrollOffset];
+ uint32_t dbase = hScrollOffset + voffsets[vScrollOffset];
dbase += (288-26)/2; // Center horizontally
dbase += 320*((224-((65*2)+8))/2); // Center vertically
{
for(int xx=0; xx<26; xx++)
{
- uint8 b = idswitch[bmpptr++];
+ uint8_t b = idswitch[bmpptr++];
if (b) my_scr[scadr+xx+yy*320] = b;
}
}
{
for(int xx=0; xx<26; xx++)
{
- uint8 b = idswitch[bmpptr++];
+ uint8_t b = idswitch[bmpptr++];
if (b) my_scr[scadr+xx+yy*320] = b;
}
}
scadr += 315; // Adjust position...
}
}
- uint8 dselected_text = dseloff[dswitch];
+ uint8_t dselected_text = dseloff[dswitch];
for(int i=0; i<13; i++)
{
if (dselected_text != i)
{
for(int xx=0; xx<dtx[i]; xx++)
{
- uint8 b = dtxt[i][bmpptr++];
+ uint8_t b = dtxt[i][bmpptr++];
if (b) my_scr[scadr] = b;
scadr++;
}
{
for(int xx=0; xx<dtx[dselected_text]; xx++)
{
- uint8 b = dtxt[dselected_text][bmpptr++];
+ uint8_t b = dtxt[dselected_text][bmpptr++];
if (b) my_scr[scadr] = 125;
scadr++;
}
//
// User selected something! Handle it!
//
-uint8 UserSelectedSomething(void)
+uint8_t UserSelectedSomething(void)
{
- //extern uint8 * gram1;
+ //extern uint8_t * gram1;
if (!gui_debounce)
{
//
void ShowNumbers(int number)
{
- uint8 * bnarray[16] = { bn0, bn1, bn2, bn3, bn4, bn5, bn6, bn7, bn8, bn9,
+ uint8_t * bnarray[16] = { bn0, bn1, bn2, bn3, bn4, bn5, bn6, bn7, bn8, bn9,
bnA, bnB, bnC, bnD, bnE, bnF };
- uint32 scadr = hScrollOffset + voffsets[vScrollOffset] + 642 + 2560;
- uint16 bmpptr = 0;
+ uint32_t scadr = hScrollOffset + voffsets[vScrollOffset] + 642 + 2560;
+ uint16_t bmpptr = 0;
- uint8 first_dig = number>>4, second_dig = number&0x0F;
+ uint8_t first_dig = number>>4, second_dig = number&0x0F;
for(int y=0; y<7; y++)
{
for(int x=0; x<6; x++)
//
// Spawn a message
//
-void SpawnMsg(uint8 msg)
+void SpawnMsg(uint8_t msg)
{
text_life = 60; // 1 second...
show_text = true; // Show the damn thing...
text_life--; // Your life force is running out...
// Draw the message here...
- uint32 scadr = hScrollOffset + voffsets[vScrollOffset] + 642;
- uint16 bmpptr = 0;
+ uint32_t scadr = hScrollOffset + voffsets[vScrollOffset] + 642;
+ uint16_t bmpptr = 0;
for(int y=0; y<7; y++)
{
//
void SpawnSound(int type, int snd, int channel/* = 0*/)
{
- extern uint32 psg_lens[16];
- extern uint8 * psg_adrs[16];
- extern uint32 voc_lens[32];
- extern uint8 * voc_adrs[32];
- extern uint32 fm_lens[14];
- extern uint8 * fm_adrs[14];
+ extern uint32_t psg_lens[16];
+ extern uint8_t * psg_adrs[16];
+ extern uint32_t voc_lens[32];
+ extern uint8_t * voc_adrs[32];
+ extern uint32_t fm_lens[14];
+ extern uint8_t * fm_adrs[14];
snd_num = snd;
SpawnMsg(MSHOWNUMS);
if (channel == 0)
{
// 00 nn ss (nn # of repeats of sample ss)
- uint32 st = 0;
+ uint32_t st = 0;
if (snd & 0x40)
{
}
else
{
- uint32 st = 0;
+ uint32_t st = 0;
if (snd & 0x40)
{
//
void SoundFunc(void * userdata, Uint8 * buff, int num)
{
- uint16 cnt = 0, sample; // 0-22 different sounds...
- uint8 start_samp1, end_samp1, start_samp2, end_samp2;
- uint8 samp1 = 128, samp2 = 128, samp3 = 128,
+ uint16_t cnt = 0, sample; // 0-22 different sounds...
+ uint8_t start_samp1, end_samp1, start_samp2, end_samp2;
+ uint8_t samp1 = 128, samp2 = 128, samp3 = 128,
samp4 = 128, samp5 = 128, samp6 = 128; // Zero samples...
memset(buff, 128, num); // Kill sound...
//
// GUI.H
//
-// by James L. Hammmons
-// (C) 1998, 2009 Underground Software
+// by James Hammmons
+// (C) 1998, 2014 Underground Software
//
#ifndef __GUI_H__
#define __GUI_H__
-#include "types.h"
+#include <stdint.h>
#include "SDL.h"
// Message macros
#define RESET 9
#define EXIT 10
-void SpawnMsg(uint8);
+void SpawnMsg(uint8_t);
void DrawText(void);
void InitGUI(void);
bool ShowGUI(void);
void SelectRight(void);
void SelectUp(void);
void SelectDown(void);
-uint8 UserSelectedSomething(void);
+uint8_t UserSelectedSomething(void);
void SetRefreshRate(bool);
void ActivateGUI(void);
void DeactivateGUI(void);
//
// Log handler
//
-// by James L. Hammons
-// (c) 2004, 2009 Underground Software
+// by James Hammons
+// (C) 2004, 2014 Underground Software
//
-// JLH = James L. Hammons <jlhamm@acm.org>
+// JLH = James Hammons <jlhamm@acm.org>
//
// WHO WHEN WHAT
-// --- ---------- ------------------------------------------------------------
+// --- ---------- -----------------------------------------------------------
// JLH 07/23/2009 Added changelog ;-)
//
#include "types.h"
#include "log.h"
-#define MAX_LOG_SIZE 10000000 // Maximum size of log file (10 MB)
+#define MAX_LOG_SIZE 10000000 // Maximum size of log file (10 MB)
-static FILE * log_stream = NULL;
+static FILE * logStream = NULL;
static uint32 logSize = 0;
+
bool InitLog(const char * path)
{
- log_stream = fopen(path, "wrt");
+ logStream = fopen(path, "wrt");
- if (log_stream == NULL)
+ if (logStream == NULL)
return false;
return true;
}
+
void LogDone(void)
{
- if (log_stream)
- fclose(log_stream);
+ if (logStream)
+ fclose(logStream);
}
+
//
// This logger is used mainly to ensure that text gets written to the log file
// even if the program crashes. The performance hit is acceptable in this case!
//
void WriteLog(const char * text, ...)
{
- if (!log_stream)
+ if (!logStream)
return;
va_list arg;
va_start(arg, text);
- logSize += vfprintf(log_stream, text, arg);
+ logSize += vfprintf(logStream, text, arg);
if (logSize > MAX_LOG_SIZE)
{
- fflush(log_stream);
- fclose(log_stream);
+ fflush(logStream);
+ fclose(logStream);
exit(1);
- }//*/
+ }
va_end(arg);
- fflush(log_stream); // Make sure that text is written!
+ fflush(logStream); // Make sure that text is written!
}
+
;
; Thunder GUI resources
;
-; by Jimmy Hamm
-; (C) 1998 Underground Software
+; by James Hammons
+; (C) 1998, 2014 Underground Software
;
[SECTION .data]
[GLOBAL sunknown]
//
// Resource header file
//
-// by James L. Hammons
-// (C) 1998, 2009 Underground Software
+// by James Hammons
+// (C) 1998, 2014 Underground Software
//
#ifndef __RESOURCE_H__
#define __RESOURCE_H__
+#include <stdint.h>
+
#ifdef __cplusplus
extern "C" {
#endif
-extern uint8 * sunknown;
-extern uint8 * scya;
-extern uint8 * scamera;
-extern uint32 sunknownlen;
-extern uint32 scyalen;
-extern uint32 scameralen;
+extern uint8_t * sunknown;
+extern uint8_t * scya;
+extern uint8_t * scamera;
+extern uint32_t sunknownlen;
+extern uint32_t scyalen;
+extern uint32_t scameralen;
-extern uint8 * inoguib;
-extern uint8 * idipswb;
-extern uint8 * ipl1stb;
-extern uint8 * ipl2stb;
-extern uint8 * ii30hzb;
-extern uint8 * ii60hzb;
-extern uint8 * icoinub;
-extern uint8 * isnapsb;
-extern uint8 * iresetb;
-extern uint8 * ibyebyb;
-extern uint8 * ikeycnb;
+extern uint8_t * inoguib;
+extern uint8_t * idipswb;
+extern uint8_t * ipl1stb;
+extern uint8_t * ipl2stb;
+extern uint8_t * ii30hzb;
+extern uint8_t * ii60hzb;
+extern uint8_t * icoinub;
+extern uint8_t * isnapsb;
+extern uint8_t * iresetb;
+extern uint8_t * ibyebyb;
+extern uint8_t * ikeycnb;
-extern uint8 * inoguis;
-extern uint8 * idipsws;
-extern uint8 * ipl1sts;
-extern uint8 * ipl2sts;
-extern uint8 * ii30hzs;
-extern uint8 * ii60hzs;
-extern uint8 * icoinus;
-extern uint8 * isnapss;
-extern uint8 * iresets;
-extern uint8 * ibyebys;
-extern uint8 * ikeycns;
-extern uint8 * ichecks;
+extern uint8_t * inoguis;
+extern uint8_t * idipsws;
+extern uint8_t * ipl1sts;
+extern uint8_t * ipl2sts;
+extern uint8_t * ii30hzs;
+extern uint8_t * ii60hzs;
+extern uint8_t * icoinus;
+extern uint8_t * isnapss;
+extern uint8_t * iresets;
+extern uint8_t * ibyebys;
+extern uint8_t * ikeycns;
+extern uint8_t * ichecks;
-extern uint8 * idswitch;
-extern uint8 * idsbutton;
-extern uint8 * idstext1;
-extern uint8 * idstext2;
-extern uint8 * idstext3;
-extern uint8 * idstext4;
-extern uint8 * idstext5;
-extern uint8 * idstext6;
-extern uint8 * idstext7;
-extern uint8 * idstext8;
-extern uint8 * idstext9;
-extern uint8 * idstext10;
-extern uint8 * idstext11;
-extern uint8 * idstext12;
+extern uint8_t * idswitch;
+extern uint8_t * idsbutton;
+extern uint8_t * idstext1;
+extern uint8_t * idstext2;
+extern uint8_t * idstext3;
+extern uint8_t * idstext4;
+extern uint8_t * idstext5;
+extern uint8_t * idstext6;
+extern uint8_t * idstext7;
+extern uint8_t * idstext8;
+extern uint8_t * idstext9;
+extern uint8_t * idstext10;
+extern uint8_t * idstext11;
+extern uint8_t * idstext12;
#ifdef __cplusplus
}
// Now with VESA2 support!
// Also, support routines for video hardware emulation are included
//
-// by James L. Hammons
+// by James Hammons
//
// (C) 2003 Underground Software
//
-// JLH = James L. Hammons <jlhamm@acm.org>
+// JLH = James Hammons <jlhamm@acm.org>
//
// Who When What
-// --- ---------- ------------------------------------------------------------
+// --- ---------- -----------------------------------------------------------
// JLH 03/12/2003 Ported this steaming pile of crap from VESA to SDL
//
// Private function prototypes
-void DrawSprites(uint8 priority);
+void DrawSprites(uint8_t priority);
int FindPCXName(void);
-static void DrawChar(uint8 * chr, uint8 * ram, uint8 sx, uint8 sy, uint16 scp, uint32 baseAddr, uint32 scrollOffset, bool transparent = true);
-void Sprite(uint32 sprnum, uint16 x, uint16 y, uint8 flip, uint8 horiz_bl, uint8 vert_bl);
+static void DrawChar(uint8_t * chr, uint8_t * ram, uint8_t sx, uint8_t sy, uint16_t scp, uint32_t baseAddr, uint32_t scrollOffset, bool transparent = true);
+void Sprite(uint32_t sprnum, uint16_t x, uint16_t y, uint8_t flip, uint8_t horiz_bl, uint8_t vert_bl);
// Private global variables
-uint8 my_scr[0x14000]; // Screen buffer...
-uint8 palette[768]; // Screen palette
-uint8 ccolor[256][8]; // Character colors
-uint8 scolor[128][16]; // Sprite colors
-bool charbase; // Character base pointer...
-uint8 hScrollOffset; // Horizontal scroll offset
-uint8 vScrollOffset; // Vertical scroll offset
-uint8 spr_color_index; // Sprite color index
-uint32 hoffsets[8] = { 0, 1, 2, 3, 4, 5, 6, 7 }; // Scroll offsets...
-uint32 voffsets[8] = { 0, 320, 640, 960, 1280, 1600, 1920, 2240 };
+uint8_t my_scr[0x14000]; // Screen buffer...
+uint8_t palette[768]; // Screen palette
+uint8_t ccolor[256][8]; // Character colors
+uint8_t scolor[128][16]; // Sprite colors
+bool charbase; // Character base pointer...
+uint8_t hScrollOffset; // Horizontal scroll offset
+uint8_t vScrollOffset; // Vertical scroll offset
+uint8_t spr_color_index; // Sprite color index
+uint32_t hoffsets[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };// Scroll offsets...
+uint32_t voffsets[8] = { 0, 320, 640, 960, 1280, 1600, 1920, 2240 };
+
+extern bool show_text; // Whether or not to show text
+extern bool show_scr; // Whether or not to show screen
-extern bool show_text; // Whether or not to show text
-extern bool show_scr; // Whether or not to show screen
//
// Render the NAMCO screen
//
-void BlitChar(SDL_Surface * scr, uint8 * chr, uint8 * ram)
+void BlitChar(SDL_Surface * scr, uint8_t * chr, uint8_t * ram)
{
// Screen structure:
// Screen is 288 x 224 pixels, with character and independent sprites. Tiles are 36 x 28.
if (show_scr)
{
- uint32 sc_base = ((ram[0x9000] << 8) | ram[0x9001]) + 4; // Adjust hscroll val
+ uint32_t sc_base = ((ram[0x9000] << 8) | ram[0x9001]) + 4; // Adjust hscroll val
hScrollOffset = sc_base & 0x07; // Horiz. fine scroll offset
sc_base = (sc_base & 0xFFF8) >> 2; // Skip odds..
- uint8 vsc_base = ((ram[0x9002] + 1) & 0xF8) >> 3;// Vertical scroll addr adjust
+ uint8_t vsc_base = ((ram[0x9002] + 1) & 0xF8) >> 3;// Vertical scroll addr adjust
vScrollOffset = ((ram[0x9002] + 1) & 0x07); // Vertical fine scroll amount
- uint32 scp0 = 0x0180 | ((sc_base + 0x04) & 0x7F); /*0x0188;*/
- uint32 scp1 = 0x1180 | ((sc_base + 0x04) & 0x7F); /*0x1188;*/
- uint32 scp2 = 0x2180 | ((sc_base + 0x04) & 0x7F); /*0x2188;*/
- uint32 scp3 = 0x3208;
+ uint32_t scp0 = 0x0180 | ((sc_base + 0x04) & 0x7F); /*0x0188;*/
+ uint32_t scp1 = 0x1180 | ((sc_base + 0x04) & 0x7F); /*0x1188;*/
+ uint32_t scp2 = 0x2180 | ((sc_base + 0x04) & 0x7F); /*0x2188;*/
+ uint32_t scp3 = 0x3208;
scp0 += vsc_base * 0x80;
scp0 &= 0x0FFF; // Set vertical scroll addr
scp2 = 0x2000 | (scp2 & 0x0FFF); // Set vertical scroll addr
// Layer 0 (bottom layer)
- for(uint8 sy=0; sy<29; sy++)
+ for(uint8_t sy=0; sy<29; sy++)
{
- for(uint8 sx=0; sx<37; sx++)
+ for(uint8_t sx=0; sx<37; sx++)
DrawChar(chr, ram, sx, sy, scp0, (charbase ? 0x20000 : 0x00000), 0, false);
scp0 += 0x80;
DrawSprites(0x40); // Draw sprites at lowest layer...
// Layer 1
- for(uint8 sy=0; sy<29; sy++)
+ for(uint8_t sy=0; sy<29; sy++)
{
- for(uint8 sx=0; sx<37; sx++)
+ for(uint8_t sx=0; sx<37; sx++)
DrawChar(chr, ram, sx, sy, scp1, (charbase ? 0x30000 : 0x10000), 0);
scp1 += 0x80;
DrawSprites(0x80); // Draw sprites under layer #2...
// Layer 2
- for(uint8 sy=0; sy<29; sy++)
+ for(uint8_t sy=0; sy<29; sy++)
{
- for(uint8 sx=0; sx<37; sx++)
+ for(uint8_t sx=0; sx<37; sx++)
DrawChar(chr, ram, sx, sy, scp2, 0x40000, 0);
scp2 += 0x80;
DrawSprites(0xC0); // Draw highest priority sprites...
// Layer 3 (top layer)
- for(uint8 sy=0; sy<28; sy++)
+ for(uint8_t sy=0; sy<28; sy++)
{
- for(uint8 sx=0; sx<36; sx++)
+ for(uint8_t sx=0; sx<36; sx++)
DrawChar(chr, ram, sx, sy, scp3, 0x50000, hScrollOffset + voffsets[vScrollOffset]);
scp3 += 0x80;
// Rolling Thunder screen size is 288 x 224. Virtual is this, real may not be...
// Doubled pixel blit (should be faster now!)
- uint8 * pMem = (uint8 *)scr->pixels;
- uint32 src = (uint32)(hoffsets[hScrollOffset] + voffsets[vScrollOffset]),
+ uint8_t * pMem = (uint8_t *)scr->pixels;
+ uint32_t src = (uint32_t)(hoffsets[hScrollOffset] + voffsets[vScrollOffset]),
dst1 = 0, dst2 = scr->pitch;
- uint32 srcAdd = 320 - VIRTUAL_SCREEN_WIDTH, dstAdd = (scr->pitch * 2) - (VIRTUAL_SCREEN_WIDTH * 2);
+ uint32_t srcAdd = 320 - VIRTUAL_SCREEN_WIDTH, dstAdd = (scr->pitch * 2) - (VIRTUAL_SCREEN_WIDTH * 2);
for(int i=0; i<VIRTUAL_SCREEN_HEIGHT; i++)
{
SDL_UpdateRect(scr, 0, 0, 0, 0);
}
+
//
// Draw character on screen
//
-static inline void DrawChar(uint8 * chr, uint8 * ram, uint8 sx, uint8 sy, uint16 scp, uint32 baseAddr, uint32 scrollOffset, bool transparent/*= true*/)
+static inline void DrawChar(uint8_t * chr, uint8_t * ram, uint8_t sx, uint8_t sy, uint16_t scp, uint32_t baseAddr, uint32_t scrollOffset, bool transparent/*= true*/)
{
- uint8 scp_lo = (scp + (sx << 1)) & 0x7F;// Let LO byte wrap only...
- uint16 sp2 = (scp & 0xFF80) | scp_lo;
- uint8 tile = ram[sp2++];
- uint8 index = ram[sp2] & 0x03;
- uint8 color = ram[sp2];
- uint32 chind = baseAddr + (((index << 8) + tile) * 64);
- uint32 sc_addr = (sx * 8) + (sy * 2560) + scrollOffset; // Start addr in my_scr[]
+ uint8_t scp_lo = (scp + (sx << 1)) & 0x7F;// Let LO byte wrap only...
+ uint16_t sp2 = (scp & 0xFF80) | scp_lo;
+ uint8_t tile = ram[sp2++];
+ uint8_t index = ram[sp2] & 0x03;
+ uint8_t color = ram[sp2];
+ uint32_t chind = baseAddr + (((index << 8) + tile) * 64);
+ uint32_t sc_addr = (sx * 8) + (sy * 2560) + scrollOffset; // Start addr in my_scr[]
for(int y=0; y<8; y++)
{
}
}
+
//
// Draw sprites at priority level (new code)
//
-void DrawSprites(uint8 priority)
+void DrawSprites(uint8_t priority)
{
// Sprite blocks:
//
// 8 Top two bits are sprite priority, bits 4 & 2 are sprite offset hi bit, vert. expand
// 9 Sprite Y position (192 - value)
- extern uint8 gram1[]; // Game RAM space
+ extern uint8_t gram1[]; // Game RAM space
- for(uint16 i=0x5800; i<0x6000; i+=0x10)
+ for(uint16_t i=0x5800; i<0x6000; i+=0x10)
{
if ((gram1[i + 8] & 0xC0) == priority) // Check for correct layer...
{
spr_color_index = gram1[i + 6] >> 1; // Set color...
- uint16 x = ((gram1[i + 6] & 0x01) << 8) | gram1[i + 7];
+ uint16_t x = ((gram1[i + 6] & 0x01) << 8) | gram1[i + 7];
if (x > 512 - 32)
x -= 512; // Handle neg x values
- uint16 y = 192 - gram1[i + 9];
- uint8 flip = gram1[i + 4] & 0x20; // Horizontal flip
- uint32 spr_num = ((gram1[i + 4] & 0x07) << 9) | ((gram1[i + 5] & 0x7F) << 2)
+ uint16_t y = 192 - gram1[i + 9];
+ uint8_t flip = gram1[i + 4] & 0x20; // Horizontal flip
+ uint32_t spr_num = ((gram1[i + 4] & 0x07) << 9) | ((gram1[i + 5] & 0x7F) << 2)
| ((gram1[i + 4] & 0x10) >> 4) | ((gram1[i + 8] & 0x10) >> 3);
// Draw sprite...
}
}
+
//
// Sprite handler
//
-void Sprite(uint32 sprnum, uint16 x, uint16 y, uint8 flip, uint8 horiz_bl, uint8 vert_bl)
+void Sprite(uint32_t sprnum, uint16_t x, uint16_t y, uint8_t flip, uint8_t horiz_bl, uint8_t vert_bl)
{
- extern uint8 spr_rom[];
- uint32 sc_addr;
+ extern uint8_t spr_rom[];
+ uint32_t sc_addr;
x += hScrollOffset; // Adjust x-coord
y += vScrollOffset; // Adjust y-coord
if (!flip)
{
- for(uint16 sy=0; sy<16; sy++)
+ for(uint16_t sy=0; sy<16; sy++)
{
- for(uint16 sx=0; sx<16; sx+=2)
+ for(uint16_t sx=0; sx<16; sx+=2)
{
- uint8 b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
- uint16 spy = y + sy, spx = x + sx; // Need to optimize this clipping!
+ uint8_t b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
+ uint16_t spy = y + sy, spx = x + sx; // Need to optimize this clipping!
if (spy > 223 || spx > 299)
sc_addr = 0x13FFE;
if (horiz_bl)
{
- for(uint16 sy=0; sy<16; sy++)
+ for(uint16_t sy=0; sy<16; sy++)
{
- for(uint16 sx=16; sx<32; sx+=2)
+ for(uint16_t sx=16; sx<32; sx+=2)
{
- uint8 b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
- uint16 spy = y + sy, spx = x + sx;
+ uint8_t b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
+ uint16_t spy = y + sy, spx = x + sx;
if (spy > 223 || spx > 299)
sc_addr = 0x13FFE;
{
y += 16; // Do next row...
- for(uint16 sy=0; sy<16; sy++)
+ for(uint16_t sy=0; sy<16; sy++)
{
- for(uint16 sx=0; sx<16; sx+=2)
+ for(uint16_t sx=0; sx<16; sx+=2)
{
- uint8 b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
- uint16 spy = y + sy, spx = x + sx;
+ uint8_t b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
+ uint16_t spy = y + sy, spx = x + sx;
if (spy > 223 || spx > 299)
sc_addr = 0x13FFE;
if (horiz_bl)
{
- for(uint16 sy=0; sy<16; sy++)
+ for(uint16_t sy=0; sy<16; sy++)
{
- for(uint16 sx=16; sx<32; sx+=2)
+ for(uint16_t sx=16; sx<32; sx+=2)
{
- uint8 b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
- uint16 spy = y + sy, spx = x + sx;
+ uint8_t b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
+ uint16_t spy = y + sy, spx = x + sx;
if (spy > 223 || spx > 299)
sc_addr = 0x13FFE;
}
else // Flip
{
- if (horiz_bl)
- {
- for(uint16 sy=0; sy<16; sy++)
- {
- for(uint16 sx=30; sx!=14; sx-=2)
- {
- uint8 b1 = spr_rom[sprnum]>>4, b2 = spr_rom[sprnum++]&0x0F;
- uint16 spy = y+sy, spx = x+sx;
- if ((spy>223) || (spx>299))
- sc_addr = 0x13FFE;
- else
- sc_addr = spx+spy*320;
- if (b2 != 15)
- my_scr[sc_addr] = scolor[spr_color_index][b2]; // Store it
- sc_addr++;
- if (b1 != 15)
- my_scr[sc_addr] = scolor[spr_color_index][b1]; // Store it
- }
- }
- }
- for(uint16 sy=0; sy<16; sy++)
- {
- for(uint16 sx=14; sx!=0xFFFE; sx-=2)
- {
- uint8 b1 = spr_rom[sprnum]>>4, b2 = spr_rom[sprnum++]&0x0F;
- uint16 spy = y+sy, spx = x+sx;
- if ((spy>223) || (spx>299))
- sc_addr = 0x13FFE;
- else
- sc_addr = spx+spy*320;
- if (b2 != 15)
- my_scr[sc_addr] = scolor[spr_color_index][b2]; // Store it
- sc_addr++;
- if (b1 != 15)
- my_scr[sc_addr] = scolor[spr_color_index][b1]; // Store it
- }
- }
- if (!horiz_bl) sprnum += 128; // If single, skip sprite...
- if (vert_bl)
- {
- y += 16; // Adjust Y coord...
- if (horiz_bl)
- {
- for(uint16 sy=0; sy<16; sy++)
- {
- for(uint16 sx=30; sx!=14; sx-=2)
- {
- uint8 b1 = spr_rom[sprnum]>>4, b2 = spr_rom[sprnum++]&0x0F;
- uint16 spy = y+sy, spx = x+sx;
- if ((spy>223) || (spx>299))
- sc_addr = 0x13FFE;
- else
- sc_addr = spx+spy*320;
- if (b2 != 15)
- my_scr[sc_addr] = scolor[spr_color_index][b2]; // Store it
- sc_addr++;
- if (b1 != 15)
- my_scr[sc_addr] = scolor[spr_color_index][b1]; // Store it
- }
- }
- }
- for(uint16 sy=0; sy<16; sy++)
- {
- for(uint16 sx=14; sx!=0xFFFE; sx-=2)
- {
- uint8 b1 = spr_rom[sprnum]>>4, b2 = spr_rom[sprnum++]&0x0F;
- uint16 spy = y+sy, spx = x+sx;
- if ((spy>223) || (spx>299))
- sc_addr = 0x13FFE;
- else
- sc_addr = spx+spy*320;
- if (b2 != 15)
- my_scr[sc_addr] = scolor[spr_color_index][b2]; // Store it
- sc_addr++;
- if (b1 != 15)
- my_scr[sc_addr] = scolor[spr_color_index][b1]; // Store it
- }
- }
- }
- }
+ if (horiz_bl)
+ {
+ for(uint16_t sy=0; sy<16; sy++)
+ {
+ for(uint16_t sx=30; sx!=14; sx-=2)
+ {
+ uint8_t b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
+ uint16_t spy = y + sy, spx = x + sx;
+
+ if ((spy > 223) || (spx > 299))
+ sc_addr = 0x13FFE;
+ else
+ sc_addr = spx + spy * 320;
+
+ if (b2 != 15)
+ my_scr[sc_addr] = scolor[spr_color_index][b2]; // Store it
+
+ sc_addr++;
+
+ if (b1 != 15)
+ my_scr[sc_addr] = scolor[spr_color_index][b1]; // Store it
+ }
+ }
+ }
+
+ for(uint16_t sy=0; sy<16; sy++)
+ {
+ for(uint16_t sx=14; sx!=0xFFFE; sx-=2)
+ {
+ uint8_t b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
+ uint16_t spy = y + sy, spx = x + sx;
+
+ if ((spy > 223) || (spx > 299))
+ sc_addr = 0x13FFE;
+ else
+ sc_addr = spx+spy*320;
+
+ if (b2 != 15)
+ my_scr[sc_addr] = scolor[spr_color_index][b2]; // Store it
+
+ sc_addr++;
+
+ if (b1 != 15)
+ my_scr[sc_addr] = scolor[spr_color_index][b1]; // Store it
+ }
+ }
+
+ if (!horiz_bl) sprnum += 128; // If single, skip sprite...
+
+ if (vert_bl)
+ {
+ y += 16; // Adjust Y coord...
+
+ if (horiz_bl)
+ {
+ for(uint16_t sy=0; sy<16; sy++)
+ {
+ for(uint16_t sx=30; sx!=14; sx-=2)
+ {
+ uint8_t b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
+ uint16_t spy = y + sy, spx = x + sx;
+
+ if ((spy > 223) || (spx > 299))
+ sc_addr = 0x13FFE;
+ else
+ sc_addr = spx + spy * 320;
+
+ if (b2 != 15)
+ my_scr[sc_addr] = scolor[spr_color_index][b2]; // Store it
+
+ sc_addr++;
+
+ if (b1 != 15)
+ my_scr[sc_addr] = scolor[spr_color_index][b1]; // Store it
+ }
+ }
+ }
+ for(uint16_t sy=0; sy<16; sy++)
+ {
+ for(uint16_t sx=14; sx!=0xFFFE; sx-=2)
+ {
+ uint8_t b1 = spr_rom[sprnum] >> 4, b2 = spr_rom[sprnum++] & 0x0F;
+ uint16_t spy = y + sy, spx = x + sx;
+
+ if ((spy > 223) || (spx > 299))
+ sc_addr = 0x13FFE;
+ else
+ sc_addr = spx + spy * 320;
+
+ if (b2 != 15)
+ my_scr[sc_addr] = scolor[spr_color_index][b2]; // Store it
+
+ sc_addr++;
+
+ if (b1 != 15)
+ my_scr[sc_addr] = scolor[spr_color_index][b1]; // Store it
+ }
+ }
+ }
+ }
}
+
int FindPCXName()
{
static int pcxNum = -1; // This needs to go elsewhere... (or does it?)
return -1;
}
+
void SnapPCX(SDL_Surface * scr)
{
char filename[30];
int YMax = 223;
int bytesPerLine = 320;
+ // Return if failed...
if ((i = FindPCXName()) < 0)
- return; // failed...
+ return;
sprintf(filename, "thnd%04i.pcx", i);
fputc(0x5, fw); // version 5
fputc(0x1, fw); // RLE encoding
fputc(0x8, fw); // bits per pixel
- fputc(0, fw); fputc(0, fw); fputc(0, fw); fputc(0, fw); // XMin=0,YMin=0
- fputc(XMax&0xFF, fw); fputc(XMax>>8, fw);
- fputc(YMax&0xFF, fw); fputc(YMax>>8, fw);
- fputc(0, fw); fputc(0, fw); fputc(0, fw); fputc(0,fw); // unknown DPI
- for (i=0; i<48; i++) fputc(0, fw); // EGA color palette
+ fputc(0, fw);
+ fputc(0, fw);
+ fputc(0, fw);
+ fputc(0, fw); // XMin=0,YMin=0
+ fputc(XMax & 0xFF, fw);
+ fputc(XMax >> 8, fw);
+ fputc(YMax & 0xFF, fw);
+ fputc(YMax >> 8, fw);
+ fputc(0, fw);
+ fputc(0, fw);
+ fputc(0, fw);
+ fputc(0,fw); // unknown DPI
+
+ for (i=0; i<48; i++)
+ fputc(0, fw); // EGA color palette
+
fputc(0, fw); // reserved
fputc(1, fw); // number of bit planes
- fputc(bytesPerLine&0xFF, fw); fputc(bytesPerLine>>8, fw);
- fputc(1, fw); fputc(0, fw); // palette info - unused
- fputc((XMax+1)&0xFF, fw); fputc((XMax+1)>>8, fw);
- fputc((YMax+1)&0xFF, fw); fputc((YMax+1)>>8, fw); // screen resolution
- for (i=0; i<54; i++) fputc(0, fw); // unused
+ fputc(bytesPerLine & 0xFF, fw);
+ fputc(bytesPerLine >> 8, fw);
+ fputc(1, fw);
+ fputc(0, fw); // palette info - unused
+ fputc((XMax + 1) & 0xFF, fw);
+ fputc((XMax + 1) >> 8, fw);
+ fputc((YMax + 1) & 0xFF, fw);
+ fputc((YMax + 1) >> 8, fw); // screen resolution
+
+ for (i=0; i<54; i++)
+ fputc(0, fw); // unused
// Instead of using the screen, we should use our internal buffer...
SDL_LockSurface(scr);
- uint32 mem = scr->pitch * 8; // Skip first line... WAS:320*8;
+ uint32_t mem = scr->pitch * 8; // Skip first line... WAS:320*8;
+
for (line=0; line<=YMax; line++)
{
int count;
int last;
int xpos;
- uint8 * pMem = (uint8 *)scr->pixels;
+ uint8_t * pMem = (uint8_t *)scr->pixels;
xpos = 0;
+
while (xpos < bytesPerLine)
{
last = pMem[mem++];
xpos++;
count = 1;
+
while (pMem[mem] == last && xpos < bytesPerLine && count < 63)
{
mem++; count++; xpos++;
}
- if (count > 1 || (last&0xC0) == 0xC0)
+ if (count > 1 || (last & 0xC0) == 0xC0)
{
- fputc(0xC0 | (count & 0x3F), fw); fputc(last & 0xFF, fw);
+ fputc(0xC0 | (count & 0x3F), fw);
+ fputc(last & 0xFF, fw);
}
- else fputc(last & 0xFF, fw);
+ else
+ fputc(last & 0xFF, fw);
}
mem += (scr->pitch - 320); // Handle non-standard line lengths...
}
SDL_UnlockSurface(scr);
// Write the palette
-
fputc(0x0C, fw);
+
for (i=0; i<768; i++)
fputc(palette[i], fw);
fclose(fw); // success!
}
+
//
// SCREEN.H
//
-// by James L. Hammons
-// (C) 1997 Underground Software
+// by James Hammons
+// (C) 1997, 2014 Underground Software
//
#ifndef __SCREEN_H__
#define __SCREEN_H__
#include "SDL.h"
-#include "types.h"
+#include <stdint.h>
#define VIRTUAL_SCREEN_WIDTH 288
#define VIRTUAL_SCREEN_HEIGHT 224
void SnapPCX(SDL_Surface *); // Take a PCX snapshot
-void BlitChar(SDL_Surface *, uint8 *, uint8 *); // Show NAMCO screen
+void BlitChar(SDL_Surface *, uint8_t *, uint8_t *); // Show NAMCO screen
#endif // __SCREEN_H__
+
//
// Thunder: A Rolling Thunder Emulator w/6809 debugger
//
-// by James L. Hammons
-// (c) 2004, 2009 Underground Software
+// by James Hammons
+// (C) 2004, 2014 Underground Software
//
-// JLH = James L. Hammons <jlhamm@acm.org>
+// JLH = James Hammons <jlhamm@acm.org>
//
// WHO WHEN WHAT
-// --- ---------- ------------------------------------------------------------
+// --- ---------- -----------------------------------------------------------
// JLH 07/23/2009 Added changelog ;-)
// JLH 08/12/2009 Stabilized emulation so that it works
//
-#define THUNDER_VERSION "0.9.9"
+#define THUNDER_VERSION "1.0.0"
#include <iostream>
#include <iomanip>
#include <new>
#include <stdio.h>
#include <stdlib.h>
+#include <stdint.h>
//#include <conio.h> // For getch()
#include <curses.h> // For getch()
#include <time.h>
#include "SDL.h" // Get yer SDL out...!
-#include "types.h"
#include "v6809.h"
#include "screen.h"
#include "gui.h"
using namespace std; // Yes!
-#if 0
-#define ROM1 "RT3-1B.ROM"
-#define ROM2 "RT3-2B.ROM"
-#define ROM3 "RT3-3.ROM"
-#define ROM4 "RT3-4.ROM"
-#define ROM5 "RT1-5.ROM"
-#define ROM6 "RT1-6.ROM"
-#define ROM7 "RT1-7.ROM"
-#define ROM8 "RT1-8.ROM"
-#define ROM9 "RT1-9.ROM"
-#define ROM10 "RT1-10.ROM"
-#define ROM11 "RT1-11.ROM"
-#define ROM12 "RT1-12.ROM"
-#define ROM13 "RT1-13.ROM"
-#define ROM14 "RT1-14.ROM"
-#define ROM15 "RT1-15.ROM"
-#define ROM16 "RT1-16.ROM"
-#define ROM17 "RT1-17.ROM"
-#define ROM18 "RT1-18.ROM"
-#define ROM19 "RT3-19.ROM"
-#define ROM20 "RT3-20.ROM"
-#define ROM21 "RT1-21.ROM"
-#define ROM22 "RT2-22.ROM"
-#define PROM1 "RT1-1.BIN"
-#define PROM2 "RT1-2.BIN"
-#define PROM3 "RT1-3.BIN"
-#define PROM4 "RT1-4.BIN"
-#define PROM5 "RT1-5.BIN"
-#else
+
#define ROM1 "rt3-1b.9c"
#define ROM2 "rt3-2b.12c"
#define ROM3 "rt3-3.12d"
#define PROM4 "mb7138h.6v"
#define PROM5 "mb7112e.6u"
#define MCUROM "rt1-mcu.bin"
-#endif
+
// Global defines
SDL_Surface * screen;
-uint8 * gram, * grom; // Allocate RAM & ROM pointers
-uint8 gram1[0x10000], gram2[0x10000], grom1[0x10000], grom2[0x10000]; // Actual memory
-uint8 grom3[0x8000], grom4[0x8000], data_rom[0x40000], spr_rom[0x80000], voice_rom[0x20000];
-uint8 chr_rom[0x60000]; // Character ROM pointer
+uint8_t * gram, * grom; // Allocate RAM & ROM pointers
+uint8_t gram1[0x10000], gram2[0x10000], grom1[0x10000], grom2[0x10000]; // Actual memory
+uint8_t grom3[0x8000], grom4[0x8000], data_rom[0x40000], spr_rom[0x80000], voice_rom[0x20000];
+uint8_t chr_rom[0x60000]; // Character ROM pointer
V6809REGS cpu1, cpu2;
-bool trace1 = false; // ditto...
-bool looking_at_rom = true; // true = R1, false = R2
-uint32 banksw1, banksw2; // Bank switch addresses
-uint16 game_over_switch; // Game over delay
-uint16 dpc; // Debug pc reg...
-bool show_scr = true; // Whether or not to show background
-bool enable_cpu = true; // Whether or not to enable CPUs
-bool irqGoA = true; // IRQ switch for CPU #1
-bool irqGoB = true; // IRQ switch for CPU #2
-
-uint16 refresh_ = 0; // Crappy global screen stuff...
+bool trace1 = false; // ditto...
+bool looking_at_rom = true; // true = R1, false = R2
+uint32_t banksw1, banksw2; // Bank switch addresses
+uint16_t game_over_switch; // Game over delay
+uint16_t dpc; // Debug pc reg...
+bool show_scr = true; // Whether or not to show background
+bool enable_cpu = true; // Whether or not to enable CPUs
+bool irqGoA = true; // IRQ switch for CPU #1
+bool irqGoB = true; // IRQ switch for CPU #2
+
+uint16_t refresh_ = 0; // Crappy global screen stuff...
bool refresh2 = true;
-uint32 psg_lens[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-uint8 * psg_adrs[16];
-uint32 voc_lens[32] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+uint32_t psg_lens[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+uint8_t * psg_adrs[16];
+uint32_t voc_lens[32] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-uint8 * voc_adrs[32];
-uint32 fm_lens[14] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-uint8 * fm_adrs[14];
+uint8_t * voc_adrs[32];
+uint32_t fm_lens[14] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+uint8_t * fm_adrs[14];
-fstream tr; // Tracelog hook
-uint16 pcx; // Where we at?
+fstream tr; // Tracelog hook
+uint16_t pcx; // Where we at?
-static uint8 * keys; // SDL raw keyboard matrix
+static uint8_t * keys; // SDL raw keyboard matrix
static char op_mat1[256] = {
1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,
"A", "B", "CC", "DP", "??", "??", "??", "??" },
iregs[4][2] = {"X", "Y", "U", "S" };
+
//
// Read a byte from memory (without touching PC. Not a Fetch!)
//
-uint8 RdMem(uint16 addr)
+uint8_t RdMem(uint16_t addr)
{
- uint8 b;
+ uint8_t b;
// $4000-4300 is RAM shared with the microcontroller...
return b;
}
+
//
// Write a byte to memory
//
-void WrMem(uint16 addr, uint8 b)
+void WrMem(uint16_t addr, uint8_t b)
{
extern bool disasm;
extern bool charbase; // Needed for screen. Extern it in it??
- //extern uint16 sr, ur, xr, yr; // Needed for tracelog
- //extern uint16 pcr;
+ //extern uint16_t sr, ur, xr, yr; // Needed for tracelog
+ //extern uint16_t pcr;
/* if ((addr>0x40FF) && (addr<0x4390))
{
tr << hex << addr << ":" << (int)b;
//for(int i=0; i<32; i++)
//{
// if (gram1[0x4400+i]<0x10) tr << "0";
- // tr << hex << (uint16)gram1[0x4400+i] << " ";
+ // tr << hex << (uint16_t)gram1[0x4400+i] << " ";
//}
tr << endl;
}//*/
if (addr == 0x6400)
SpawnSound(GAMESOUND, gram1[0x6600], 1); // Do voice chan 2
if (addr == 0x6800)
- banksw1 = (uint32)b << 13; // Set char data bankswitch base address
+ banksw1 = (uint32_t)b << 13; // Set char data bankswitch base address
if (addr > 0x4284 && addr < 0x42A5 && b)
SpawnSound(PSGSOUND, addr - 0x4285); // Do PSG sound on chans 2, 3
if (addr == 0x4380)
}
}
+
//
// Read a byte from memory (without touching PC. Not a Fetch!) (2nd processor)
//
-uint8 RdMemB(uint16 addr)
+uint8_t RdMemB(uint16_t addr)
{
-// extern uint16 cpu2.s, cpu2.u, cpu2.x, cpu2.y; // Needed for tracelog
- uint8 b;
+// extern uint16_t cpu2.s, cpu2.u, cpu2.x, cpu2.y; // Needed for tracelog
+ uint8_t b;
if (addr < 0x8000)
{
return b;
}
+
//
// Write a byte to memory (2nd processor)
//
-void WrMemB(uint16 addr, uint8 b)
+void WrMemB(uint16_t addr, uint8_t b)
{
extern bool disasm;
extern bool charbase;
- //extern uint16 sr, ur, xr, yr; // Needed for tracelog
- //extern uint16 pcr;
+ //extern uint16_t sr, ur, xr, yr; // Needed for tracelog
+ //extern uint16_t pcr;
/* if ((addr>0x00FF) && (addr<0x0390))
{
tr << hex << addr << ":" << (int)b;
//for(int i=0; i<32; i++)
//{
// if (gram1[0x4400+i]<0x10) tr << "0";
- // tr << hex << (uint16)gram1[0x4400+i] << " ";
+ // tr << hex << (uint16_t)gram1[0x4400+i] << " ";
//}
tr << endl;
}//*/
if (addr > 0x0284 && addr < 0x02A5 && b)
SpawnSound(PSGSOUND, addr - 0x0285); // Do PSG sound on chans 2, 3
if (addr == 0xD803)
- banksw2 = (uint32)(b & 0x03) << 13; // Set sprite data bank switch
+ banksw2 = (uint32_t)(b & 0x03) << 13; // Set sprite data bank switch
if (addr == 0x0380)
{
SpawnSound(FMSOUND, b); // Do FM sound on chan 4
}
}
+
//
// Display bytes in mem in hex
//
-void DisplayBytes(uint16 src, unsigned long dst)
+void DisplayBytes(uint16_t src, unsigned long dst)
{
- uint8 cnt;
- unsigned long i;
+ uint8_t cnt = 0;
+ WriteLog("%04X: ", src);
- WriteLog("%04X: ", src);
- cnt = 0; // Init counter...
- if (src > dst) dst += 0x10000; // That should fix the FFFF bug...
- for(i=src; i<dst; i++)
- {
- WriteLog("%02X ", (uint8)(looking_at_rom ? RdMem(i) : RdMemB(i)));
- cnt++; // Bump counter...
- }
- for(i=cnt; i<5; i++) // Pad the leftover spaces...
- {
- WriteLog(" ");
- }
+ if (src > dst)
+ dst += 0x10000; // That should fix the FFFF bug...
+
+ for(unsigned long i=src; i<dst; i++)
+ {
+ WriteLog("%02X ", (uint8_t)(looking_at_rom ? RdMem(i) : RdMemB(i)));
+ cnt++;
+ }
+
+ // Pad the leftover spaces...
+ for(unsigned long i=cnt; i<5; i++)
+ WriteLog(" ");
}
+
// temp crap...
-uint8 Fetch(void) { return RdMem(dpc); }
-uint16 FetchW(void) { return (uint16)((RdMem(dpc) << 8) | RdMem(dpc+1)); }
-uint8 FetchB(void) { return RdMemB(dpc); }
-uint16 FetchWB(void) { return (uint16)((RdMemB(dpc) << 8) | RdMemB(dpc+1)); }
+uint8_t Fetch(void) { return RdMem(dpc); }
+uint16_t FetchW(void) { return (uint16_t)((RdMem(dpc) << 8) | RdMem(dpc+1)); }
+uint8_t FetchB(void) { return RdMemB(dpc); }
+uint16_t FetchWB(void) { return (uint16_t)((RdMemB(dpc) << 8) | RdMemB(dpc+1)); }
+
//
// Decode a 6809 instruction at 'addr'
//
void Decode_6809()
{
- uint8 (* DFetch)(); // Decode Fetch() pointer...
- uint16 (* DFetchW)(); // Decode FetchW() pointer...
- DFetch = (looking_at_rom ? Fetch : FetchB);
- DFetchW = (looking_at_rom ? FetchW : FetchWB);
-
-/* extern*/ uint16 pcr, pcrB; // Pull in 'pcr' from '6809.cpp'
- uint16 pc_save = pcr, pcB_save = pcrB;
- pcr = dpc; pcrB = dpc;
- uint8 opcode = DFetch(); // Get the opcode ('fetch' cycle)
- uint8 opcode2, operand;
- uint16 loperand;
- uint8 admode = op_mat1[opcode]; // addressing mode
- char outbuf[80], mnem[6], tmp[30];
-
- strcpy(mnem, mnemonics[opcode]); // Copy page 1 opcode
- if (opcode == 0x10) // Extended opcode?
- {
- opcode2 = DFetch(); // Then get next byte
- admode = op_mat2[opcode2]; // And use it as index into 'op_mat2'
- strcpy(mnem, mnemonics2[opcode2]); // Overwrite mnemonic
- }
- if (opcode == 0x11) // Same as above...
- {
- opcode2 = DFetch();
- admode = op_mat3[opcode2];
- strcpy(mnem, mnemonics3[opcode2]); // Overwrite mnemonic
- }
- switch(admode) // Decode it...
- {
- case 0: // Illegal
- { sprintf(outbuf, "???"); break; }
- case 1: // Zero page
- { operand = DFetch(); // Get ZP address
- sprintf(outbuf, "%s $%02X", mnem, operand);
- break; }
- case 2: // Absolute
- { loperand = DFetchW(); // Get ABS address
- sprintf(outbuf, "%s $%04X", mnem, loperand);
- break; }
- case 3: // Relative
- { operand = DFetch(); // Get offset
- uint16 tmpc = (looking_at_rom ? pcr : pcrB);
- sprintf(outbuf, "%s $%04X", mnem, tmpc+(int16)(int8)operand);
- break; }
- case 4: // Long Relative
- { loperand = DFetchW(); // Get long offset
- uint16 tmpc = (looking_at_rom ? pcr : pcrB);
- sprintf(outbuf, "%s $%04X", mnem, tmpc+(int16)loperand);
- break; }
- case 5: // Inherent
- { sprintf(outbuf, "%s ", mnem);
- break; }
- case 6: // Txfr/exchg/push/pull
- { operand = DFetch(); // Get txfr/exg/push/pull byte
- if ((opcode == 0x1E) || (opcode == 0x1F)) // Is it TXF/EXG?
- {
- sprintf(tmp, "%s,%s", tregs[operand>>4], tregs[operand&0x0F]);
- }
- else
- {
- tmp[0] = 0;
- if (operand&0x01) strcat(tmp, "CC ");
- if (operand&0x02) strcat(tmp, "A ");
- if (operand&0x04) strcat(tmp, "B ");
- if (operand&0x08) strcat(tmp, "DP ");
- if (operand&0x10) strcat(tmp, "X ");
- if (operand&0x20) strcat(tmp, "Y ");
- if (operand&0x40) (((opcode==0x34)||(opcode==0x35))
- ? strcat(tmp, "U ") : strcat(tmp, "S "));
- if (operand&0x80) strcat(tmp, "PC");
- }
- sprintf(outbuf, "%s %s", mnem, tmp);
- break; }
- case 7: // Indexed (the tough one!)
- { operand = DFetch(); // Get IDX byte
- uint8 reg = ((operand & 0x60) >> 5), idxind = ((operand & 0x10) >> 4),
- lo_nyb = (operand & 0x0F), boff;
- uint16 woff;
-
- strcpy(tmp, "??");
- if (!(operand & 0x80)) // Hi bit set? Then decode 4 bit offset
- {
- sprintf(tmp, "(%d),%s", (idxind ? -(16-lo_nyb) : lo_nyb),
- iregs[reg]);
- }
- else // Add the ($nnnn,R) code dude...
- {
- if (idxind)
- {
- switch(lo_nyb)
- {
- case 1: sprintf(tmp, "(,%s++)", iregs[reg]); break;
- case 3: sprintf(tmp, "(,--%s)", iregs[reg]); break;
- case 4: sprintf(tmp, "(,%s)", iregs[reg]); break;
- case 5: sprintf(tmp, "(B,%s)", iregs[reg]); break;
- case 6: sprintf(tmp, "(A,%s)", iregs[reg]); break;
- case 8:
- { boff = DFetch(); sprintf(tmp, "($%02X,%s)", boff,
- iregs[reg]); break; }
- case 9:
- { woff = DFetchW(); sprintf(tmp, "($%04X,%s)", woff,
- iregs[reg]); break; }
- case 11: sprintf(tmp, "(D,%s)", iregs[reg]); break;
- case 12:
- { boff = DFetch(); sprintf(tmp, "($%02X,PC)", boff); break; }
- case 13:
- { woff = DFetchW(); sprintf(tmp, "($%04X,PC)", woff); break; }
- case 15:
- { woff = DFetchW(); sprintf(tmp, "[$%04X]", woff); break; }
- default: strcpy(tmp, "??");
- }
- }
- else
- {
- switch(lo_nyb)
- {
- case 0: sprintf(tmp, ",%s+", iregs[reg]); break;
- case 1: sprintf(tmp, ",%s++", iregs[reg]); break;
- case 2: sprintf(tmp, ",-%s", iregs[reg]); break;
- case 3: sprintf(tmp, ",--%s", iregs[reg]); break;
- case 4: sprintf(tmp, ",%s", iregs[reg]); break;
- case 5: sprintf(tmp, "(B),%s", iregs[reg]); break;
- case 6: sprintf(tmp, "(A),%s", iregs[reg]); break;
- case 8:
- { boff = DFetch(); sprintf(tmp, "($%02X),%s", boff,
- iregs[reg]); break; }
- case 9:
- { woff = DFetchW(); sprintf(tmp, "($%04X),%s", woff,
- iregs[reg]); break; }
- case 11: sprintf(tmp, "(D),%s", iregs[reg]); break;
- case 12:
- { boff = DFetch(); sprintf(tmp, "($%02X),PC", boff); break; }
- case 13:
- { woff = DFetchW(); sprintf(tmp, "($%04X),PC", woff); break; }
- default: strcpy(tmp, "??");
- }
- }
- }
- sprintf(outbuf, "%s %s", mnem, tmp);
- break; }
- case 8: // Immediate
- { operand = DFetch(); // Get IMM byte
- sprintf(outbuf, "%s #$%02X", mnem, operand);
- break; }
- case 9: // Long Immediate
- { loperand = DFetchW(); // Get IMM word
- sprintf(outbuf, "%s #$%04X", mnem, loperand);
- break; }
- }
- DisplayBytes(dpc, (looking_at_rom ? pcr : pcrB)); // Show bytes
- WriteLog(outbuf); WriteLog("\n"); // display opcode & addressing, etc
- dpc = (looking_at_rom ? pcr : pcrB); // Advance debug PC
- pcr = pc_save; pcrB = pcB_save; // Restore PCs
+ uint8_t (* DFetch)(); // Decode Fetch() pointer...
+ uint16_t (* DFetchW)(); // Decode FetchW() pointer...
+ DFetch = (looking_at_rom ? Fetch : FetchB);
+ DFetchW = (looking_at_rom ? FetchW : FetchWB);
+
+ /* extern*/ uint16_t pcr, pcrB; // Pull in 'pcr' from '6809.cpp'
+ uint16_t pc_save = pcr, pcB_save = pcrB;
+ pcr = dpc; pcrB = dpc;
+ uint8_t opcode = DFetch(); // Get the opcode ('fetch' cycle)
+ uint8_t opcode2, operand;
+ uint16_t loperand;
+ uint8_t admode = op_mat1[opcode]; // addressing mode
+ char outbuf[80], mnem[6], tmp[30];
+
+ strcpy(mnem, mnemonics[opcode]); // Copy page 1 opcode
+
+ if (opcode == 0x10) // Extended opcode?
+ {
+ opcode2 = DFetch(); // Then get next byte
+ admode = op_mat2[opcode2]; // And use it as index into 'op_mat2'
+ strcpy(mnem, mnemonics2[opcode2]); // Overwrite mnemonic
+ }
+
+ if (opcode == 0x11) // Same as above...
+ {
+ opcode2 = DFetch();
+ admode = op_mat3[opcode2];
+ strcpy(mnem, mnemonics3[opcode2]); // Overwrite mnemonic
+ }
+
+ // Decode it...
+ switch (admode)
+ {
+ case 0: // Illegal
+ sprintf(outbuf, "???");
+ break;
+ case 1: // Zero page
+ operand = DFetch(); // Get ZP address
+ sprintf(outbuf, "%s $%02X", mnem, operand);
+ break;
+ case 2: // Absolute
+ loperand = DFetchW(); // Get ABS address
+ sprintf(outbuf, "%s $%04X", mnem, loperand);
+ break;
+ case 3: // Relative
+ {
+ operand = DFetch(); // Get offset
+ uint16_t tmpc = (looking_at_rom ? pcr : pcrB);
+ sprintf(outbuf, "%s $%04X", mnem, tmpc+(int16_t)(int8_t)operand);
+ break;
+ }
+ case 4: // Long Relative
+ {
+ loperand = DFetchW(); // Get long offset
+ uint16_t tmpc = (looking_at_rom ? pcr : pcrB);
+ sprintf(outbuf, "%s $%04X", mnem, tmpc+(int16_t)loperand);
+ break;
+ }
+ case 5: // Inherent
+ sprintf(outbuf, "%s ", mnem);
+ break;
+ case 6: // Txfr/exchg/push/pull
+ {
+ operand = DFetch(); // Get txfr/exg/push/pull byte
+
+ if ((opcode == 0x1E) || (opcode == 0x1F)) // Is it TXF/EXG?
+ {
+ sprintf(tmp, "%s,%s", tregs[operand>>4], tregs[operand&0x0F]);
+ }
+ else
+ {
+ tmp[0] = 0;
+ if (operand&0x01) strcat(tmp, "CC ");
+ if (operand&0x02) strcat(tmp, "A ");
+ if (operand&0x04) strcat(tmp, "B ");
+ if (operand&0x08) strcat(tmp, "DP ");
+ if (operand&0x10) strcat(tmp, "X ");
+ if (operand&0x20) strcat(tmp, "Y ");
+ if (operand&0x40) (((opcode==0x34)||(opcode==0x35))
+ ? strcat(tmp, "U ") : strcat(tmp, "S "));
+ if (operand&0x80) strcat(tmp, "PC");
+ }
+ sprintf(outbuf, "%s %s", mnem, tmp);
+ break;
+ }
+ case 7: // Indexed (the tough one!)
+ {
+ operand = DFetch(); // Get IDX byte
+ uint8_t reg = ((operand & 0x60) >> 5), idxind = ((operand & 0x10) >> 4),
+ lo_nyb = (operand & 0x0F), boff;
+ uint16_t woff;
+
+ strcpy(tmp, "??");
+
+ if (!(operand & 0x80)) // Hi bit set? Then decode 4 bit offset
+ {
+ sprintf(tmp, "(%d),%s", (idxind ? -(16-lo_nyb) : lo_nyb),
+ iregs[reg]);
+ }
+ else // Add the ($nnnn,R) code dude...
+ {
+ if (idxind)
+ {
+ switch (lo_nyb)
+ {
+ case 1: sprintf(tmp, "(,%s++)", iregs[reg]); break;
+ case 3: sprintf(tmp, "(,--%s)", iregs[reg]); break;
+ case 4: sprintf(tmp, "(,%s)", iregs[reg]); break;
+ case 5: sprintf(tmp, "(B,%s)", iregs[reg]); break;
+ case 6: sprintf(tmp, "(A,%s)", iregs[reg]); break;
+ case 8:
+ { boff = DFetch(); sprintf(tmp, "($%02X,%s)", boff,
+ iregs[reg]); break; }
+ case 9:
+ { woff = DFetchW(); sprintf(tmp, "($%04X,%s)", woff,
+ iregs[reg]); break; }
+ case 11: sprintf(tmp, "(D,%s)", iregs[reg]); break;
+ case 12:
+ { boff = DFetch(); sprintf(tmp, "($%02X,PC)", boff); break; }
+ case 13:
+ { woff = DFetchW(); sprintf(tmp, "($%04X,PC)", woff); break; }
+ case 15:
+ { woff = DFetchW(); sprintf(tmp, "[$%04X]", woff); break; }
+ default: strcpy(tmp, "??");
+ }
+ }
+ else
+ {
+ switch (lo_nyb)
+ {
+ case 0: sprintf(tmp, ",%s+", iregs[reg]); break;
+ case 1: sprintf(tmp, ",%s++", iregs[reg]); break;
+ case 2: sprintf(tmp, ",-%s", iregs[reg]); break;
+ case 3: sprintf(tmp, ",--%s", iregs[reg]); break;
+ case 4: sprintf(tmp, ",%s", iregs[reg]); break;
+ case 5: sprintf(tmp, "(B),%s", iregs[reg]); break;
+ case 6: sprintf(tmp, "(A),%s", iregs[reg]); break;
+ case 8:
+ { boff = DFetch(); sprintf(tmp, "($%02X),%s", boff,
+ iregs[reg]); break; }
+ case 9:
+ { woff = DFetchW(); sprintf(tmp, "($%04X),%s", woff,
+ iregs[reg]); break; }
+ case 11: sprintf(tmp, "(D),%s", iregs[reg]); break;
+ case 12:
+ { boff = DFetch(); sprintf(tmp, "($%02X),PC", boff); break; }
+ case 13:
+ { woff = DFetchW(); sprintf(tmp, "($%04X),PC", woff); break; }
+ default: strcpy(tmp, "??");
+ }
+ }
+ }
+
+ sprintf(outbuf, "%s %s", mnem, tmp);
+ break;
+ }
+ case 8: // Immediate
+ operand = DFetch(); // Get IMM byte
+ sprintf(outbuf, "%s #$%02X", mnem, operand);
+ break;
+ case 9: // Long Immediate
+ loperand = DFetchW(); // Get IMM word
+ sprintf(outbuf, "%s #$%04X", mnem, loperand);
+ break;
+ }
+
+ DisplayBytes(dpc, (looking_at_rom ? pcr : pcrB)); // Show bytes
+ WriteLog(outbuf);
+ WriteLog("\n"); // display opcode & addressing, etc
+ dpc = (looking_at_rom ? pcr : pcrB); // Advance debug PC
+ pcr = pc_save;
+ pcrB = pcB_save; // Restore PCs
}
+
//
// Convert hex to dec
//
-uint16 htod(char *str)
+uint16_t htod(char * str)
{
- uint16 value = 0;
- int len = strlen(str);
+ uint16_t value = 0;
+ int len = strlen(str);
- for(int i=0; i<len; i++)
- {
- if (str[i]>='0' && str[i]<='9')
- {
- value = (value<<4) | (unsigned)(str[i]-'0');
- }
- if (str[i]>='a' && str[i]<='f')
- {
- value = (value<<4) | (unsigned)(str[i]-'a')+10;
- }
- if (str[i]>='A' && str[i]<='F')
- {
- value = (value<<4) | (unsigned)(str[i]-'A')+10;
- }
- }
- return(value);
+ for(int i=0; i<len; i++)
+ {
+ if (str[i] >= '0' && str[i] <= '9')
+ {
+ value = (value << 4) | (unsigned)(str[i] - '0');
+ }
+ else if (str[i] >= 'a' && str[i] <= 'f')
+ {
+ value = (value << 4) | (unsigned)((str[i] - 'a') + 10);
+ }
+ else if (str[i] >= 'A' && str[i] <= 'F')
+ {
+ value = (value << 4) | (unsigned)((str[i] - 'A') + 10);
+ }
+ }
+
+ return value;
}
+
//
// Load 32K file into ROM image space
//
-bool Load32KImg(char * filename, uint16 address)
+bool Load32KImg(char * filename, uint16_t address)
{
- ifstream ff;
- char ch;
+ ifstream ff;
+ char ch;
- ff.open(filename, ios::binary | ios::in); // Open 'da file...
- if (ff)
- {
- for(long i=0; i<32768; i++) // Read it in...
- {
- ff.get(ch);
- grom[address+i] = ch;
- }
- ff.close(); // Close 'da file...
- }
- return(ff);
+ ff.open(filename, ios::binary | ios::in); // Open 'da file...
+
+ if (ff)
+ {
+ for(long i=0; i<32768; i++) // Read it in...
+ {
+ ff.get(ch);
+ grom[address+i] = ch;
+ }
+
+ ff.close(); // Close 'da file...
+ }
+
+ return ff;
}
+
//
// Generic Load file into image space
// (No error checking performed! Responsibility of caller!)
//
-bool LoadImg(const char * filename, uint8 * mem, uint32 address, uint32 length)
+bool LoadImg(const char * filename, uint8_t * mem, uint32_t address, uint32_t length)
{
- ifstream ff;
- char path[80];
- char ch;
+ ifstream ff;
+ char path[80];
+ char ch;
- strcpy(path, "./ROMs/");
- strcat(path, filename);
+ strcpy(path, "./ROMs/");
+ strcat(path, filename);
// ff.open(filename, ios::binary | ios::in); // Open 'da file...
- ff.open(path, ios::binary | ios::in); // Open 'da file...
- if (ff)
- {
- for(uint32 i=0; i<length; i++) // Read it in...
- {
- ff.get(ch);
- mem[address+i] = ch;
- }
- ff.close(); // Close 'da file...
- }
- return(ff);
+ ff.open(path, ios::binary | ios::in); // Open 'da file...
+
+ if (ff)
+ {
+ for(uint32_t i=0; i<length; i++) // Read it in...
+ {
+ ff.get(ch);
+ mem[address+i] = ch;
+ }
+
+ ff.close(); // Close 'da file...
+ }
+
+ return ff;
}
+
//
// Read color PROMs
//
bool ReadColorPROMs(void)
{
- fstream ff1, ff2;
-// uint8 ch;
- char ch;
- extern uint8 palette[768]; // Screen physical palette
- extern uint8 ccolor[256][8]; // Character color PROM values
- extern uint8 scolor[128][16]; // Sprite color PROM values
-
- ff1.open("./ROMs/"PROM3, ios::binary|ios::in);
- if (ff1)
- {
- for(int i=0; i<256; i++) // Load char pallete with PROM values
- {
- for(int j=0; j<8; j++)
- {
- ff1.get(ch);
- ccolor[i][j] = (uint8)ch;
- }
- }
- ff1.close();
- }
- ff1.open("./ROMs/"PROM4, ios::binary|ios::in);
- if (ff1)
- {
- for(int i=0; i<128; i++) // Load sprite pallete with PROM values
- {
- for(int j=0; j<16; j++)
- {
- ff1.get(ch);
- scolor[i][j] = (uint8)ch;
- }
- }
- ff1.close();
- }
-
- ff1.open("./ROMs/"PROM1, ios::binary|ios::in);
- ff2.open("./ROMs/"PROM2, ios::binary|ios::in);
- if (ff1) // If open was successful...
- {
- for(int i=0; i<768; i+=3)
- {
- ff1.get(ch);
- palette[i] = (uint8)(ch&0x0F);
- palette[i+1] = (uint8)(ch>>4);
- ff2.get(ch);
- palette[i+2] = (uint8)ch;
- }
-
- // Do palette stretching here... I.e. add 0 to hinyb 0, 1 to hinyb 1, etc.
-
- for(int i=0; i<768; i++)
- palette[i] = ((palette[i]<<4)&0xF0) | (palette[i]&0x0F);
-
- ff1.close();
- ff2.close();
- }
- return ff1;
+ fstream ff1, ff2;
+ // uint8_t ch;
+ char ch;
+ extern uint8_t palette[768]; // Screen physical palette
+ extern uint8_t ccolor[256][8]; // Character color PROM values
+ extern uint8_t scolor[128][16]; // Sprite color PROM values
+
+ ff1.open("./ROMs/"PROM3, ios::binary|ios::in);
+
+ if (ff1)
+ {
+ for(int i=0; i<256; i++) // Load char pallete with PROM values
+ {
+ for(int j=0; j<8; j++)
+ {
+ ff1.get(ch);
+ ccolor[i][j] = (uint8_t)ch;
+ }
+ }
+
+ ff1.close();
+ }
+
+ ff1.open("./ROMs/"PROM4, ios::binary|ios::in);
+
+ if (ff1)
+ {
+ for(int i=0; i<128; i++) // Load sprite pallete with PROM values
+ {
+ for(int j=0; j<16; j++)
+ {
+ ff1.get(ch);
+ scolor[i][j] = (uint8_t)ch;
+ }
+ }
+
+ ff1.close();
+ }
+
+ ff1.open("./ROMs/"PROM1, ios::binary|ios::in);
+ ff2.open("./ROMs/"PROM2, ios::binary|ios::in);
+
+ if (ff1) // If open was successful...
+ {
+ for(int i=0; i<768; i+=3)
+ {
+ ff1.get(ch);
+ palette[i] = (uint8_t)(ch&0x0F);
+ palette[i+1] = (uint8_t)(ch>>4);
+ ff2.get(ch);
+ palette[i+2] = (uint8_t)ch;
+ }
+
+ // Do palette stretching here... I.e. add 0 to hinyb 0, 1 to hinyb 1, etc.
+
+ for(int i=0; i<768; i++)
+ palette[i] = ((palette[i]<<4)&0xF0) | (palette[i]&0x0F);
+
+ ff1.close();
+ ff2.close();
+ }
+
+ return ff1;
}
+
//
// Unpack font data
//
bool UnpackFonts(void)
{
-// uint8 b1, b2, b3;
- char b1, b2, b3;
- fstream f1, f2;
- //0x4000 $800 chars
- f1.open("./ROMs/"ROM7, ios::binary | ios::in);
- f2.open("./ROMs/"ROM8, ios::binary | ios::in);
- if ((!f1) || (!f2)) return false; // Return if not found...
- for(long i=0; i<0x40000; i+=64)
- {
- for(int j=0; j<64; j+=8)
- {
- f1.get(b1); f1.get(b2); f2.get(b3);
- b3 ^= 0xFF; // Invert top data...
- chr_rom[i+j] = ((b3 & 0x80) >> 5) | ((b1 & 0x80) >> 6) | ((b1 & 0x08) >> 3);
- chr_rom[i+j+1] = ((b3 & 0x40) >> 4) | ((b1 & 0x40) >> 5) | ((b1 & 0x04) >> 2);
- chr_rom[i+j+2] = ((b3 & 0x20) >> 3) | ((b1 & 0x20) >> 4) | ((b1 & 0x02) >> 1);
- chr_rom[i+j+3] = ((b3 & 0x10) >> 2) | ((b1 & 0x10) >> 3) | (b1 & 0x01);
- chr_rom[i+j+4] = ((b3 & 0x08) >> 1) | ((b2 & 0x80) >> 6) | ((b2 & 0x08) >> 3);
- chr_rom[i+j+5] = (b3 & 0x04) | ((b2 & 0x40) >> 5) | ((b2 & 0x04) >> 2);
- chr_rom[i+j+6] = ((b3 & 0x02) << 1) | ((b2 & 0x20) >> 4) | ((b2 & 0x02) >> 1);
- chr_rom[i+j+7] = ((b3 & 0x01) << 2) | ((b2 & 0x10) >> 3) | (b2 & 0x01);
- }
- }
- f1.close();
- f2.close();
-
- f1.open("./ROMs/"ROM5, ios::binary | ios::in);
- f2.open("./ROMs/"ROM6, ios::binary | ios::in);
- for(long i=0x40000; i<0x60000; i+=64)
- {
- for(int j=0; j<64; j+=8)
- {
- f1.get(b1); f1.get(b2); f2.get(b3);
- b3 ^= 0xFF; // Invert top data
- chr_rom[i+j] = ((b3 & 0x80) >> 5) | ((b1 & 0x80) >> 6) | ((b1 & 0x08) >> 3);
- chr_rom[i+j+1] = ((b3 & 0x40) >> 4) | ((b1 & 0x40) >> 5) | ((b1 & 0x04) >> 2);
- chr_rom[i+j+2] = ((b3 & 0x20) >> 3) | ((b1 & 0x20) >> 4) | ((b1 & 0x02) >> 1);
- chr_rom[i+j+3] = ((b3 & 0x10) >> 2) | ((b1 & 0x10) >> 3) | (b1 & 0x01);
- chr_rom[i+j+4] = ((b3 & 0x08) >> 1) | ((b2 & 0x80) >> 6) | ((b2 & 0x08) >> 3);
- chr_rom[i+j+5] = (b3 & 0x04) | ((b2 & 0x40) >> 5) | ((b2 & 0x04) >> 2);
- chr_rom[i+j+6] = ((b3 & 0x02) << 1) | ((b2 & 0x20) >> 4) | ((b2 & 0x02) >> 1);
- chr_rom[i+j+7] = ((b3 & 0x01) << 2) | ((b2 & 0x10) >> 3) | (b2 & 0x01);
- }
- }
- f1.close();
- f2.close();
- return true; // Made it!
+// uint8_t b1, b2, b3;
+ char b1, b2, b3;
+ fstream f1, f2;
+ //0x4000 $800 chars
+ f1.open("./ROMs/"ROM7, ios::binary | ios::in);
+ f2.open("./ROMs/"ROM8, ios::binary | ios::in);
+
+ if ((!f1) || (!f2))
+ return false; // Return if not found...
+
+ for(long i=0; i<0x40000; i+=64)
+ {
+ for(int j=0; j<64; j+=8)
+ {
+ f1.get(b1); f1.get(b2); f2.get(b3);
+ b3 ^= 0xFF; // Invert top data...
+ chr_rom[i+j] = ((b3 & 0x80) >> 5) | ((b1 & 0x80) >> 6) | ((b1 & 0x08) >> 3);
+ chr_rom[i+j+1] = ((b3 & 0x40) >> 4) | ((b1 & 0x40) >> 5) | ((b1 & 0x04) >> 2);
+ chr_rom[i+j+2] = ((b3 & 0x20) >> 3) | ((b1 & 0x20) >> 4) | ((b1 & 0x02) >> 1);
+ chr_rom[i+j+3] = ((b3 & 0x10) >> 2) | ((b1 & 0x10) >> 3) | (b1 & 0x01);
+ chr_rom[i+j+4] = ((b3 & 0x08) >> 1) | ((b2 & 0x80) >> 6) | ((b2 & 0x08) >> 3);
+ chr_rom[i+j+5] = (b3 & 0x04) | ((b2 & 0x40) >> 5) | ((b2 & 0x04) >> 2);
+ chr_rom[i+j+6] = ((b3 & 0x02) << 1) | ((b2 & 0x20) >> 4) | ((b2 & 0x02) >> 1);
+ chr_rom[i+j+7] = ((b3 & 0x01) << 2) | ((b2 & 0x10) >> 3) | (b2 & 0x01);
+ }
+ }
+
+ f1.close();
+ f2.close();
+
+ f1.open("./ROMs/"ROM5, ios::binary | ios::in);
+ f2.open("./ROMs/"ROM6, ios::binary | ios::in);
+
+ for(long i=0x40000; i<0x60000; i+=64)
+ {
+ for(int j=0; j<64; j+=8)
+ {
+ f1.get(b1); f1.get(b2); f2.get(b3);
+ b3 ^= 0xFF; // Invert top data
+ chr_rom[i+j] = ((b3 & 0x80) >> 5) | ((b1 & 0x80) >> 6) | ((b1 & 0x08) >> 3);
+ chr_rom[i+j+1] = ((b3 & 0x40) >> 4) | ((b1 & 0x40) >> 5) | ((b1 & 0x04) >> 2);
+ chr_rom[i+j+2] = ((b3 & 0x20) >> 3) | ((b1 & 0x20) >> 4) | ((b1 & 0x02) >> 1);
+ chr_rom[i+j+3] = ((b3 & 0x10) >> 2) | ((b1 & 0x10) >> 3) | (b1 & 0x01);
+ chr_rom[i+j+4] = ((b3 & 0x08) >> 1) | ((b2 & 0x80) >> 6) | ((b2 & 0x08) >> 3);
+ chr_rom[i+j+5] = (b3 & 0x04) | ((b2 & 0x40) >> 5) | ((b2 & 0x04) >> 2);
+ chr_rom[i+j+6] = ((b3 & 0x02) << 1) | ((b2 & 0x20) >> 4) | ((b2 & 0x02) >> 1);
+ chr_rom[i+j+7] = ((b3 & 0x01) << 2) | ((b2 & 0x10) >> 3) | (b2 & 0x01);
+ }
+ }
+
+ f1.close();
+ f2.close();
+
+ return true; // Made it!
}
+
//
// Get length of sample from WAV format
//
-uint32 GetWAVLength(fstream &file)
+uint32_t GetWAVLength(fstream & file)
{
char ch;
- uint32 len;
+ uint32_t len;
file.ignore(16); // Skip header BS
for(int i=0; i<2; i++)
{
- file.get(ch); len = (int)(uint8)ch;
- file.get(ch); len |= (int)(uint8)ch << 8;
- file.get(ch); len |= (int)(uint8)ch << 16;
- file.get(ch); len |= (int)(uint8)ch << 24;
+ file.get(ch); len = (int)(uint8_t)ch;
+ file.get(ch); len |= (int)(uint8_t)ch << 8;
+ file.get(ch); len |= (int)(uint8_t)ch << 16;
+ file.get(ch); len |= (int)(uint8_t)ch << 24;
file.ignore(len + 4); // Skip intermediate data
}
- file.get(ch); len = (int)(uint8)ch; // & finally get length of data
- file.get(ch); len |= (int)(uint8)ch << 8;
- file.get(ch); len |= (int)(uint8)ch << 16;
- file.get(ch); len |= (int)(uint8)ch << 24;
+ file.get(ch); len = (int)(uint8_t)ch; // & finally get length of data
+ file.get(ch); len |= (int)(uint8_t)ch << 8;
+ file.get(ch); len |= (int)(uint8_t)ch << 16;
+ file.get(ch); len |= (int)(uint8_t)ch << 24;
return len;
}
+
//
// Load PSG samples from disk
//
{
char file[40];
char ch;
- uint32 len;
+ uint32_t len;
for(int i=0; i<16; i++)
{
if (fp)
{
len = GetWAVLength(fp); // Get WAV data length...
- psg_adrs[i] = new uint8[len]; // Attempt to allocate space...
+ psg_adrs[i] = new uint8_t[len]; // Attempt to allocate space...
if (psg_adrs[i] != NULL)
{
}
}
+
//
// Load FM samples from disk
//
{
char file[200];
char ch;
- uint32 len;
+ uint32_t len;
for(int i=0; i<14; i++)
{
if (fp)
{
len = GetWAVLength(fp); // Get WAV length...
- fm_adrs[i] = new uint8[len]; // Attempt to allocate space...
+ fm_adrs[i] = new uint8_t[len]; // Attempt to allocate space...
if (fm_adrs[i] != NULL)
{
}
}
+
//
// Main loop
//
extern bool charbase; // From 'SCREEN.CPP'
charbase = false;
- char lbuff[80];
- fstream ff; // Declare fstream without file hooks...
- bool brk = false, brk2 = false; // Breakpoint set flag
- uint16 brkpnt, brkpnt2; // Where the breakpoint is...
- bool running; // CPU running state flag...
- bool self_test = false; // Self-test switch
- bool scr_type = false; // false=chars, true=pixels
- uint16 debounce = 0; // Key de-bounce counter
- uint16 fire_debounce = 0; // Fire button debounce counter
+ char lbuff[80];
+ fstream ff; // Declare fstream without file hooks...
+ bool brk = false, brk2 = false; // Breakpoint set flag
+ uint16_t brkpnt, brkpnt2; // Where the breakpoint is...
+ bool running; // CPU running state flag...
+ bool self_test = false; // Self-test switch
+ bool scr_type = false; // false=chars, true=pixels
+ uint16_t debounce = 0; // Key de-bounce counter
+ uint16_t fire_debounce = 0; // Fire button debounce counter
// bool refresh2 = true; // Default to 60 Hz...
- uint8 x; // General placeholder...
- bool active = true; // Program running flag
+ uint8_t x; // General placeholder...
+ bool active = true; // Program running flag
- SDL_Event event; // SDL "event"
- extern uint8 palette[768]; // Screen physical palette
- uint32 ticks, oldTicks;
+ SDL_Event event; // SDL "event"
+ extern uint8_t palette[768]; // Screen physical palette
+ uint32_t ticks, oldTicks;
cout << endl << "THUNDER v"THUNDER_VERSION" ";
cout << "by James Hammons" << endl;
- cout << "Serial #20090723 / Prerelease" << endl;
- cout << "(C) 2003, 2009 Underground Software" << endl << endl;
+ cout << "Serial #20149404 / Prerelease" << endl;
+ cout << "© 2003, 2014 Underground Software" << endl << endl;
cout << "This emulator is free software. If you paid for it you were RIPPED OFF"
<< endl << endl;
keys = SDL_GetKeyState(NULL); // Get the SDL keyboard matrix
- gram = gram1; grom = grom1; // Needed only for debugger
+ gram = gram1; grom = grom1; // Needed only for debugger
- for(long i=0; i<0x10000; i++)
- {
- gram[i] = 0; grom[i] = 0; // Zero out memory
- gram2[i] = 0; grom2[i] = 0;
- }
- game_over_switch = 0; // Init game over delay
+ for(long i=0; i<0x10000; i++)
+ {
+ gram[i] = 0; grom[i] = 0; // Zero out memory
+ gram2[i] = 0; grom2[i] = 0;
+ }
+
+ game_over_switch = 0; // Init game over delay
// cpu1.a = 0; cpu1.b = 0; cpu1.cc = 0; cpu1.dp = 0; cpu1.x = 0; cpu1.y = 0; cpu1.s = 0; ur = 0; cpu1.pc = 0;
- cout << "Loading ROMs..." << endl;
+ cout << "Loading ROMs..." << endl;
// LoadCMOS(); // Load CMOS at $CC00-$CFFF
- if (!ReadColorPROMs()) // Load virtual PROMs
- { cout << "Could not open PROM files!" << endl; return -1; }
+ if (!ReadColorPROMs()) // Load virtual PROMs
+ { cout << "Could not open PROM files!" << endl; return -1; }
- if (!LoadImg(ROM1, grom1, 0x8000, 0x8000)) // Load $8000-$FFFF 1st ROM
- { cout << "Could not open file '" << ROM1 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM1, grom1, 0x8000, 0x8000)) // Load $8000-$FFFF 1st ROM
+ { cout << "Could not open file '" << ROM1 << "'!" << endl; return -1; }
- if (!LoadImg(ROM2, grom2, 0x8000, 0x8000)) // Load $8000-$FFFF 2nd ROM
- { cout << "Could not open file '" << ROM2 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM2, grom2, 0x8000, 0x8000)) // Load $8000-$FFFF 2nd ROM
+ { cout << "Could not open file '" << ROM2 << "'!" << endl; return -1; }
- if (!LoadImg(ROM3, grom3, 0, 0x8000)) // Load 3rd ROM into its own space
- { cout << "Could not open file '" << ROM3 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM3, grom3, 0, 0x8000)) // Load 3rd ROM into its own space
+ { cout << "Could not open file '" << ROM3 << "'!" << endl; return -1; }
- if (!LoadImg(ROM4, grom4, 0, 0x8000)) // Load 4rd ROM into its own space
- { cout << "Could not open file '" << ROM4 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM4, grom4, 0, 0x8000)) // Load 4rd ROM into its own space
+ { cout << "Could not open file '" << ROM4 << "'!" << endl; return -1; }
- if (!LoadImg(ROM17, data_rom, 0, 0x10000)) // Load 17th ROM
- { cout << "Could not open file '" << ROM17 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM17, data_rom, 0, 0x10000)) // Load 17th ROM
+ { cout << "Could not open file '" << ROM17 << "'!" << endl; return -1; }
- if (!LoadImg(ROM18, data_rom, 0x10000, 0x10000)) // Load 18th ROM
- { cout << "Could not open file '" << ROM18 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM18, data_rom, 0x10000, 0x10000)) // Load 18th ROM
+ { cout << "Could not open file '" << ROM18 << "'!" << endl; return -1; }
- if (!LoadImg(ROM19, data_rom, 0x20000, 0x10000)) // Load 19th ROM
- { cout << "Could not open file '" << ROM19 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM19, data_rom, 0x20000, 0x10000)) // Load 19th ROM
+ { cout << "Could not open file '" << ROM19 << "'!" << endl; return -1; }
- if (!LoadImg(ROM20, data_rom, 0x30000, 0x10000)) // Load 20th ROM
- { cout << "Could not open file '" << ROM20 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM20, data_rom, 0x30000, 0x10000)) // Load 20th ROM
+ { cout << "Could not open file '" << ROM20 << "'!" << endl; return -1; }
- if (!LoadImg(ROM9, spr_rom, 0, 0x10000)) // Load 9th ROM
- { cout << "Could not open file '" << ROM9 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM9, spr_rom, 0, 0x10000)) // Load 9th ROM
+ { cout << "Could not open file '" << ROM9 << "'!" << endl; return -1; }
- if (!LoadImg(ROM10, spr_rom, 0x10000, 0x10000)) // Load 10th ROM
- { cout << "Could not open file '" << ROM10 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM10, spr_rom, 0x10000, 0x10000)) // Load 10th ROM
+ { cout << "Could not open file '" << ROM10 << "'!" << endl; return -1; }
- if (!LoadImg(ROM11, spr_rom, 0x20000, 0x10000)) // Load 11th ROM
- { cout << "Could not open file '" << ROM11 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM11, spr_rom, 0x20000, 0x10000)) // Load 11th ROM
+ { cout << "Could not open file '" << ROM11 << "'!" << endl; return -1; }
- if (!LoadImg(ROM12, spr_rom, 0x30000, 0x10000)) // Load 12th ROM
- { cout << "Could not open file '" << ROM12 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM12, spr_rom, 0x30000, 0x10000)) // Load 12th ROM
+ { cout << "Could not open file '" << ROM12 << "'!" << endl; return -1; }
- if (!LoadImg(ROM13, spr_rom, 0x40000, 0x10000)) // Load 13th ROM
- { cout << "Could not open file '" << ROM13 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM13, spr_rom, 0x40000, 0x10000)) // Load 13th ROM
+ { cout << "Could not open file '" << ROM13 << "'!" << endl; return -1; }
- if (!LoadImg(ROM14, spr_rom, 0x50000, 0x10000)) // Load 14th ROM
- { cout << "Could not open file '" << ROM14 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM14, spr_rom, 0x50000, 0x10000)) // Load 14th ROM
+ { cout << "Could not open file '" << ROM14 << "'!" << endl; return -1; }
- if (!LoadImg(ROM15, spr_rom, 0x60000, 0x10000)) // Load 15th ROM
- { cout << "Could not open file '" << ROM15 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM15, spr_rom, 0x60000, 0x10000)) // Load 15th ROM
+ { cout << "Could not open file '" << ROM15 << "'!" << endl; return -1; }
- if (!LoadImg(ROM16, spr_rom, 0x70000, 0x10000)) // Load 16th ROM
- { cout << "Could not open file '" << ROM16 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM16, spr_rom, 0x70000, 0x10000)) // Load 16th ROM
+ { cout << "Could not open file '" << ROM16 << "'!" << endl; return -1; }
- if (!LoadImg(ROM21, voice_rom, 0, 0x10000)) // Load 21st ROM
- { cout << "Could not open file '" << ROM21 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM21, voice_rom, 0, 0x10000)) // Load 21st ROM
+ { cout << "Could not open file '" << ROM21 << "'!" << endl; return -1; }
- if (!LoadImg(ROM22, voice_rom, 0x10000, 0x10000)) // Load 22nd ROM
- { cout << "Could not open file '" << ROM22 << "'!" << endl; return -1; }
+ if (!LoadImg(ROM22, voice_rom, 0x10000, 0x10000)) // Load 22nd ROM
+ { cout << "Could not open file '" << ROM22 << "'!" << endl; return -1; }
- if (!UnpackFonts()) // Load 5, 6, 7, 8th ROMs
- {
- cout << "Could not open font files!" << endl;
- return -1;
- }
+ if (!UnpackFonts()) // Load 5, 6, 7, 8th ROMs
+ {
+ cout << "Could not open font files!" << endl;
+ return -1;
+ }
// Load samples if they're there...
LoadPSGs();
LoadFMs();
// Quick 'n' Dirty voice dump (sound 0x0E)
-/* uint32 adc = (voice_rom[26]<<8) | voice_rom[27];
+/* uint32_t adc = (voice_rom[26]<<8) | voice_rom[27];
bool doneWitIt = false;
int crh = 0;
while (!doneWitIt)
dpc = htod(lbuff);
}
printf("%04X: ", dpc);
- uint16 pc_save = cpu1.pc, pcB_save = cpu2.pc;
+ uint16_t pc_save = cpu1.pc, pcB_save = cpu2.pc;
cpu1.pc = dpc; cpu2.pc = dpc;
for(int i=0; i<16; i++)
printf("%02X ", (looking_at_rom ? Fetch() : FetchB()));
cpu1.pc = dpc; cpu2.pc = dpc;
for(int i=0; i<16; i++)
{
- uint8 a = (looking_at_rom ? Fetch() : FetchB());
+ uint8_t a = (looking_at_rom ? Fetch() : FetchB());
if (a<10) cout << (char)(a+48);
if ((a>9) && (a<37)) cout << (char)(a+55);
if (a>36) cout << ".";
dpc = htod(lbuff);
}
printf("%04X: ", dpc);
- for(int i=0; i<16; i++) printf("%02X ", (uint8)gram[dpc++]);
+ for(int i=0; i<16; i++) printf("%02X ", (uint8_t)gram[dpc++]);
cout << endl;
}
else if (lbuff[0] == 'l')
else if ((lbuff[0] == 'r') || (lbuff[0] == 'c')) // Run/continue...
{
WriteLog("Executing 'run' command...\n");
- uint32 my_clock = 0;
+ uint32_t my_clock = 0;
running = true; // Set running status...
trace1 = false;
SetRefreshRate(refresh2); // Tell GUI our refresh rate
- //for(uint16 i=0; i<0x8000; i++) gram2[i] = grom3[i]; //Temp
+ //for(uint16_t i=0; i<0x8000; i++) gram2[i] = grom3[i]; //Temp
if (lbuff[0] == 'r') // If run, then reset CPUs
{
}
WriteLog("About to set up screen...\n");
-// if (!SetVESA2()) running = false; // Set up screen
- // Set up screen (windowed)
-// screen = SDL_SetVideoMode(640, 480, 8, SDL_SWSURFACE); //video_bpp, videoflags);
screen = SDL_SetVideoMode(VIRTUAL_SCREEN_WIDTH * 2, VIRTUAL_SCREEN_HEIGHT * 2, 8, SDL_SWSURFACE | SDL_DOUBLEBUF);
if (screen == NULL)
{
}
SDL_Color colors[256];
+
for(int i=0; i<256; i++)
{
colors[i].r = palette[i*3+0];
colors[i].g = palette[i*3+1];
colors[i].b = palette[i*3+2];
}
+
SDL_SetPalette(screen, SDL_LOGPAL | SDL_PHYSPAL, colors, 0, 256);
#if 0
// This confirms that we're getting video to the screen...
SDL_LockSurface(screen);
- uint8 pixel = 0;
- uint8 * pixels = (uint8 *)(screen->pixels);
+ uint8_t pixel = 0;
+ uint8_t * pixels = (uint8_t *)(screen->pixels);
- for(uint32 y=0; y<480; y++)
- for(uint32 x=0; x<640; x++)
+ for(uint32_t y=0; y<480; y++)
+ for(uint32_t x=0; x<640; x++)
pixels[(y * 640) + x] = pixel++;
SDL_UnlockSurface(screen);
cout << "Couldn't open audio: " << SDL_GetError() << endl;
return -1;
}
+
SDL_PauseAudio(0); // Get that audio going!
WriteLog("About to enter main loop...\n");
}
if (keys[SDLK_RETURN]) // Return
{
- uint8 retval = UserSelectedSomething();
+ uint8_t retval = UserSelectedSomething();
if (retval == EXIT)
running = false;
if (retval == REFRESH)
// 640 * 40
// 800 * 32
// Interesting, putting IRQs at 30 Hz makes it run at the correct speed. Still hangs in the demo, though.
- for(uint32 i=0; i<640; i++)
-// for(uint32 i=0; i<1280; i++)
+ for(uint32_t i=0; i<640; i++)
+// for(uint32_t i=0; i<1280; i++)
{
// Gay, but what are ya gonna do?
// There's better ways, such as keeping track of when slave writes to master, etc...
}
else if (lbuff[0] == 'i') // Inspect registers
{
- printf("CPU1: A=%02X B=%02X CC=%02X DP=%02X X=%04X Y=%04X S=%04X U=%04X PC=%04X",
- cpu1.a, cpu1.b, cpu1.cc, cpu1.dp, cpu1.x, cpu1.y, cpu1.s, cpu1.u, cpu1.pc);
- cout << " iclk=" << dec << cpu1.clock << endl;
- printf("CPU2: A=%02X B=%02X CC=%02X DP=%02X X=%04X Y=%04X S=%04X U=%04X PC=%04X",
- cpu2.a, cpu2.b, cpu2.cc, cpu2.dp, cpu2.x, cpu2.y, cpu2.s, cpu2.u, cpu2.pc);
- cout << " iclk=" << dec << cpu2.clock << endl;
- if (brk)
- cout << "Breakpoint #1 set at " << hex << brkpnt << dec << endl;
- if (brk2)
- cout << "Breakpoint #2 set at " << hex << brkpnt2 << dec << endl;
- }
+ printf("CPU1: A=%02X B=%02X CC=%02X DP=%02X X=%04X Y=%04X S=%04X U=%04X PC=%04X",
+ cpu1.a, cpu1.b, cpu1.cc, cpu1.dp, cpu1.x, cpu1.y, cpu1.s, cpu1.u, cpu1.pc);
+ cout << " iclk=" << dec << cpu1.clock << endl;
+ printf("CPU2: A=%02X B=%02X CC=%02X DP=%02X X=%04X Y=%04X S=%04X U=%04X PC=%04X",
+ cpu2.a, cpu2.b, cpu2.cc, cpu2.dp, cpu2.x, cpu2.y, cpu2.s, cpu2.u, cpu2.pc);
+ cout << " iclk=" << dec << cpu2.clock << endl;
+
+ if (brk)
+ cout << "Breakpoint #1 set at " << hex << brkpnt << dec << endl;
+
+ if (brk2)
+ cout << "Breakpoint #2 set at " << hex << brkpnt2 << dec << endl;
+ }
else if (strncmp(lbuff, "swap", 4) == 0) // Swap ROMs
- {
- looking_at_rom = !looking_at_rom;
- cout << "Swapped: Looking at ";
- (looking_at_rom ? cout << "ROM #1" : cout << "ROM #2");
- cout << endl;
- }
+ {
+ looking_at_rom = !looking_at_rom;
+ cout << "Swapped: Looking at ";
+ (looking_at_rom ? cout << "ROM #1" : cout << "ROM #2");
+ cout << endl;
+ }
else if (strncmp(lbuff, "seek", 4) == 0) // Seek non-zero bytes in RAM
- {
- if (lbuff[4] != 0)
- {
- for(int i=0; i<4; i++)
- lbuff[i] = 32;
- dpc = htod(lbuff);
- }
- do
- {
- x = gram1[dpc++];
- }
- while ((x == 0) && (dpc != 0xFFFF)); // Keep going until something found
- dpc--;
-
- printf("%04X: ", dpc); // Show data found...
- for(int i=0; i<16; i++)
- printf("%02X ", gram1[(uint16)(dpc+i)]);
- cout << " ";
- for(int i=0; i<16; i++)
- {
- uint8 a = gram1[dpc++];
- if (a<10)
- cout << (char)(a+48);
- if ((a>9) && (a<37))
- cout << (char)(a+55);
- if (a>36)
- cout << ".";
- }
- cout << endl;
- }
+ {
+
+ if (lbuff[4] != 0)
+ {
+ for(int i=0; i<4; i++)
+ lbuff[i] = 32;
+ dpc = htod(lbuff);
+ }
+
+ do
+ {
+ x = gram1[dpc++];
+ }
+ while ((x == 0) && (dpc != 0xFFFF)); // Keep going until something found
+ dpc--;
+
+ printf("%04X: ", dpc); // Show data found...
+
+ for(int i=0; i<16; i++)
+ printf("%02X ", gram1[(uint16_t)(dpc+i)]);
+
+ cout << " ";
+
+ for(int i=0; i<16; i++)
+ {
+ uint8_t a = gram1[dpc++];
+
+ if (a<10)
+ cout << (char)(a+48);
+ if ((a>9) && (a<37))
+ cout << (char)(a+55);
+ if (a>36)
+ cout << ".";
+ }
+
+ cout << endl;
+ }
else if (lbuff[0] == 'v') // View screen
{
-// SetVESA2(); // Set up screen
BlitChar(screen, chr_rom, gram1);
getch();
-// RestoreOldMode();
}
if (lbuff[0] == 'q')
Most of the decoding is done by custom chips (CUS47 and CUS41), so the memory
map is inferred by program behaviour. The customs also handle internally irq
and watchdog.
+
The main CPU memory map is the same in all games because CUS47 is used by all
games. The sub CPU and sound CPU, on the other hand, change because CUS41 is
replaced by other chips.
-All RAM is shared between main and sub CPU, except for sound RAM which is shared
-between main and sound CPU; the portion of object RAM that is overlapped by sound
-RAM is used exclusively by the sub CPU.
+
+All RAM is shared between main and sub CPU, except for sound RAM which is
+shared between main and sound CPU; the portion of object RAM that is overlapped
+by sound RAM is used exclusively by the sub CPU.
MAIN CPU:
stop receiving interrupts.
#endif
+
+++ /dev/null
-//
-// TYPES.H
-//
-// by James L. Hammons
-// (C) 2009 Underground Software
-//
-// Now that C/C++ has stardard sizes, this is much more precise. We still do
-// this because we don't like typing _t on the back of our types. :-)
-//
-
-#ifndef __TYPES_H__
-#define __TYPES_H__
-
-#include <stdint.h>
-
-typedef uint8_t uint8;
-typedef int8_t int8;
-typedef uint16_t uint16;
-typedef int16_t int16;
-typedef uint32_t uint32;
-typedef int32_t int32;
-typedef uint64_t uint64;
-typedef int64_t int64;
-
-#endif // __TYPES_H__
//
// Virtual 6808 Emulator v2.0
//
-// by James L. Hammons
+// by James Hammons
// (C) 2006 Underground Software
//
-// JLH = James L. Hammons <jlhamm@acm.org>
+// JLH = James Hammons <jlhamm@acm.org>
//
// WHO WHEN WHAT
-// --- ---------- ------------------------------------------------------------
+// --- ---------- -----------------------------------------------------------
// JLH 06/15/2006 Added changelog ;-)
// JLH 06/15/2006 Scrubbed all BYTE, WORD & DWORD references from the code
// JLH 11/13/2006 Converted core to V65C02 macro style :-)
// NOTE: V6808_STATE_WAI is not handled in the main loop correctly. !!! FIX !!!
// Some random thoughts: Could there be a performance gain by breaking
-// out the flags in regs.cc into separate uint8 variables (or bools)?
+// out the flags in regs.cc into separate uint8_t variables (or bools)?
// You'd have to convert on entering and exiting the emulation loop, but I
// think the perfomance hit would be negligible compared to the gain in not
// having to mask and shift flags all the time. Investigate after the
#define SET_N(r) (flagN = ((r) & 0x80) >> 7)
#define SET_V(a,b,r) (flagV = (((b) ^ (a) ^ (r) ^ ((r) >> 1)) & 0x80) >> 7)
-#define SET_C_CMP(a,b) (flagC = ((uint8)(b) < (uint8)(a) ? 1 : 0))
+#define SET_C_CMP(a,b) (flagC = ((uint8_t)(b) < (uint8_t)(a) ? 1 : 0))
#define SET_ZN(r) SET_N(r); SET_Z(r)
#define SET_ZNC_ADD(a,b,r) SET_N(r); SET_Z(r); SET_C_ADD(a,b)
#define SET_ZNVC_CMP(a,b,r) SET_N(r); SET_Z(r); SET_C_CMP(a,b); SET_V(a,b,r)
#define SET_N16(r) (flagN = ((r) & 0x8000) >> 15)
#define SET_V16(a,b,r) (flagV = (((b) ^ (a) ^ (r) ^ ((r) >> 1)) & 0x8000) >> 15)
-#define SET_C_CMP16(a,b) (flagC = ((uint16)(b) < (uint16)(a) ? 1 : 0))
+#define SET_C_CMP16(a,b) (flagC = ((uint16_t)(b) < (uint16_t)(a) ? 1 : 0))
#define SET_ZNVC_CMP16(a,b,r) SET_N16(r); SET_Z(r); SET_C_CMP16(a,b); SET_V16(a,b,r)
//Small problem with the EA_ macros: ABS macros don't increment the PC!!! !!! FIX !!! [DONE, kinda]
#define READ_ZP_X16 RdMemW(EA_ZP_X)
#define READ_ABS16 RdMemW(EA_ABS); regs.pc += 2
-#define READ_IMM_WB(v) uint16 addr = EA_IMM; v = regs.RdMem(addr)
-#define READ_ZP_WB(v) uint16 addr = EA_ZP; v = regs.RdMem(addr)
-#define READ_ZP_X_WB(v) uint16 addr = EA_ZP_X; v = regs.RdMem(addr)
-#define READ_ABS_WB(v) uint16 addr = EA_ABS; v = regs.RdMem(addr); regs.pc += 2
+#define READ_IMM_WB(v) uint16_t addr = EA_IMM; v = regs.RdMem(addr)
+#define READ_ZP_WB(v) uint16_t addr = EA_ZP; v = regs.RdMem(addr)
+#define READ_ZP_X_WB(v) uint16_t addr = EA_ZP_X; v = regs.RdMem(addr)
+#define READ_ABS_WB(v) uint16_t addr = EA_ABS; v = regs.RdMem(addr); regs.pc += 2
#define WRITE_BACK(d) regs.WrMem(addr, (d))
// Private global variables
static V6808REGS regs;
-static uint8 flagH, flagI, flagN, flagZ, flagV, flagC;
+static uint8_t flagH, flagI, flagN, flagZ, flagV, flagC;
-static uint8 CPUCycles[256] = {
+static uint8_t CPUCycles[256] = {
1, 2, 1, 1, 1, 1, 2, 2, 4, 4, 2, 2, 2, 2, 2, 2,
2, 2, 1, 1, 1, 1, 2, 2, 1, 2, 1, 2, 1, 1, 1, 1,
4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
// Private function prototypes
-static uint16 RdMemW(uint16);
+static uint16_t RdMemW(uint16_t);
//
// Read a word out of 6808 memory (little endian format)
//
-static inline uint16 RdMemW(uint16 address)
+static inline uint16_t RdMemW(uint16_t address)
{
- return (uint16)(regs.RdMem(address) << 8) | regs.RdMem(address + 1);
+ return (uint16_t)(regs.RdMem(address) << 8) | regs.RdMem(address + 1);
}
//
// ADD opcodes
#define OP_ADD_HANDLER(m, acc) \
- uint16 sum = (uint16)(acc) + (m); \
+ uint16_t sum = (uint16_t)(acc) + (m); \
flagC = sum >> 8; \
flagH = (sum >> 4) & 0x01; \
SET_V(m, acc, sum); \
static void Op8B(void) // ADDA #
{
- uint16 m = READ_IMM;
+ uint16_t m = READ_IMM;
OP_ADD_HANDLER(m, regs.a);
}
static void Op9B(void) // ADDA ZP
{
- uint16 m = READ_ZP;
+ uint16_t m = READ_ZP;
OP_ADD_HANDLER(m, regs.a);
}
static void OpAB(void) // ADDA ZP, X
{
- uint16 m = READ_ZP_X;
+ uint16_t m = READ_ZP_X;
OP_ADD_HANDLER(m, regs.a);
}
static void OpBB(void) // ADDA ABS
{
- uint16 m = READ_ABS;
+ uint16_t m = READ_ABS;
OP_ADD_HANDLER(m, regs.a);
}
static void OpCB(void) // ADDB #
{
- uint16 m = READ_IMM;
+ uint16_t m = READ_IMM;
OP_ADD_HANDLER(m, regs.b);
}
static void OpDB(void) // ADDB ZP
{
- uint16 m = READ_ZP;
+ uint16_t m = READ_ZP;
OP_ADD_HANDLER(m, regs.b);
}
static void OpEB(void) // ADDB ZP, X
{
- uint16 m = READ_ZP_X;
+ uint16_t m = READ_ZP_X;
OP_ADD_HANDLER(m, regs.b);
}
static void OpFB(void) // ADDB ABS
{
- uint16 m = READ_ABS;
+ uint16_t m = READ_ABS;
OP_ADD_HANDLER(m, regs.b);
}
// ADC opcodes
#define OP_ADC_HANDLER(m, acc) \
- uint16 sum = (uint16)acc + (m) + (uint16)flagC; \
+ uint16_t sum = (uint16_t)acc + (m) + (uint16_t)flagC; \
flagC = sum >> 8; \
flagH = (sum >> 4) & 0x01; \
SET_V(m, acc, sum); \
static void Op89(void) // ADCA #
{
- uint16 m = READ_IMM;
+ uint16_t m = READ_IMM;
OP_ADC_HANDLER(m, regs.a);
}
static void Op99(void) // ADCA ZP
{
- uint16 m = READ_ZP;
+ uint16_t m = READ_ZP;
OP_ADC_HANDLER(m, regs.a);
}
static void OpA9(void) // ADCA ZP, X
{
- uint16 m = READ_ZP_X;
+ uint16_t m = READ_ZP_X;
OP_ADC_HANDLER(m, regs.a);
}
static void OpB9(void) // ADCA ABS
{
- uint16 m = READ_ABS;
+ uint16_t m = READ_ABS;
OP_ADC_HANDLER(m, regs.a);
}
static void OpC9(void) // ADCB #
{
- uint16 m = READ_IMM;
+ uint16_t m = READ_IMM;
OP_ADC_HANDLER(m, regs.b);
}
static void OpD9(void) // ADCB ZP
{
- uint16 m = READ_ZP;
+ uint16_t m = READ_ZP;
OP_ADC_HANDLER(m, regs.b);
}
static void OpE9(void) // ADCB ZP, X
{
- uint16 m = READ_ZP_X;
+ uint16_t m = READ_ZP_X;
OP_ADC_HANDLER(m, regs.b);
}
static void OpF9(void) // ADCB ABS
{
- uint16 m = READ_ABS;
+ uint16_t m = READ_ABS;
OP_ADC_HANDLER(m, regs.b);
}
static void Op84(void) // ANDA #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_AND_HANDLER(m, regs.a);
}
static void Op94(void) // ANDA ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_AND_HANDLER(m, regs.a);
}
static void OpA4(void) // ANDA ZP, X
{
- uint16 m = READ_ZP_X;
+ uint16_t m = READ_ZP_X;
OP_AND_HANDLER(m, regs.a);
}
static void OpB4(void) // ANDA ABS
{
- uint16 m = READ_ABS;
+ uint16_t m = READ_ABS;
OP_AND_HANDLER(m, regs.a);
}
static void OpC4(void) // ANDB #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_AND_HANDLER(m, regs.b);
}
static void OpD4(void) // ANDB ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_AND_HANDLER(m, regs.b);
}
static void OpE4(void) // ANDB ZP, X
{
- uint16 m = READ_ZP_X;
+ uint16_t m = READ_ZP_X;
OP_AND_HANDLER(m, regs.b);
}
static void OpF4(void) // ANDB ABS
{
- uint16 m = READ_ABS;
+ uint16_t m = READ_ABS;
OP_AND_HANDLER(m, regs.b);
}
// BIT opcodes
#define OP_BIT_HANDLER(m, acc) \
- int8 result = acc & (m); \
+ int8_t result = acc & (m); \
SET_ZN(result)
static void Op85(void) // BITA #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_BIT_HANDLER(m, regs.a);
}
static void Op95(void) // BITA ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_BIT_HANDLER(m, regs.a);
}
static void OpA5(void) // BITA ZP, X
{
- uint8 m = READ_ZP_X;
+ uint8_t m = READ_ZP_X;
OP_BIT_HANDLER(m, regs.a);
}
static void OpB5(void) // BITA ABS
{
- uint8 m = READ_ABS;
+ uint8_t m = READ_ABS;
OP_BIT_HANDLER(m, regs.a);
}
static void OpC5(void) // BITB #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_BIT_HANDLER(m, regs.b);
}
static void OpD5(void) // BITB ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_BIT_HANDLER(m, regs.b);
}
static void OpE5(void) // BITB ZP, X
{
- uint8 m = READ_ZP_X;
+ uint8_t m = READ_ZP_X;
OP_BIT_HANDLER(m, regs.b);
}
static void OpF5(void) // BITB ABS
{
- uint8 m = READ_ABS;
+ uint8_t m = READ_ABS;
OP_BIT_HANDLER(m, regs.b);
}
*/
#define OP_CMP_HANDLER(m, acc) \
- uint16 result = acc - (m); \
+ uint16_t result = acc - (m); \
SET_ZNVC_CMP(m, acc, result)
static void Op81(void) // CMPA #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_CMP_HANDLER(m, regs.a);
}
static void Op91(void) // CMPA ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_CMP_HANDLER(m, regs.a);
}
static void OpA1(void) // CMPA ZP, X
{
- uint8 m = READ_ZP_X;
+ uint8_t m = READ_ZP_X;
OP_CMP_HANDLER(m, regs.a);
}
static void OpB1(void) // CMPA ABS
{
- uint8 m = READ_ABS;
+ uint8_t m = READ_ABS;
OP_CMP_HANDLER(m, regs.a);
}
static void OpC1(void) // CMPB #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_CMP_HANDLER(m, regs.b);
}
static void OpD1(void) // CMPB ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_CMP_HANDLER(m, regs.b);
}
static void OpE1(void) // CMPB ZP, X
{
- uint8 m = READ_ZP_X;
+ uint8_t m = READ_ZP_X;
OP_CMP_HANDLER(m, regs.b);
}
static void OpF1(void) // CMPB ABS
{
- uint8 m = READ_ABS;
+ uint8_t m = READ_ABS;
OP_CMP_HANDLER(m, regs.b);
}
static void Op63(void) // COM ZP, X
{
- uint8 m;
+ uint8_t m;
READ_ZP_X_WB(m);
OP_COM_HANDLER(m);
WRITE_BACK(m);
static void Op73(void) // COM ABS
{
- uint8 m;
+ uint8_t m;
READ_ABS_WB(m);
OP_COM_HANDLER(m);
WRITE_BACK(m);
static void Op60(void) // NEG ZP, X
{
- uint8 m;
+ uint8_t m;
READ_ZP_X_WB(m);
OP_NEG_HANDLER(m);
WRITE_BACK(m);
static void Op70(void) // NEG ABS
{
- uint8 m;
+ uint8_t m;
READ_ABS_WB(m);
OP_NEG_HANDLER(m);
WRITE_BACK(m);
static void Op19(void) // DAA
{
- uint16 result = (uint16)regs.a;
+ uint16_t result = (uint16_t)regs.a;
if ((regs.a & 0x0F) > 0x09 || flagH)
result += 0x06;
if ((regs.a & 0xF0) > 0x90 || flagC || ((regs.a & 0xF0) > 0x80 && (regs.a & 0x0F) > 0x09))
result += 0x60;
- regs.a = (uint8)result;
+ regs.a = (uint8_t)result;
SET_ZN(result);
CLR_V; // Not sure this is correct...
flagC |= (result & 0x100) >> 8; // Overwrite carry if it was 0, otherwise, ignore
static void Op6A(void) // DEC ZP, X
{
- uint8 m;
+ uint8_t m;
READ_ZP_X_WB(m);
OP_DEC_HANDLER(m);
WRITE_BACK(m);
static void Op7A(void) // DEC ABS
{
- uint8 m;
+ uint8_t m;
READ_ABS_WB(m);
OP_DEC_HANDLER(m);
WRITE_BACK(m);
static void Op88(void) // EORA #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_EOR_HANDLER(m, regs.a);
}
static void Op98(void) // EORA ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_EOR_HANDLER(m, regs.a);
}
static void OpA8(void) // EORA ZP, X
{
- uint8 m = READ_ZP_X;
+ uint8_t m = READ_ZP_X;
OP_EOR_HANDLER(m, regs.a);
}
static void OpB8(void) // EORA ABS
{
- uint8 m = READ_ABS;
+ uint8_t m = READ_ABS;
OP_EOR_HANDLER(m, regs.a);
}
static void OpC8(void) // EORB #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_EOR_HANDLER(m, regs.b);
}
static void OpD8(void) // EORB ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_EOR_HANDLER(m, regs.b);
}
static void OpE8(void) // EORB ZP, X
{
- uint8 m = READ_ZP_X;
+ uint8_t m = READ_ZP_X;
OP_EOR_HANDLER(m, regs.b);
}
static void OpF8(void) // EORB ABS
{
- uint8 m = READ_ABS;
+ uint8_t m = READ_ABS;
OP_EOR_HANDLER(m, regs.b);
}
static void Op6C(void) // INC ZP, X
{
- uint8 m;
+ uint8_t m;
READ_ZP_X_WB(m);
OP_INC_HANDLER(m);
WRITE_BACK(m);
static void Op7C(void) // INC ABS
{
- uint8 m;
+ uint8_t m;
READ_ABS_WB(m);
OP_INC_HANDLER(m);
WRITE_BACK(m);
static void Op86(void) // LDAA #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_LDA_HANDLER(m, regs.a);
}
static void Op96(void) // LDAA ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_LDA_HANDLER(m, regs.a);
}
static void OpA6(void) // LDAA ZP, X
{
- uint8 m = READ_ZP_X;
+ uint8_t m = READ_ZP_X;
OP_LDA_HANDLER(m, regs.a);
}
static void OpB6(void) // LDAA ABS
{
- uint8 m = READ_ABS;
+ uint8_t m = READ_ABS;
OP_LDA_HANDLER(m, regs.a);
}
static void OpC6(void) // LDAB #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_LDA_HANDLER(m, regs.b);
}
static void OpD6(void) // LDAB ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_LDA_HANDLER(m, regs.b);
}
static void OpE6(void) // LDAB ZP, X
{
- uint8 m = READ_ZP_X;
+ uint8_t m = READ_ZP_X;
OP_LDA_HANDLER(m, regs.b);
}
static void OpF6(void) // LDAB ABS
{
- uint8 m = READ_ABS;
+ uint8_t m = READ_ABS;
OP_LDA_HANDLER(m, regs.b);
}
static void Op8A(void) // ORAA #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_ORA_HANDLER(m, regs.a);
}
static void Op9A(void) // ORAA ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_ORA_HANDLER(m, regs.a);
}
static void OpAA(void) // ORAA ZP, X
{
- uint8 m = READ_ZP_X;
+ uint8_t m = READ_ZP_X;
OP_ORA_HANDLER(m, regs.a);
}
static void OpBA(void) // ORAA ABS
{
- uint8 m = READ_ABS;
+ uint8_t m = READ_ABS;
OP_ORA_HANDLER(m, regs.a);
}
static void OpCA(void) // ORAB #
{
- uint8 m = READ_IMM;
+ uint8_t m = READ_IMM;
OP_ORA_HANDLER(m, regs.b);
}
static void OpDA(void) // ORAB ZP
{
- uint8 m = READ_ZP;
+ uint8_t m = READ_ZP;
OP_ORA_HANDLER(m, regs.b);
}
static void OpEA(void) // ORAB ZP, X
{
- uint8 m = READ_ZP_X;
+ uint8_t m = READ_ZP_X;
OP_ORA_HANDLER(m, regs.b);
}
static void OpFA(void) // ORAB ABS
{
- uint8 m = READ_ABS;
+ uint8_t m = READ_ABS;
OP_ORA_HANDLER(m, regs.b);
}
// ROL opcodes
#define OP_ROL_HANDLER(m) \
- uint8 newCarry = (m & 0x80) >> 7; \
+ uint8_t newCarry = (m & 0x80) >> 7; \
m = (m << 1) | flagC; \
SET_ZN(m); \
flagC = newCarry; \
static void Op69(void) // ROL ZP, X
{
- uint8 m;
+ uint8_t m;
READ_ZP_X_WB(m);
OP_ROL_HANDLER(m);
WRITE_BACK(m);
static void Op79(void) // ROL ABS
{
- uint8 m;
+ uint8_t m;
READ_ABS_WB(m);
OP_ROL_HANDLER(m);
WRITE_BACK(m);
// ROR opcodes
#define OP_ROR_HANDLER(m) \
- uint8 newCarry = m & 0x01; \
+ uint8_t newCarry = m & 0x01; \
m = (m >> 1) | (flagC << 7); \
SET_ZN(m); \
flagC = newCarry; \
static void Op66(void) // ROR ZP, X
{
- uint8 m;
+ uint8_t m;
READ_ZP_X_WB(m);
OP_ROR_HANDLER(m);
WRITE_BACK(m);
static void Op76(void) // ROR ABS
{
- uint8 m;
+ uint8_t m;
READ_ABS_WB(m);
OP_ROR_HANDLER(m);
WRITE_BACK(m);
// ASL opcodes
#define OP_ASL_HANDLER(m) \
- uint8 newCarry = (m & 0x80) >> 7; \
+ uint8_t newCarry = (m & 0x80) >> 7; \
m <<= 1; \
SET_ZN(m); \
flagC = newCarry; \
static void Op68(void) // ASL ZP, X
{
- uint8 m;
+ uint8_t m;
READ_ZP_X_WB(m);
OP_ASL_HANDLER(m);
WRITE_BACK(m);
static void Op78(void) // ASL ABS
{
- uint8 m;
+ uint8_t m;
READ_ABS_WB(m);
OP_ASL_HANDLER(m);
WRITE_BACK(m);
// ASR opcodes
#define OP_ASR_HANDLER(m) \
- uint8 newCarry = m & 0x01; \
+ uint8_t newCarry = m & 0x01; \
m = (m >> 1) | (m & 0x80); \
SET_ZN(m); \
flagC = newCarry; \
static void Op67(void) // ASR ZP, X
{
- uint8 m;
+ uint8_t m;
READ_ZP_X_WB(m);
OP_ASR_HANDLER(m);
WRITE_BACK(m);
static void Op77(void) // ASR ABS
{
- uint8 m;
+ uint8_t m;
READ_ABS_WB(m);
OP_ASR_HANDLER(m);
WRITE_BACK(m);
// LSR opcodes
#define OP_LSR_HANDLER(m) \
- uint8 newCarry = m & 0x01; \
+ uint8_t newCarry = m & 0x01; \
m >>= 1; \
SET_ZN(m); \
flagC = newCarry; \
static void Op64(void) // LSR ZP, X
{
- uint8 m;
+ uint8_t m;
READ_ZP_X_WB(m);
OP_LSR_HANDLER(m);
WRITE_BACK(m);
static void Op74(void) // LSR ABS
{
- uint8 m;
+ uint8_t m;
READ_ABS_WB(m);
OP_LSR_HANDLER(m);
WRITE_BACK(m);
// SUB opcodes
#define OP_SUB_HANDLER(m, acc) \
- uint16 sum = (uint16)acc - (m); \
+ uint16_t sum = (uint16_t)acc - (m); \
flagC = sum >> 15; \
SET_V(m, acc, sum); \
- acc = (uint8)sum; \
+ acc = (uint8_t)sum; \
SET_ZN(acc)
static void Op80(void) // SUBA #
{
- uint16 m = READ_IMM;
+ uint16_t m = READ_IMM;
OP_SUB_HANDLER(m, regs.a);
}
static void Op90(void) // SUBA ZP
{
- uint16 m = READ_ZP;
+ uint16_t m = READ_ZP;
OP_SUB_HANDLER(m, regs.a);
}
static void OpA0(void) // SUBA ZP, X
{
- uint16 m = READ_ZP_X;
+ uint16_t m = READ_ZP_X;
OP_SUB_HANDLER(m, regs.a);
}
static void OpB0(void) // SUBA ABS
{
- uint16 m = READ_ABS;
+ uint16_t m = READ_ABS;
OP_SUB_HANDLER(m, regs.a);
}
static void OpC0(void) // SUBB #
{
- uint16 m = READ_IMM;
+ uint16_t m = READ_IMM;
OP_SUB_HANDLER(m, regs.b);
}
static void OpD0(void) // SUBB ZP
{
- uint16 m = READ_ZP;
+ uint16_t m = READ_ZP;
OP_SUB_HANDLER(m, regs.b);
}
static void OpE0(void) // SUBB ZP, X
{
- uint16 m = READ_ZP_X;
+ uint16_t m = READ_ZP_X;
OP_SUB_HANDLER(m, regs.b);
}
static void OpF0(void) // SUBB ABS
{
- uint16 m = READ_ABS;
+ uint16_t m = READ_ABS;
OP_SUB_HANDLER(m, regs.b);
}
// SBC opcodes
#define OP_SBC_HANDLER(m, acc) \
- uint16 sum = (uint16)acc - (m) - (uint16)flagC; \
+ uint16_t sum = (uint16_t)acc - (m) - (uint16_t)flagC; \
flagC = sum >> 15; \
SET_V(m, acc, sum); \
- acc = (uint8)sum; \
+ acc = (uint8_t)sum; \
SET_ZN(acc)
static void Op82(void) // SBCA #
{
- uint16 m = READ_IMM;
+ uint16_t m = READ_IMM;
OP_SBC_HANDLER(m, regs.a);
}
static void Op92(void) // SBCA ZP
{
- uint16 m = READ_ZP;
+ uint16_t m = READ_ZP;
OP_SBC_HANDLER(m, regs.a);
}
static void OpA2(void) // SBCA ZP, X
{
- uint16 m = READ_ZP_X;
+ uint16_t m = READ_ZP_X;
OP_SBC_HANDLER(m, regs.a);
}
static void OpB2(void) // SBCA ABS
{
- uint16 m = READ_ABS;
+ uint16_t m = READ_ABS;
OP_SBC_HANDLER(m, regs.a);
}
static void OpC2(void) // SBCB #
{
- uint16 m = READ_IMM;
+ uint16_t m = READ_IMM;
OP_SBC_HANDLER(m, regs.b);
}
static void OpD2(void) // SBCB ZP
{
- uint16 m = READ_ZP;
+ uint16_t m = READ_ZP;
OP_SBC_HANDLER(m, regs.b);
}
static void OpE2(void) // SBCB ZP, X
{
- uint16 m = READ_ZP_X;
+ uint16_t m = READ_ZP_X;
OP_SBC_HANDLER(m, regs.b);
}
static void OpF2(void) // SBCB ABS
{
- uint16 m = READ_ABS;
+ uint16_t m = READ_ABS;
OP_SBC_HANDLER(m, regs.b);
}
static void Op6D(void) // TST ZP, X
{
- uint8 m;
+ uint8_t m;
READ_ZP_X_WB(m);
OP_TST_HANDLER(m);
WRITE_BACK(m);
static void Op7D(void) // TST ABS
{
- uint8 m;
+ uint8_t m;
READ_ABS_WB(m);
OP_TST_HANDLER(m);
WRITE_BACK(m);
*/
#define OP_CPX_HANDLER(m) \
- uint32 result = regs.x - (m); \
+ uint32_t result = regs.x - (m); \
SET_ZNVC_CMP16(m, regs.x, result)
static void Op8C(void) // CPX #
{
- uint16 m = READ_IMM16;
+ uint16_t m = READ_IMM16;
OP_CPX_HANDLER(m);
}
static void Op9C(void) // CPX ZP
{
- uint16 m = READ_ZP16;
+ uint16_t m = READ_ZP16;
OP_CPX_HANDLER(m);
}
static void OpAC(void) // CPX ZP, X
{
- uint16 m = READ_ZP_X16;
+ uint16_t m = READ_ZP_X16;
OP_CPX_HANDLER(m);
}
static void OpBC(void) // CPX ABS
{
- uint16 m = READ_ABS16;
+ uint16_t m = READ_ABS16;
OP_CPX_HANDLER(m);
}
static void OpDF(void) // STX ZP
{
- uint16 m = EA_ZP;
+ uint16_t m = EA_ZP;
OP_ST_HANDLER(m, regs.x);
}
static void OpEF(void) // STX ZP, X
{
- uint16 m = EA_ZP_X;
+ uint16_t m = EA_ZP_X;
OP_ST_HANDLER(m, regs.x);
}
static void OpFF(void) // STX ABS
{
- uint16 m = EA_ABS;
+ uint16_t m = EA_ABS;
regs.pc += 2;
OP_ST_HANDLER(m, regs.x);
}
static void Op9F(void) // STS ZP
{
- uint16 m = EA_ZP;
+ uint16_t m = EA_ZP;
OP_ST_HANDLER(m, regs.s);
}
static void OpAF(void) // STS ZP, X
{
- uint16 m = EA_ZP_X;
+ uint16_t m = EA_ZP_X;
OP_ST_HANDLER(m, regs.s);
}
static void OpBF(void) // STS ABS
{
- uint16 m = EA_ABS;
+ uint16_t m = EA_ABS;
regs.pc += 2;
OP_ST_HANDLER(m, regs.s);
}
static void Op20(void) // BRA
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
regs.pc += m;
}
// NOTE: We can optimize this by following the maxim: "Don't branch!" by converting the boolean
// result into a multiplication. The only way to know if this is a win is to do some profiling
// both with and without the optimization.
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
//Note sure if the ! operator will do what we want, so we use ^ 1
static void Op25(void) // BCS
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * (flagC);
static void Op27(void) // BEQ
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * (flagZ);
static void Op2C(void) // BGE
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * ((flagN ^ flagV) ^ 0x01);
static void Op2E(void) // BGT
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * ((flagZ | (flagN ^ flagV)) ^ 0x01);
static void Op22(void) // BHI
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * ((flagZ | flagC) ^ 0x01);
static void Op2F(void) // BLE
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * (flagZ | (flagN ^ flagV));
static void Op23(void) // BLS
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * (flagZ | flagC);
static void Op2D(void) // BLT
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * (flagN ^ flagV);
static void Op2B(void) // BMI
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * (flagN);
static void Op26(void) // BNE
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * (flagZ ^ 0x01);
static void Op28(void) // BVC
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * (flagV ^ 0x01);
static void Op29(void) // BVS
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * (flagV);
static void Op2A(void) // BPL
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
#ifdef TEST_DONT_BRANCH_OPTIMIZATION
regs.pc += m * (flagN ^ 0x01);
static void Op8D(void) // BSR
{
- int16 m = (int16)(int8)READ_IMM;
+ int16_t m = (int16_t)(int8_t)READ_IMM;
PUSH16(regs.pc);
regs.pc += m;
}
static void OpAD(void) // JSR ZP, X
{
- uint16 m = EA_ZP_X;
+ uint16_t m = EA_ZP_X;
PUSH16(regs.pc);
regs.pc = m;
}
static void OpBD(void) // JSR ABS
{
- uint16 m = EA_ABS;
+ uint16_t m = EA_ABS;
regs.pc += 2;
PUSH16(regs.pc);
regs.pc = m;
//
// Internal "memcpy" (so we don't have to link with any external libraries!)
//
-static void myMemcpy(void * dst, void * src, uint32 size)
+static void myMemcpy(void * dst, void * src, uint32_t size)
{
- uint8 * d = (uint8 *)dst, * s = (uint8 *)src;
+ uint8_t * d = (uint8_t *)dst, * s = (uint8_t *)src;
- for(uint32 i=0; i<size; i++)
+ for(uint32_t i=0; i<size; i++)
d[i] = s[i];
}
//
// Function to execute 6808 for "cycles" cycles
//
-void Execute6808(V6808REGS * context, uint32 cycles)
+void Execute6808(V6808REGS * context, uint32_t cycles)
{
#warning "V6808_STATE_WAI is not properly handled yet! !!! FIX !!!"
#warning "Need to convert from destructive clock to non-destructive. !!! FIX !!!"
myMemcpy(®s, context, sizeof(V6808REGS));
- UNPACK_FLAGS; // Explode flags register into individual uint8s
+ UNPACK_FLAGS; // Explode flags register into individual uint8_ts
// Execute here...
while (regs.clock < cycles)
if (logGo)
Decode6808(regs.pc);
#endif
- uint8 opcode = regs.RdMem(regs.pc++);
+ uint8_t opcode = regs.RdMem(regs.pc++);
#ifdef __DEBUG__
//if (!(regs.cpuFlags & V6808_STATE_ILLEGAL_INST))
//
// Get the clock of the currently executing CPU
//
-uint64 GetCurrentV6808Clock(void)
+uint64_t GetCurrentV6808Clock(void)
{
return regs.clock;
}
//
// Virtual 6808 Header file
//
-// by James L. Hammons
+// by James Hammons
//
// (C) 2006 Underground Software
//
#ifndef __V6808_H__
#define __V6808_H__
-#include "types.h"
+#include <stdint.h>
// Useful defines
struct V6808REGS
{
- uint16 pc; // 6808 PC register
- uint16 x; // 6808 X index register
- uint16 s; // 6808 System stack pointer
- uint8 cc; // 6808 Condition Code register
- uint8 a; // 6808 A register
- uint8 b; // 6808 B register
- uint64 clock; // 6808 clock
- uint8 (* RdMem)(uint16); // Address of uint8 read routine
- void (* WrMem)(uint16, uint8); // Address of uint8 write routine
- uint32 cpuFlags; // v6808 IRQ/RESET flags
- uint32 clockOverrun; // Amount of overflow between runs
+ uint16_t pc; // 6808 PC register
+ uint16_t x; // 6808 X index register
+ uint16_t s; // 6808 System stack pointer
+ uint8_t cc; // 6808 Condition Code register
+ uint8_t a; // 6808 A register
+ uint8_t b; // 6808 B register
+ uint64_t clock; // 6808 clock
+ uint8_t (* RdMem)(uint16_t); // Address of uint8_t read routine
+ void (* WrMem)(uint16_t, uint8_t); // Address of uint8_t write routine
+ uint32_t cpuFlags; // v6808 IRQ/RESET flags
+ uint32_t clockOverrun; // Amount of overflow between runs
};
// Function prototypes
-void Execute6808(V6808REGS *, uint32); // Function to execute 6808 instructions
-uint64 GetCurrentV6808Clock(void); // Get the clock of the currently executing CPU
-//uint8 GetCCRegister(void); // Hmm.
+void Execute6808(V6808REGS *, uint32_t); // Function to execute 6808 instructions
+uint64_t GetCurrentV6808Clock(void); // Get the clock of the currently executing CPU
+//uint8_t GetCCRegister(void); // Hmm.
#endif // __V6808_H__
+
//
// Virtual 6809 v1.3
//
-// by James L. Hammons
-// (c) 1997, 2006 Underground Software
+// by James Hammons
+// (c) 1997, 2014 Underground Software
//
-// JLH = James L. Hammons <jlhamm@acm.org>
+// JLH = James Hammons <jlhamm@acm.org>
//
// WHO WHEN WHAT
-// --- ---------- ------------------------------------------------------------
+// --- ---------- -----------------------------------------------------------
// JLH 06/15/2006 Added changelog ;-)
// JLH 06/15/2006 Scrubbed all BYTE, WORD & DWORD references from the code
// JLH 11/11/2006 Removed all SignedX() references
#define SET_N(r) (regs.cc = ((r) & 0x80 ? regs.cc | FLAG_N : regs.cc & ~FLAG_N))
//Not sure that this code is computing the carry correctly... Investigate! [Seems to be]
-#define SET_C_ADD(a,b) (regs.cc = ((uint8)(b) > (uint8)(~(a)) ? regs.cc | FLAG_C : regs.cc & ~FLAG_C))
-//#define SET_C_SUB(a,b) (regs.cc = ((uint8)(b) >= (uint8)(a) ? regs.cc | FLAG_C : regs.cc & ~FLAG_C))
-#define SET_C_CMP(a,b) (regs.cc = ((uint8)(b) >= (uint8)(a) ? regs.cc | FLAG_C : regs.cc & ~FLAG_C))
+#define SET_C_ADD(a,b) (regs.cc = ((uint8_t)(b) > (uint8_t)(~(a)) ? regs.cc | FLAG_C : regs.cc & ~FLAG_C))
+//#define SET_C_SUB(a,b) (regs.cc = ((uint8_t)(b) >= (uint8_t)(a) ? regs.cc | FLAG_C : regs.cc & ~FLAG_C))
+#define SET_C_CMP(a,b) (regs.cc = ((uint8_t)(b) >= (uint8_t)(a) ? regs.cc | FLAG_C : regs.cc & ~FLAG_C))
#define SET_ZN(r) SET_N(r); SET_Z(r)
#define SET_ZNC_ADD(a,b,r) SET_N(r); SET_Z(r); SET_C_ADD(a,b)
//#define SET_ZNC_SUB(a,b,r) SET_N(r); SET_Z(r); SET_C_SUB(a,b)
#define READ_IND_ZP_Y regs.RdMem(EA_IND_ZP_Y)
#define READ_IND_ZP regs.RdMem(EA_IND_ZP)
-#define READ_IMM_WB(v) uint16 addr = EA_IMM; v = regs.RdMem(addr)
-#define READ_ZP_WB(v) uint16 addr = EA_ZP; v = regs.RdMem(addr)
-#define READ_ZP_X_WB(v) uint16 addr = EA_ZP_X; v = regs.RdMem(addr)
-#define READ_ABS_WB(v) uint16 addr = EA_ABS; v = regs.RdMem(addr); regs.pc += 2
-#define READ_ABS_X_WB(v) uint16 addr = EA_ABS_X; v = regs.RdMem(addr); regs.pc += 2
-#define READ_ABS_Y_WB(v) uint16 addr = EA_ABS_Y; v = regs.RdMem(addr); regs.pc += 2
-#define READ_IND_ZP_X_WB(v) uint16 addr = EA_IND_ZP_X; v = regs.RdMem(addr)
-#define READ_IND_ZP_Y_WB(v) uint16 addr = EA_IND_ZP_Y; v = regs.RdMem(addr)
-#define READ_IND_ZP_WB(v) uint16 addr = EA_IND_ZP; v = regs.RdMem(addr)
+#define READ_IMM_WB(v) uint16_t addr = EA_IMM; v = regs.RdMem(addr)
+#define READ_ZP_WB(v) uint16_t addr = EA_ZP; v = regs.RdMem(addr)
+#define READ_ZP_X_WB(v) uint16_t addr = EA_ZP_X; v = regs.RdMem(addr)
+#define READ_ABS_WB(v) uint16_t addr = EA_ABS; v = regs.RdMem(addr); regs.pc += 2
+#define READ_ABS_X_WB(v) uint16_t addr = EA_ABS_X; v = regs.RdMem(addr); regs.pc += 2
+#define READ_ABS_Y_WB(v) uint16_t addr = EA_ABS_Y; v = regs.RdMem(addr); regs.pc += 2
+#define READ_IND_ZP_X_WB(v) uint16_t addr = EA_IND_ZP_X; v = regs.RdMem(addr)
+#define READ_IND_ZP_Y_WB(v) uint16_t addr = EA_IND_ZP_Y; v = regs.RdMem(addr)
+#define READ_IND_ZP_WB(v) uint16_t addr = EA_IND_ZP; v = regs.RdMem(addr)
#define WRITE_BACK(d) regs.WrMem(addr, (d))
static V6809REGS regs;
//Let's see if we can nuke this shit.
-static uint16 addr; // Temporary variables common to all funcs...
-static uint8 tmp;
+static uint16_t addr; // Temporary variables common to all funcs...
+static uint8_t tmp;
// Private function prototypes
-static uint16 FetchW(void);
-static uint16 RdMemW(uint16 addr);
-static void WrMemW(uint16 addr, uint16 w);
-static uint16 ReadEXG(uint8); // Read TFR/EXG post byte
-static void WriteEXG(uint8, uint16); // Set TFR/EXG data
-static uint16 DecodeReg(uint8); // Decode register data
-static uint16 DecodeIDX(uint8); // Decode IDX data
+static uint16_t FetchW(void);
+static uint16_t RdMemW(uint16_t addr);
+static void WrMemW(uint16_t addr, uint16_t w);
+static uint16_t ReadEXG(uint8_t); // Read TFR/EXG post byte
+static void WriteEXG(uint8_t, uint16_t); // Set TFR/EXG data
+static uint16_t DecodeReg(uint8_t); // Decode register data
+static uint16_t DecodeIDX(uint8_t); // Decode IDX data
//static void (* exec_op1[256])();
//static void (* exec_op2[256])();
// Fetch a word out of 6809 memory (little endian format)
// This is a leftover from when fetches were separated from garden variety reads...
//
-static uint16 FetchW()
+static uint16_t FetchW()
{
- uint16 w = RdMemW(regs.pc);
+ uint16_t w = RdMemW(regs.pc);
regs.pc += 2;
return w;
}
//
// Read word from memory function
//
-uint16 RdMemW(uint16 addr)
+uint16_t RdMemW(uint16_t addr)
{
- return (uint16)(regs.RdMem(addr) << 8) | regs.RdMem(addr + 1);
+ return (uint16_t)(regs.RdMem(addr) << 8) | regs.RdMem(addr + 1);
}
//
// Write word to memory function
//
-void WrMemW(uint16 addr, uint16 w)
+void WrMemW(uint16_t addr, uint16_t w)
{
regs.WrMem(addr + 0, w >> 8);
regs.WrMem(addr + 1, w & 0xFF);
//
// Function to read TFR/EXG post byte
//
-uint16 ReadEXG(uint8 code)
+uint16_t ReadEXG(uint8_t code)
{
- uint16 retval;
+ uint16_t retval;
switch (code)
{
//
// Function to set TFR/EXG data
//
-void WriteEXG(uint8 code, uint16 data)
+void WriteEXG(uint8_t code, uint16_t data)
{
switch (code)
{
//
// Function to decode register data
//
-uint16 DecodeReg(uint8 reg)
+uint16_t DecodeReg(uint8_t reg)
{
- uint16 retval;
+ uint16_t retval;
switch (reg)
{
//
// Function to decode IDX data
//
-uint16 DecodeIDX(uint8 code)
+uint16_t DecodeIDX(uint8_t code)
{
- uint16 addr, woff;
- uint8 reg = (code & 0x60) >> 5, idxind = (code & 0x10) >> 4, lo_nyb = code & 0x0F;
+ uint16_t addr, woff;
+ uint8_t reg = (code & 0x60) >> 5, idxind = (code & 0x10) >> 4, lo_nyb = code & 0x0F;
if (!(code & 0x80)) // Hi bit unset? Then decode 4 bit offset
addr = DecodeReg(reg) + (idxind ? lo_nyb - 16 : lo_nyb);
addr = RdMemW(woff);
break;
case 5:
- woff = DecodeReg(reg) + (int16)(int8)regs.b;
+ woff = DecodeReg(reg) + (int16_t)(int8_t)regs.b;
addr = RdMemW(woff);
break;
case 6:
- woff = DecodeReg(reg) + (int16)(int8)regs.a;
+ woff = DecodeReg(reg) + (int16_t)(int8_t)regs.a;
addr = RdMemW(woff);
break;
case 8:
- woff = DecodeReg(reg) + (int16)(int8)regs.RdMem(regs.pc++);
+ woff = DecodeReg(reg) + (int16_t)(int8_t)regs.RdMem(regs.pc++);
addr = RdMemW(woff);
break;
case 9:
addr = RdMemW(woff);
break;
case 12:
- woff = regs.pc + (int16)(int8)regs.RdMem(regs.pc++);
+ woff = regs.pc + (int16_t)(int8_t)regs.RdMem(regs.pc++);
addr = RdMemW(woff);
break;
case 13:
}
addr = DecodeReg(reg); break; }
case 4: { addr = DecodeReg(reg); break; }
- case 5: { addr = DecodeReg(reg) + (int16)(int8)regs.b; break; }
- case 6: { addr = DecodeReg(reg) + (int16)(int8)regs.a; break; }
- case 8: { addr = DecodeReg(reg) + (int16)(int8)regs.RdMem(regs.pc++); break; }
+ case 5: { addr = DecodeReg(reg) + (int16_t)(int8_t)regs.b; break; }
+ case 6: { addr = DecodeReg(reg) + (int16_t)(int8_t)regs.a; break; }
+ case 8: { addr = DecodeReg(reg) + (int16_t)(int8_t)regs.RdMem(regs.pc++); break; }
case 9: { addr = DecodeReg(reg) + FetchW(); break; }
case 11: { addr = DecodeReg(reg) + ((regs.a << 8) | regs.b); break; }
- case 12: { addr = regs.pc + (int16)(int8)regs.RdMem(regs.pc++); break; }
+ case 12: { addr = regs.pc + (int16_t)(int8_t)regs.RdMem(regs.pc++); break; }
case 13: { addr = regs.pc + FetchW(); break; }
}
}
}
static void Op06(void) // ROR DP
{
- addr = (regs.dp<<8) | regs.RdMem(regs.pc++); uint8 tmp2 = regs.RdMem(addr);
+ addr = (regs.dp<<8) | regs.RdMem(regs.pc++); uint8_t tmp2 = regs.RdMem(addr);
tmp = (tmp2>>1) + (regs.cc&0x01)*128;
regs.WrMem(addr, tmp);
(tmp2&0x01 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Shift bit into carry
}
static void Op09(void) // ROL DP
{
- addr = (regs.dp<<8) | regs.RdMem(regs.pc++); uint8 tmp2 = regs.RdMem(addr);
+ addr = (regs.dp<<8) | regs.RdMem(regs.pc++); uint8_t tmp2 = regs.RdMem(addr);
tmp = (tmp2<<1) + (regs.cc&0x01);
regs.WrMem(addr, tmp);
(tmp2&0x80 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Shift hi bit into carry
static void Op17(void) // LBSR
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
regs.WrMem(--regs.s, regs.pc & 0xFF);
regs.WrMem(--regs.s, regs.pc >> 8);
// regs.pc += SignedW(addr);
static void Op19(void) // DAA
{
#if 0
- uint8 result = regs.a;
+ uint8_t result = regs.a;
if ((regs.cc&0x20) || ((regs.a&0x0F) > 0x09)) // H set or lo nyb too big?
{
if (regs.a == 0) regs.cc |= 0x04; // Adjust Zero flag
if (regs.a&0x80) regs.cc |= 0x08; // Adjust Negative flag
#else
- uint16 result = (uint16)regs.a;
+ uint16_t result = (uint16_t)regs.a;
if ((regs.a & 0x0F) > 0x09 || (regs.cc & FLAG_H))
result += 0x06;
if ((regs.a & 0xF0) > 0x90 || (regs.cc & FLAG_C) || ((regs.a & 0xF0) > 0x80 && (regs.a & 0x0F) > 0x09))
result += 0x60;
- regs.a = (uint8)result;
+ regs.a = (uint8_t)result;
// SET_ZN(result);
// CLR_V; // Not sure this is correct...
regs.cc &= 0xF1; // CL NZV
static void Op20(void) // BRA
{
// regs.pc += SignedB(regs.RdMem(regs.pc++)); // Branch always
- regs.pc += (int16)(int8)regs.RdMem(regs.pc) + 1; // Branch always
+ regs.pc += (int16_t)(int8_t)regs.RdMem(regs.pc) + 1; // Branch always
regs.clock += 3;
}
static void Op22(void) // BHI
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (!(regs.cc & 0x05))
regs.pc += word;
static void Op23(void) // BLS
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (regs.cc & 0x05)
regs.pc += word;
static void Op24(void) // BCC (BHS)
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (!(regs.cc & 0x01))
regs.pc += word;
static void Op25(void) // BCS (BLO)
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (regs.cc & 0x01)
regs.pc += word;
static void Op26(void) // BNE
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (!(regs.cc & 0x04))
regs.pc += word;
static void Op27(void) // BEQ
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (regs.cc & 0x04)
regs.pc += word;
static void Op28(void) // BVC
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (!(regs.cc & 0x02))
regs.pc += word;
static void Op29(void) // BVS
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (regs.cc & 0x02)
regs.pc += word;
static void Op2A(void) // BPL
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (!(regs.cc & 0x08))
regs.pc += word;
static void Op2B(void) // BMI
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (regs.cc & 0x08)
regs.pc += word;
static void Op2C(void) // BGE
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (!(((regs.cc & 0x08) >> 2) ^ (regs.cc & 0x02)))
regs.pc += word;
static void Op2D(void) // BLT
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (((regs.cc & 0x08) >> 2) ^ (regs.cc & 0x02))
regs.pc += word;
static void Op2E(void) // BGT
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if (!((regs.cc & 0x04) | (((regs.cc & 0x08) >> 2) ^ (regs.cc & 0x02))))
regs.pc += word;
static void Op2F(void) // BLE
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
if ((regs.cc & 0x04) | (((regs.cc & 0x08) >> 2) ^ (regs.cc & 0x02)))
regs.pc += word;
static void Op60(void) // NEG IDX
{
addr = DecodeIDX(regs.RdMem(regs.pc++));
- tmp = regs.RdMem(addr); uint8 res = 256 - tmp;
+ tmp = regs.RdMem(addr); uint8_t res = 256 - tmp;
regs.WrMem(addr, res);
// ((res^tmp)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Adjust H carry
(res == 0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void Op66(void) // ROR IDX
{
addr = DecodeIDX(regs.RdMem(regs.pc++));
- tmp = regs.RdMem(addr); uint8 tmp2 = tmp;
+ tmp = regs.RdMem(addr); uint8_t tmp2 = tmp;
tmp = (tmp >> 1) + (regs.cc&0x01)*128;
regs.WrMem(addr, tmp);
(tmp2&0x01 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Shift bit into carry
}
static void Op69(void) // ROL IDX
{
- uint8 tmp2 = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
+ uint8_t tmp2 = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
tmp = (tmp2<<1) + (regs.cc&0x01);
regs.WrMem(addr, tmp);
(tmp2&0x80 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Shift hi bit into carry
}
static void Op6A(void) // DEC IDX
{
- uint8 tmp; uint16 addr;
+ uint8_t tmp; uint16_t addr;
addr = DecodeIDX(regs.RdMem(regs.pc++));
tmp = regs.RdMem(addr) - 1;
regs.WrMem(addr, tmp);
static void Op70(void) // NEG ABS
{
addr = FetchW();
- tmp = regs.RdMem(addr); uint8 res = 256 - tmp;
+ tmp = regs.RdMem(addr); uint8_t res = 256 - tmp;
regs.WrMem(addr, res);
(res == 0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
(res == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
}
static void Op76(void) // ROR ABS
{
- uint8 tmp; uint16 addr;
+ uint8_t tmp; uint16_t addr;
addr = FetchW();
- tmp = regs.RdMem(addr); uint8 tmp2 = tmp;
+ tmp = regs.RdMem(addr); uint8_t tmp2 = tmp;
tmp = (tmp >> 1) + (regs.cc&0x01)*128;
regs.WrMem(addr, tmp);
(tmp2&0x01 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Shift bit into carry
}
static void Op77(void) // ASR ABS
{
- uint8 tmp; uint16 addr;
+ uint8_t tmp; uint16_t addr;
addr = FetchW();
tmp = regs.RdMem(addr);
(tmp&0x01 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Shift bit into carry
}
static void Op78(void) // LSL ABS
{
- uint8 tmp; uint16 addr;
+ uint8_t tmp; uint16_t addr;
addr = FetchW();
tmp = regs.RdMem(addr);
(tmp&0x80 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Shift hi bit into carry
}
static void Op79(void) // ROL ABS
{
- uint8 tmp2 = regs.RdMem(FetchW());
+ uint8_t tmp2 = regs.RdMem(FetchW());
tmp = (tmp2<<1) + (regs.cc&0x01);
regs.WrMem(addr, tmp);
(tmp2&0x80 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Shift hi bit into carry
}
static void Op7A(void) // DEC ABS
{
- uint8 tmp; uint16 addr;
+ uint8_t tmp; uint16_t addr;
addr = FetchW();
tmp = regs.RdMem(addr) - 1;
regs.WrMem(addr, tmp);
}
static void Op7C(void) // INC ABS
{
- uint8 tmp; uint16 addr;
+ uint8_t tmp; uint16_t addr;
addr = FetchW();
tmp = regs.RdMem(addr) + 1;
regs.WrMem(addr, tmp);
static void Op7D(void) // TST ABS
{
- uint8 tmp = regs.RdMem(FetchW());
+ uint8_t tmp = regs.RdMem(FetchW());
(tmp == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(tmp&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
}
static void Op80(void) // SUBA #
{
- uint8 tmp = regs.RdMem(regs.pc++); uint8 as = regs.a;
+ uint8_t tmp = regs.RdMem(regs.pc++); uint8_t as = regs.a;
regs.a -= tmp;
(as < tmp ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((as^tmp^regs.a^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void Op81(void) // CMPA #
{
tmp = regs.RdMem(regs.pc++);
- uint8 db = regs.a - tmp;
+ uint8_t db = regs.a - tmp;
(regs.a < tmp ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((regs.a^tmp^db^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
(db == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
}
static void Op82(void) // SBCA #
{
- tmp = regs.RdMem(regs.pc++); uint8 as = regs.a;
+ tmp = regs.RdMem(regs.pc++); uint8_t as = regs.a;
regs.a = regs.a - tmp - (regs.cc&0x01);
(as < (tmp+(regs.cc&0x01)) ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((as^tmp^regs.a^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
}
static void Op83(void) // SUBD #
{
- addr = FetchW(); uint16 dr = (regs.a<<8)|regs.b, ds = dr;
+ addr = FetchW(); uint16_t dr = (regs.a<<8)|regs.b, ds = dr;
dr -= addr;
(ds < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((ds^addr^dr^(regs.cc<<15))&0x8000 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void Op89(void) // ADCA #
{
tmp = regs.RdMem(regs.pc++);
- addr = (uint16)regs.a + (uint16)tmp + (uint16)(regs.cc&0x01);
+ addr = (uint16_t)regs.a + (uint16_t)tmp + (uint16_t)(regs.cc&0x01);
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry
((regs.a^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void Op8C(void) // CMPX #
{
addr = FetchW();
- uint16 dw = regs.x - addr;
+ uint16_t dw = regs.x - addr;
(regs.x < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((regs.x^addr^dw^(regs.cc<<15))&0x8000 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerfl
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
static void Op8D(void) // Bregs.s
{
- uint16 word = (int16)(int8)regs.RdMem(regs.pc++);
+ uint16_t word = (int16_t)(int8_t)regs.RdMem(regs.pc++);
regs.WrMem(--regs.s, regs.pc & 0xFF);
regs.WrMem(--regs.s, regs.pc >> 8);
regs.pc += word;
}
static void Op90(void) // SUBA DP
{
- tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8 as = regs.a;
+ tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8_t as = regs.a;
regs.a -= tmp;
(regs.a == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(regs.a&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
static void Op91(void) // CMPA DP
{
tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++));
- uint8 db = regs.a - tmp;
+ uint8_t db = regs.a - tmp;
(db == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(db&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.a < tmp ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void Op92(void) // SBCA DP
{
- tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8 as = regs.a;
+ tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8_t as = regs.a;
regs.a = regs.a - tmp - (regs.cc&0x01);
(as < (tmp+(regs.cc&0x01)) ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((as^tmp^regs.a^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
}
static void Op93(void) // SUBD DP
{
- addr = (regs.dp<<8)|regs.RdMem(regs.pc++); uint16 dr = (regs.a<<8)|regs.b, ds = dr;
- uint16 adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ addr = (regs.dp<<8)|regs.RdMem(regs.pc++); uint16_t dr = (regs.a<<8)|regs.b, ds = dr;
+ uint16_t adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
dr -= adr2;
(ds < adr2 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((ds^adr2^dr^(regs.cc<<15))&0x8000 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void Op99(void) // ADCA DP
{
tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++));
- addr = (uint16)regs.a + (uint16)tmp + (uint16)(regs.cc&0x01);
+ addr = (uint16_t)regs.a + (uint16_t)tmp + (uint16_t)(regs.cc&0x01);
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry
((regs.a^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void Op9B(void) // ADDA DP
{
tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++));
- addr = (uint16)regs.a + (uint16)tmp;
+ addr = (uint16_t)regs.a + (uint16_t)tmp;
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.a^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
static void Op9C(void) // CMPX DP
{
addr = (regs.dp<<8)|regs.RdMem(regs.pc++);
- uint16 adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- uint16 dw = regs.x - adr2;
+ uint16_t adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16_t dw = regs.x - adr2;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.x < adr2 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void OpA0(void) // SUBA IDX
{
- tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8 as = regs.a;
+ tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8_t as = regs.a;
regs.a -= tmp;
(regs.a == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(regs.a&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
static void OpA1(void) // CMPA IDX
{
tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
- uint8 db = regs.a - tmp;
+ uint8_t db = regs.a - tmp;
(db == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(db&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.a < tmp ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void OpA2(void) // SBCA IDX
{
- tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8 as = regs.a;
+ tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8_t as = regs.a;
regs.a = regs.a - tmp - (regs.cc&0x01);
(as < (tmp+(regs.cc&0x01)) ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((as^tmp^regs.a^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
}
static void OpA3(void) // SUBD IDX
{
- addr = DecodeIDX(regs.RdMem(regs.pc++)); uint16 dr = (regs.a<<8)|regs.b, ds = dr;
- uint16 adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ addr = DecodeIDX(regs.RdMem(regs.pc++)); uint16_t dr = (regs.a<<8)|regs.b, ds = dr;
+ uint16_t adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
dr -= adr2;
(ds < adr2 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((ds^adr2^dr^(regs.cc<<15))&0x8000 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void OpA9(void) // ADCA IDX
{
tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
- addr = (uint16)regs.a + (uint16)tmp + (uint16)(regs.cc&0x01);
+ addr = (uint16_t)regs.a + (uint16_t)tmp + (uint16_t)(regs.cc&0x01);
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.a^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
static void OpAB(void) // ADDA IDX
{
tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
- addr = (uint16)regs.a + (uint16)tmp;
+ addr = (uint16_t)regs.a + (uint16_t)tmp;
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.a^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
static void OpAC(void) // CMPX IDX
{
addr = DecodeIDX(regs.RdMem(regs.pc++));
- uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- uint16 dw = regs.x - addr2;
+ uint16_t addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16_t dw = regs.x - addr2;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.x < addr2 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void OpB0(void) // SUBA ABS
{
- tmp = regs.RdMem(FetchW()); uint8 as = regs.a;
+ tmp = regs.RdMem(FetchW()); uint8_t as = regs.a;
regs.a -= tmp;
(regs.a == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(regs.a&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
static void OpB1(void) // CMPA ABS
{
tmp = regs.RdMem(FetchW());
- uint8 db = regs.a - tmp;
+ uint8_t db = regs.a - tmp;
(db == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(db&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.a < tmp ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void OpB2(void) // SBCA ABS
{
- tmp = regs.RdMem(FetchW()); uint8 as = regs.a;
+ tmp = regs.RdMem(FetchW()); uint8_t as = regs.a;
regs.a = regs.a - tmp - (regs.cc&0x01);
(as < (tmp+(regs.cc&0x01)) ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((as^tmp^regs.a^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
}
static void OpB3(void) // SUBD ABS
{
- addr = FetchW(); uint16 dr = (regs.a<<8)|regs.b, ds = dr;
- uint16 adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ addr = FetchW(); uint16_t dr = (regs.a<<8)|regs.b, ds = dr;
+ uint16_t adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
dr -= adr2;
(ds < adr2 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((ds^adr2^dr^(regs.cc<<15))&0x8000 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerfl
static void OpB9(void) // ADCA ABS
{
tmp = regs.RdMem(FetchW());
- addr = (uint16)regs.a + (uint16)tmp + (uint16)(regs.cc&0x01);
+ addr = (uint16_t)regs.a + (uint16_t)tmp + (uint16_t)(regs.cc&0x01);
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.a^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void OpBB(void) // ADDA ABS
{
tmp = regs.RdMem(FetchW());
- addr = (uint16)regs.a + (uint16)tmp;
+ addr = (uint16_t)regs.a + (uint16_t)tmp;
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.a^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
}
static void OpBC(void) // CMPX ABS
{
- addr = FetchW(); uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- uint16 dw = regs.x - addr2;
+ addr = FetchW(); uint16_t addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16_t dw = regs.x - addr2;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.x < addr2 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
static void OpC0(void) // SUBB #
{
- tmp = regs.RdMem(regs.pc++); uint8 bs = regs.b;
+ tmp = regs.RdMem(regs.pc++); uint8_t bs = regs.b;
regs.b -= tmp;
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
static void OpC1(void) // CMPB #
{
tmp = regs.RdMem(regs.pc++);
- uint8 db = regs.b - tmp;
+ uint8_t db = regs.b - tmp;
(regs.b < tmp ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((regs.b^tmp^db^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
(db == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
}
static void OpC2(void) // SBCB #
{
- tmp = regs.RdMem(regs.pc++); uint8 bs = regs.b;
+ tmp = regs.RdMem(regs.pc++); uint8_t bs = regs.b;
regs.b = regs.b - tmp - (regs.cc&0x01);
(bs < (tmp+(regs.cc&0x01)) ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((bs^tmp^regs.b^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void OpC9(void) // ADCB #
{
tmp = regs.RdMem(regs.pc++);
- addr = (uint16)regs.b + (uint16)tmp + (uint16)(regs.cc&0x01);
+ addr = (uint16_t)regs.b + (uint16_t)tmp + (uint16_t)(regs.cc&0x01);
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.b^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
}
static void OpD0(void) // SUBB DP
{
- tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8 bs = regs.b;
+ tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8_t bs = regs.b;
regs.b -= tmp;
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
static void OpD1(void) // CMPB DP
{
tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++));
- uint8 db = regs.b - tmp;
+ uint8_t db = regs.b - tmp;
(db == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(db&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.b < tmp ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void OpD2(void) // SBCB DP
{
- tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8 bs = regs.b;
+ tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8_t bs = regs.b;
regs.b = regs.b - tmp - (regs.cc&0x01);
(bs < (tmp+(regs.cc&0x01)) ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((bs^tmp^regs.b^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void OpD3(void) // ADDD DP
{
addr = (regs.dp<<8)|regs.RdMem(regs.pc++); long dr = ((regs.a<<8)|regs.b)&0xFFFF, ds = dr;
- uint16 adr2 = (regs.RdMem(addr)<<8)|regs.RdMem(addr+1);
+ uint16_t adr2 = (regs.RdMem(addr)<<8)|regs.RdMem(addr+1);
dr += adr2;
(dr > 0xFFFF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
dr &= 0xFFFF;
static void OpD9(void) // ADCB DP
{
tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++));
- addr = (uint16)regs.b + (uint16)tmp + (uint16)(regs.cc&0x01);
+ addr = (uint16_t)regs.b + (uint16_t)tmp + (uint16_t)(regs.cc&0x01);
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.b^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void OpDB(void) // ADDB DP
{
tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++));
- addr = (uint16)regs.b + (uint16)tmp;
+ addr = (uint16_t)regs.b + (uint16_t)tmp;
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.b^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
}
static void OpE0(void) // SUBB IDX
{
- tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8 bs = regs.b;
+ tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8_t bs = regs.b;
regs.b -= tmp;
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
static void OpE1(void) // CMPB IDX
{
tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
- uint8 db = regs.b - tmp;
+ uint8_t db = regs.b - tmp;
(db == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(db&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.b < tmp ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void OpE2(void) // SBCB IDX
{
- tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8 bs = regs.b;
+ tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8_t bs = regs.b;
regs.b = regs.b - tmp - (regs.cc&0x01);
(bs < (tmp+(regs.cc&0x01)) ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
((bs^tmp^regs.b^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void OpE3(void) // ADDD IDX
{
addr = DecodeIDX(regs.RdMem(regs.pc++)); long dr = ((regs.a<<8)|regs.b)&0xFFFF, ds = dr;
- uint16 adr2 = (regs.RdMem(addr)<<8)|regs.RdMem(addr+1);
+ uint16_t adr2 = (regs.RdMem(addr)<<8)|regs.RdMem(addr+1);
dr += adr2;
(dr > 0xFFFF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
dr &= 0xFFFF;
static void OpE9(void) // ADCB IDX
{
tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
- addr = (uint16)regs.b + (uint16)tmp + (uint16)(regs.cc&0x01);
+ addr = (uint16_t)regs.b + (uint16_t)tmp + (uint16_t)(regs.cc&0x01);
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.b^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void OpEB(void) // ADDB IDX
{
tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
- addr = (uint16)regs.b + (uint16)tmp;
+ addr = (uint16_t)regs.b + (uint16_t)tmp;
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.b^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
}
static void OpF0(void) // SUBB ABS
{
- tmp = regs.RdMem(FetchW()); uint8 bs = regs.b;
+ tmp = regs.RdMem(FetchW()); uint8_t bs = regs.b;
regs.b -= tmp;
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
static void OpF1(void) // CMPB ABS
{
tmp = regs.RdMem(FetchW());
- uint8 db = regs.b - tmp;
+ uint8_t db = regs.b - tmp;
(db == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(db&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.b < tmp ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void OpF2(void) // SBCB ABS
{
- tmp = regs.RdMem(FetchW()); uint8 bs = regs.b;
+ tmp = regs.RdMem(FetchW()); uint8_t bs = regs.b;
regs.b = regs.b - tmp - (regs.cc&0x01);
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
static void OpF3(void) // ADDD ABS
{
addr = FetchW(); long dr = ((regs.a<<8)|regs.b)&0xFFFF, ds = dr;
- uint16 adr2 = (regs.RdMem(addr)<<8)|regs.RdMem(addr+1);
+ uint16_t adr2 = (regs.RdMem(addr)<<8)|regs.RdMem(addr+1);
dr += adr2;
(dr > 0xFFFF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
dr &= 0xFFFF;
static void OpF9(void) // ADCB ABS
{
tmp = regs.RdMem(FetchW());
- addr = (uint16)regs.b + (uint16)tmp + (uint16)(regs.cc&0x01);
+ addr = (uint16_t)regs.b + (uint16_t)tmp + (uint16_t)(regs.cc&0x01);
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.b^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
static void OpFB(void) // ADDB ABS
{
tmp = regs.RdMem(FetchW());
- addr = (uint16)regs.b + (uint16)tmp;
+ addr = (uint16_t)regs.b + (uint16_t)tmp;
(addr > 0x00FF ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Set Carry flag
((regs.b^tmp^addr)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Set Half carry
((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
static void Op1022(void) // LBHI
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (!((regs.cc & 0x01) | (regs.cc & 0x04)))
regs.pc += word;
static void Op1023(void) // LBLS
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if ((regs.cc & 0x01) | (regs.cc & 0x04))
regs.pc += word;
static void Op1024(void) // LBCC (LBHS)
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (!(regs.cc & 0x01))
regs.pc += word;
static void Op1025(void) // LBCS (LBLO)
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (regs.cc & 0x01)
regs.pc += word;
static void Op1026(void) // LBNE
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (!(regs.cc & 0x04))
regs.pc += word;
static void Op1027(void) // LBEQ
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (regs.cc & 0x04)
regs.pc += word;
static void Op1028(void) // LBVC
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (!(regs.cc & 0x02))
regs.pc += word;
static void Op1029(void) // LBVS
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (regs.cc & 0x02)
regs.pc += word;
static void Op102A(void) // LBPL
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (!(regs.cc & 0x08))
regs.pc += word;
static void Op102B(void) // LBMI
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (regs.cc & 0x08)
regs.pc += word;
static void Op102C(void) // LBGE
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (!(((regs.cc & 0x08) >> 2) ^ (regs.cc & 0x02)))
regs.pc += word;
static void Op102D(void) // LBLT
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (((regs.cc & 0x08) >> 2) ^ (regs.cc & 0x02))
regs.pc += word;
static void Op102E(void) // LBGT
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if (!((regs.cc & 0x04) | (((regs.cc & 0x08) >> 2) ^ (regs.cc & 0x02))))
regs.pc += word;
static void Op102F(void) // LBLE
{
- uint16 word = FetchW();
+ uint16_t word = FetchW();
if ((regs.cc & 0x04) | (((regs.cc & 0x08) >> 2) ^ (regs.cc & 0x02)))
regs.pc += word;
}
static void Op1083(void) // CMPD #
{
- addr = FetchW(); uint16 dr = (regs.a<<8)|regs.b;
- uint16 dw = dr - addr;
+ addr = FetchW(); uint16_t dr = (regs.a<<8)|regs.b;
+ uint16_t dw = dr - addr;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(dr < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
- ((dr^addr^dw^((uint16)regs.cc<<15))&0x8000 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerfl
+ ((dr^addr^dw^((uint16_t)regs.cc<<15))&0x8000 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerfl
regs.clock += 5;
}
static void Op108C(void) // CMPY #
{
addr = FetchW();
- uint16 dw = regs.y - addr;
+ uint16_t dw = regs.y - addr;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.y < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void Op1093(void) // CMPD DP
{
- uint16 adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++), dr = (regs.a<<8)|regs.b;
+ uint16_t adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++), dr = (regs.a<<8)|regs.b;
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- uint16 dw = dr - addr;
+ uint16_t dw = dr - addr;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(dr < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void Op109C(void) // CMPY DP
{
- uint16 adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
+ uint16_t adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- uint16 dw = regs.y - addr;
+ uint16_t dw = regs.y - addr;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.y < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void Op10A3(void) // CMPD IDX
{
- uint16 adr2 = DecodeIDX(regs.RdMem(regs.pc++)), dr = (regs.a<<8)|regs.b;
+ uint16_t adr2 = DecodeIDX(regs.RdMem(regs.pc++)), dr = (regs.a<<8)|regs.b;
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- uint16 dw = dr - addr;
+ uint16_t dw = dr - addr;
regs.cc &= 0xF0; // CLC CLV CLZ CLN
if (dr < addr) regs.cc |= 0x01; // Set Carry flag
if ((dr^addr^dw^(regs.cc<<15))&0x8000) regs.cc |= 0x02; // Set oVerflow
}
static void Op10AC(void) // CMPY IDX
{
- uint16 adr2 = DecodeIDX(regs.RdMem(regs.pc++));
+ uint16_t adr2 = DecodeIDX(regs.RdMem(regs.pc++));
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- uint16 dw = regs.y - addr;
+ uint16_t dw = regs.y - addr;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.y < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void Op10B3(void) // CMPD ABS
{
- addr = FetchW(); uint16 dr = (regs.a<<8)|regs.b;
- uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- uint16 dw = dr - addr2;
+ addr = FetchW(); uint16_t dr = (regs.a<<8)|regs.b;
+ uint16_t addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16_t dw = dr - addr2;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(dr < addr2 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void Op10BC(void) // CMPY ABS
{
- addr = FetchW(); uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- uint16 dw = regs.y - addr2;
+ addr = FetchW(); uint16_t addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16_t dw = regs.y - addr2;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.y < addr2 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
static void Op1183(void) // CMPU #
{
addr = FetchW();
- uint16 dw = regs.u - addr;
+ uint16_t dw = regs.u - addr;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.u < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
static void Op118C(void) // CMPS #
{
addr = FetchW();
- uint16 dw = regs.s - addr;
+ uint16_t dw = regs.s - addr;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.s < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void Op1193(void) // CMPU DP
{
- uint16 adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
+ uint16_t adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- uint16 dw = regs.u - addr;
+ uint16_t dw = regs.u - addr;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.u < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void Op119C(void) // CMPS DP
{
- uint16 adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
+ uint16_t adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- uint16 dw = regs.s - addr;
+ uint16_t dw = regs.s - addr;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.s < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void Op11A3(void) // CMPU IDX
{
- uint16 addr2 = DecodeIDX(regs.RdMem(regs.pc++));
+ uint16_t addr2 = DecodeIDX(regs.RdMem(regs.pc++));
addr = (regs.RdMem(addr2)<<8) | regs.RdMem(addr2+1);
- uint16 dw = regs.u - addr;
+ uint16_t dw = regs.u - addr;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.u < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void Op11AC(void) // CMPS IDX
{
- uint16 addr2 = DecodeIDX(regs.RdMem(regs.pc++));
+ uint16_t addr2 = DecodeIDX(regs.RdMem(regs.pc++));
addr = (regs.RdMem(addr2)<<8) | regs.RdMem(addr2+1);
- uint16 dw = regs.s - addr;
+ uint16_t dw = regs.s - addr;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.s < addr ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
}
static void Op11B3(void) // CMPU ABS
{
- addr = FetchW(); uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- uint16 dw = regs.u - addr2;
+ addr = FetchW(); uint16_t addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16_t dw = regs.u - addr2;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.u < addr2 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
static void Op11BC(void) // CMPS ABS
{
- addr = FetchW(); uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- uint16 dw = regs.s - addr2;
+ addr = FetchW(); uint16_t addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16_t dw = regs.s - addr2;
(dw == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(dw&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
(regs.s < addr2 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust Carry flag
//temp, for testing...
#ifdef __DEBUG__
-static uint8 backTrace[256];
-static uint16 btPC[256];
+static uint8_t backTrace[256];
+static uint16_t btPC[256];
static int btPtr = 0;//*/
#endif
static void Op__(void) // Illegal opcode
//
// Internal "memcpy" (so we don't have to link with any external libraries!)
//
-static void myMemcpy(void * dst, void * src, uint32 size)
+static void myMemcpy(void * dst, void * src, uint32_t size)
{
- uint8 * d = (uint8 *)dst, * s = (uint8 *)src;
+ uint8_t * d = (uint8_t *)dst, * s = (uint8_t *)src;
- for(uint32 i=0; i<size; i++)
+ for(uint32_t i=0; i<size; i++)
d[i] = s[i];
}
#ifdef DEBUG_ILLEGAL
#include "log.h"
#include "dis6809.h"
-uint8 btPtr = 0;
-uint8 backTrace[256];
+uint8_t btPtr = 0;
+uint8_t backTrace[256];
V6809REGS btRegs[256];
bool tripped = false;
#endif
bool disasm = false;
//bool disasm = true;
#endif
-void Execute6809(V6809REGS * context, uint32 cycles)
+void Execute6809(V6809REGS * context, uint32_t cycles)
{
// If this is not in place, the clockOverrun calculations can cause the V6809 to get
// stuck in an infinite loop.
// through we remove them from the cycles passed in in order to come out
// approximately even. Over the long run, this unevenness in execution times
// evens out.
- uint64 endCycles = regs.clock + (uint64)(cycles - regs.clockOverrun);
+ uint64_t endCycles = regs.clock + (uint64_t)(cycles - regs.clockOverrun);
while (regs.clock < endCycles)
{
WriteLog("V6809: Executed illegal instruction!!!!\n\nBacktrace:\n\n");
regs.cpuFlags &= ~V6809_STATE_ILLEGAL_INST;
- for(uint16 i=btPtr; i<btPtr+256; i++)
+ for(uint16_t i=btPtr; i<btPtr+256; i++)
{
Decode6809(btRegs[i & 0xFF].pc);
// Note that these values are *before* execution, so stale...
// Handle any pending interrupts
// Hmm, this is bad and only works when flags are changed OUTSIDE of the running context...
-// uint32 flags = context->cpuFlags;
- uint32 flags = regs.cpuFlags;
+// uint32_t flags = context->cpuFlags;
+ uint32_t flags = regs.cpuFlags;
if (flags & V6809_ASSERT_LINE_RESET) // *** RESET handler ***
{
#endif
}
// Keep track of how much we overran so we can adjust on the next run...
- regs.clockOverrun = (uint32)(regs.clock - endCycles);
+ regs.clockOverrun = (uint32_t)(regs.clock - endCycles);
myMemcpy(context, ®s, sizeof(V6809REGS));
//
// Get the clock of the currently executing CPU
//
-uint64 GetCurrentV6809Clock(void)
+uint64_t GetCurrentV6809Clock(void)
{
return regs.clock;
}
//
// Get the PC of the currently executing CPU
//
-uint16 GetCurrentV6809PC(void)
+uint16_t GetCurrentV6809PC(void)
{
return regs.pc;
}
// Set a line of the currently executing CPU
-void SetLineOfCurrentV6809(uint32 line)
+void SetLineOfCurrentV6809(uint32_t line)
{
regs.cpuFlags |= line;
}
// Clear a line of the currently executing CPU
-void ClearLineOfCurrentV6809(uint32 line)
+void ClearLineOfCurrentV6809(uint32_t line)
{
#ifdef __DEBUG__
if (disasm)
//
// Virtual 6809 Header file
//
-// by James L. Hammons
+// by James Hammons
//
-// (C) 1997, 2004 Underground Software
+// (C) 1997, 2014 Underground Software
//
#ifndef __V6809_H__
#define __V6809_H__
-#include "types.h"
+#include <stdint.h>
// Useful defines
-#define FLAG_E 0x80 // Entire
-#define FLAG_F 0x40 // Fast IRQ
-#define FLAG_H 0x20 // Half carry
-#define FLAG_I 0x10 // IRQ
-#define FLAG_N 0x08 // Negative
-#define FLAG_Z 0x04 // Zero
-#define FLAG_V 0x02 // oVerflow
-#define FLAG_C 0x01 // Carry
+#define FLAG_E 0x80 // Entire
+#define FLAG_F 0x40 // Fast IRQ
+#define FLAG_H 0x20 // Half carry
+#define FLAG_I 0x10 // IRQ
+#define FLAG_N 0x08 // Negative
+#define FLAG_Z 0x04 // Zero
+#define FLAG_V 0x02 // oVerflow
+#define FLAG_C 0x01 // Carry
#define V6809_ASSERT_LINE_RESET 0x0001 // v6809 RESET line
#define V6809_ASSERT_LINE_IRQ 0x0002 // v6809 IRQ line
#define V6809_ASSERT_LINE_NMI 0x0008 // v6809 NMI line
#define V6809_STATE_SYNC 0x0010 // v6809 SYNC line
#define V6809_STATE_ILLEGAL_INST 0x0020 // Illegal instruction executed flag
-
//#define V6809_START_DEBUG_LOG EQU 0020h // Debug log go (temporary!)
// Useful structs
struct V6809REGS
{
- uint16 pc; // 6809 PC register
- uint16 x; // 6809 X index register
- uint16 y; // 6809 Y index register
- uint16 s; // 6809 System stack pointer
- uint16 u; // 6809 User stack pointer
- uint8 cc; // 6809 Condition Code register
- uint8 a; // 6809 A register
- uint8 b; // 6809 B register
- uint8 dp; // 6809 Direct Page register
-// uint32 clock; // 6809 clock (@ 1 MHz, wraps at 71.5 minutes)
- uint64 clock; // 6809 clock (@ 1 MHz, wraps at 570842 years)
- uint8 (* RdMem)(uint16); // Address of uint8 read routine
- void (* WrMem)(uint16, uint8); // Address of uint8 write routine
- uint32 cpuFlags; // v6809 IRQ/RESET flags
- uint32 clockOverrun;
+ uint16_t pc; // 6809 PC register
+ uint16_t x; // 6809 X index register
+ uint16_t y; // 6809 Y index register
+ uint16_t s; // 6809 System stack pointer
+ uint16_t u; // 6809 User stack pointer
+ uint8_t cc; // 6809 Condition Code register
+ uint8_t a; // 6809 A register
+ uint8_t b; // 6809 B register
+ uint8_t dp; // 6809 Direct Page register
+// uint32_t clock; // 6809 clock (@ 1 MHz, wraps at 71.5 minutes)
+ uint64_t clock; // 6809 clock (@ 1 MHz, wraps at 570842 years)
+ uint8_t (* RdMem)(uint16_t); // Address of uint8_t read routine
+ void (* WrMem)(uint16_t, uint8_t); // Address of uint8_t write routine
+ uint32_t cpuFlags; // v6809 IRQ/RESET flags
+ uint32_t clockOverrun;
};
// Function prototypes
-void Execute6809(V6809REGS *, uint32); // Function to execute 6809 instructions
-uint64 GetCurrentV6809Clock(void); // Get the clock of the currently executing CPU
-uint16 GetCurrentV6809PC(void); // Get the PC of the currently executing CPU
-void SetLineOfCurrentV6809(uint32 line); // Set a line of the currently executing CPU
-void ClearLineOfCurrentV6809(uint32 line); // Clear a line of the currently executing CPU
+void Execute6809(V6809REGS *, uint32_t); // Function to execute 6809 instructions
+uint64_t GetCurrentV6809Clock(void); // Get the clock of the currently executing CPU
+uint16_t GetCurrentV6809PC(void); // Get the PC of the currently executing CPU
+void SetLineOfCurrentV6809(uint32_t line); // Set a line of the currently executing CPU
+void ClearLineOfCurrentV6809(uint32_t line); // Clear a line of the currently executing CPU
#endif // __V6809_H__
+
projects / thunder / commitdiff