unnecessary v6809 core files.
@$(CC) $(CPPFLAGS) $(INCS) -c $< -o $@
obj/%.o: src/%.asm
- nasm -f elf32 -I res/ $< -o $@
+ nasm -f elf32 -I ./res/ $< -o $@
# *** sigh *** yet another variable... !!! FIX !!!
# nasm -f coff $< -o $@
-#include "winresrc.h"\r
-\r
-//\r
-// Icon\r
-//\r
-\r
-// Icon with lowest ID value placed first to ensure application icon\r
-// remains consistent on all systems.\r
-IDI_ICON1 ICON DISCARDABLE "stargem2.ico"\r
+#include "winresrc.h"
+
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDI_ICON1 ICON DISCARDABLE "thunder.ico"
// JLH 07/23/2009 Added changelog ;-)
//
+#include "gui.h"
+
#include <string>
#include <fstream> // Needed for tracelog
-#include "SDL.h" // Needed for screen.h
+//#include "SDL.h" // Needed for screen.h
#include "screen.h"
-#include "gui.h"
#include "resource.h" // Thunder graphics & sounds
using namespace std; // Yes!
extern SDL_Surface * screen;
-extern BYTE my_scr[0x14000]; // Screen buffer...
-extern BYTE * gram1; // Game RAM (do here??)
-extern BYTE hScrollOffset; // Horizontal scroll offset
-extern BYTE vScrollOffset; // Vertical scroll offset
-extern DWORD voffsets[8];
-extern BYTE * voice_rom; // PCM data pointer
+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 fstream tr; // Tracelog
// Global shit
-WORD text_life; // How long text is visible
+uint16 text_life; // How long text is visible
bool show_text; // Whether or not to show text
-WORD show_which_msg; // Which message to show
+uint16 show_which_msg; // Which message to show
bool show_gui; // Whether or not to show GUI
-WORD selection; // Which GUI item currently selected
-WORD snd_num;
-WORD gui_debounce; // GUI key debounce value
-WORD num_coins; // Number of coins dropped
-WORD blink = 0; // Used to blink player 1 & 2 start buttons
-WORD flash = 23; // Used to flash GUI lights
-WORD iline = 0; // Used to roll line
-WORD dcurcol = 179; // dipswitch cursor color
+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
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...
-WORD dswitch; // Which dipswitch is selected...
+uint16 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;
-BYTE * sndp1, * sndp2, * sndp3, * sndp4, * sndp5, * sndp6;
+uint8 * sndp1, * sndp2, * sndp3, * sndp4, * sndp5, * sndp6;
uint32 rom_pos, end_pos;
uint32 spos1, end_pos1;
uint32 spos2, end_pos2;
uint8 prevSamp2;
int8 delta_x2;
-BYTE * snd_array[3] = { sunknown, scya, scamera }; // From RESOURCE.H
-DWORD snd_lens[3] = { sunknownlen, scyalen, scameralen };
+uint8 * snd_array[3] = { sunknown, scya, scamera }; // From RESOURCE.H
+uint32 snd_lens[3] = { sunknownlen, scyalen, scameralen };
// Bitmaps
-BYTE bmp1[] = {
+uint8 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
};
-BYTE bmp2[] = {
+uint8 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
};
-BYTE bmp3[] = {
+uint8 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
};
-BYTE boptions[] = { // 35x9
+uint8 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
};
-BYTE bn0[] = {
+uint8 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
};
-BYTE bn1[] = {
+uint8 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
};
-BYTE bn2[] = {
+uint8 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
};
-BYTE bn3[] = {
+uint8 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
};
-BYTE bn4[] = {
+uint8 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
};
-BYTE bn5[] = {
+uint8 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
};
-BYTE bn6[] = {
+uint8 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
};
-BYTE bn7[] = {
+uint8 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
};
-BYTE bn8[] = {
+uint8 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
};
-BYTE bn9[] = {
+uint8 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
};
-BYTE bnA[] = {
+uint8 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
};
-BYTE bnB[] = {
+uint8 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
};
-BYTE bnC[] = {
+uint8 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
};
-BYTE bnD[] = {
+uint8 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
};
-BYTE bnE[] = {
+uint8 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
};
-BYTE bnF[] = {
+uint8 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(WORD icon_not_to_draw)
+void DrawSmallIcons(uint16 icon_not_to_draw)
{
- BYTE * iconmem;
- BYTE xl, yl;
- BYTE * sIcons[12] = { inoguis, icoinus, ipl1sts, ipl2sts, ii30hzs, ii60hzs,
+ uint8 * iconmem;
+ uint8 xl, yl;
+ uint8 * sIcons[12] = { inoguis, icoinus, ipl1sts, ipl2sts, ii30hzs, ii60hzs,
idipsws, ichecks, ikeycns, isnapss, iresets, ibyebys };
- BYTE xlens[12] = { 31, 18, 32, 35, 37, 37, 29, 23, 28, 32, 19, 19 };
- BYTE ylens[12] = { 31, 18, 19, 19, 21, 21, 23, 20, 16, 17, 20, 23 };
- BYTE xpos[11] = { 33, 48, 63, 78, 104, 0, 184, 210, 225, 240, 255 };
- BYTE iconidx[11] = { 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 6 };
+ 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 };
if (game_refresh) iconidx[9] = 5; // 60 Hz...
for(int i=0; i<5; i++)
{
- WORD idx = i + icon_not_to_draw; // Get correct start pos.
+ uint16 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]];
- DWORD scadr = hScrollOffset + voffsets[vScrollOffset];
+ uint32 scadr = hScrollOffset + voffsets[vScrollOffset];
scadr += 320*((224-yl)/2); // Center vertically
scadr += xpos[i] - (xl/2); // Center around horiz. pos.
- WORD bmpptr = 0;
+ uint16 bmpptr = 0;
for(int yy=0; yy<yl; yy++)
{
for(int xx=0; xx<xl; xx++)
{
- BYTE b = iconmem[bmpptr++];
+ uint8 b = iconmem[bmpptr++];
if (b) my_scr[scadr+xx+yy*320] = b;
}
}
}
for(int i=10; i>5; i--)
{
- WORD idx = i + icon_not_to_draw; // Get correct start pos.
+ uint16 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]];
- DWORD scadr = hScrollOffset + voffsets[vScrollOffset];
+ uint32 scadr = hScrollOffset + voffsets[vScrollOffset];
scadr += 320*((224-yl)/2); // Center vertically
scadr += xpos[i] - (xl/2); // Center around horiz. pos.
- WORD bmpptr = 0;
+ uint16 bmpptr = 0;
for(int yy=0; yy<yl; yy++)
{
for(int xx=0; xx<xl; xx++)
{
- BYTE b = iconmem[bmpptr++];
+ uint8 b = iconmem[bmpptr++];
if (b) my_scr[scadr+xx+yy*320] = b;
}
}
//
// Draw the large (selected) icon
//
-void DrawLargeIcon(WORD icon)
+void DrawLargeIcon(uint16 icon)
{
- BYTE * iconmem;
- BYTE xl, yl;
- BYTE * lIcons[11] = { inoguib, icoinub, ipl1stb, ipl2stb, ii30hzb, ii60hzb,
+ uint8 * iconmem;
+ uint8 xl, yl;
+ uint8 * lIcons[11] = { inoguib, icoinub, ipl1stb, ipl2stb, ii30hzb, ii60hzb,
idipswb, ikeycnb, isnapsb, iresetb, ibyebyb };
- BYTE xlens[11] = { 44, 45, 50, 52, 59, 59, 42, 45, 48, 58, 42 };
- BYTE ylens[11] = { 44, 40, 33, 29, 52, 52, 34, 45, 37, 40, 50 };
+ 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 };
- BYTE gsubs1[24] = { 21, 21, 20, 19, 168, 168, 31, 155, 68, 68, 67, 66,
+ uint8 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];
}
- DWORD scadr = hScrollOffset + voffsets[vScrollOffset];
+ uint32 scadr = hScrollOffset + voffsets[vScrollOffset];
scadr += 320*((224-yl)/2); // Center vertically
scadr += (288-xl)/2; // Center horizontally
- WORD bmpptr = 0;
+ uint16 bmpptr = 0;
for(int yy=0; yy<yl; yy++)
{
for(int xx=0; xx<xl; xx++)
{
- BYTE b = iconmem[bmpptr++];
+ uint8 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)
{
- BYTE fln = (23 - flash) + 1; // Want to go forward (maybe fix it?)
+ uint8 fln = (23 - flash) + 1; // Want to go forward (maybe fix it?)
switch (b)
{
case 36: { b = gsubs1[fln]; break; }
//
void DrawDipswitch(void)
{
- BYTE dseloff[16] = { 0, 1, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11, 11, 12 };
- BYTE * dtxt[13] = { idstext1, idstext2, idstext3, idstext4, idstext5,
+ 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,
idstext2, idstext6, idstext7, idstext8, idstext9,
idstext10, idstext11, idstext12 };
- BYTE dtx[13] = { 48, 80, 96, 82, 60, 80, 76, 57, 33, 50, 62, 65, 63 },
+ uint8 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 };
- DWORD dtxtoff[13] = { 4*320+24, 14*320-78, 25*320+24, 32*320-80,
+ uint32 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 };
- DWORD scadr, bmpptr;
+ uint32 scadr, bmpptr;
//dsx = //26x65
- DWORD dbase = hScrollOffset + voffsets[vScrollOffset];
+ uint32 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++)
{
- BYTE b = idswitch[bmpptr++];
+ uint8 b = idswitch[bmpptr++];
if (b) my_scr[scadr+xx+yy*320] = b;
}
}
{
for(int xx=0; xx<26; xx++)
{
- BYTE b = idswitch[bmpptr++];
+ uint8 b = idswitch[bmpptr++];
if (b) my_scr[scadr+xx+yy*320] = b;
}
}
scadr += 315; // Adjust position...
}
}
- BYTE dselected_text = dseloff[dswitch];
+ uint8 dselected_text = dseloff[dswitch];
for(int i=0; i<13; i++)
{
if (dselected_text != i)
{
for(int xx=0; xx<dtx[i]; xx++)
{
- BYTE b = dtxt[i][bmpptr++];
+ uint8 b = dtxt[i][bmpptr++];
if (b) my_scr[scadr] = b;
scadr++;
}
{
for(int xx=0; xx<dtx[dselected_text]; xx++)
{
- BYTE b = dtxt[dselected_text][bmpptr++];
+ uint8 b = dtxt[dselected_text][bmpptr++];
if (b) my_scr[scadr] = 125;
scadr++;
}
//
// User selected something! Handle it!
//
-BYTE UserSelectedSomething(void)
+uint8 UserSelectedSomething(void)
{
- //extern BYTE * gram1;
+ //extern uint8 * gram1;
if (!gui_debounce)
{
//
void ShowNumbers(int number)
{
- BYTE * bnarray[16] = { bn0, bn1, bn2, bn3, bn4, bn5, bn6, bn7, bn8, bn9,
+ uint8 * bnarray[16] = { bn0, bn1, bn2, bn3, bn4, bn5, bn6, bn7, bn8, bn9,
bnA, bnB, bnC, bnD, bnE, bnF };
- DWORD scadr = hScrollOffset + voffsets[vScrollOffset] + 642 + 2560;
- WORD bmpptr = 0;
+ uint32 scadr = hScrollOffset + voffsets[vScrollOffset] + 642 + 2560;
+ uint16 bmpptr = 0;
- BYTE first_dig = number>>4, second_dig = number&0x0F;
+ uint8 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(BYTE msg)
+void SpawnMsg(uint8 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...
- DWORD scadr = hScrollOffset + voffsets[vScrollOffset] + 642;
- WORD bmpptr = 0;
+ uint32 scadr = hScrollOffset + voffsets[vScrollOffset] + 642;
+ uint16 bmpptr = 0;
for(int y=0; y<7; y++)
{
//
void SpawnSound(int type, int snd, int channel/* = 0*/)
{
- extern DWORD psg_lens[16];
- extern BYTE * psg_adrs[16];
- extern DWORD voc_lens[32];
- extern BYTE * voc_adrs[32];
- extern DWORD fm_lens[14];
- extern BYTE * fm_adrs[14];
+ 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];
snd_num = snd;
SpawnMsg(MSHOWNUMS);
if (channel == 0)
{
// 00 nn ss (nn # of repeats of sample ss)
- DWORD st = 0;
+ uint32 st = 0;
if (snd & 0x40)
{
}
else
{
- DWORD st = 0;
+ uint32 st = 0;
if (snd & 0x40)
{
//
// GUI.H
//
-// by Jimmy Hamm
-// (C) 1998 Underground Software
+// by James L. Hammmons
+// (C) 1998, 2009 Underground Software
//
-/*#define BYTE unsigned char
-#define WORD unsigned short int
-#define DWORD unsigned long int
-#define int8 char
-#define int16 short
-#define int32 int
-#define uint8 unsigned int8
-#define uint16 unsigned int16
-#define uint32 unsigned int32*/
+
+#ifndef __GUI_H__
+#define __GUI_H__
+
#include "types.h"
+#include "SDL.h"
// Message macros
#define PL2START 3
#define REFRESH 4
#define DIPSWITCH 5
-#define OPTIONS 6
+#define OPTIONS 6
#define KEYCONFIG 7
#define SNAPSHOT 8
#define RESET 9
#define EXIT 10
-void SpawnMsg(BYTE);
+void SpawnMsg(uint8);
void DrawText(void);
void InitGUI(void);
bool ShowGUI(void);
void SelectRight(void);
void SelectUp(void);
void SelectDown(void);
-BYTE UserSelectedSomething(void);
+uint8 UserSelectedSomething(void);
void SetRefreshRate(bool);
void ActivateGUI(void);
void DeactivateGUI(void);
void SpawnSound(int, int, int channel = 0);
//void SoundFunc(uint8 *, uint16);
void SoundFunc(void *, Uint8 *, int);
+
+#endif // __GUI_H__
//
// Resource header file
//
-// by Jimmy Hamm
-// (C) 1998 Underground Software
+// by James L. Hammons
+// (C) 1998, 2009 Underground Software
//
+#ifndef __RESOURCE_H__
+#define __RESOURCE_H__
+
#ifdef __cplusplus
extern "C" {
#endif
-extern BYTE * sunknown;
-extern BYTE * scya;
-extern BYTE * scamera;
-extern DWORD sunknownlen;
-extern DWORD scyalen;
-extern DWORD scameralen;
-
-extern BYTE * inoguib;
-extern BYTE * idipswb;
-extern BYTE * ipl1stb;
-extern BYTE * ipl2stb;
-extern BYTE * ii30hzb;
-extern BYTE * ii60hzb;
-extern BYTE * icoinub;
-extern BYTE * isnapsb;
-extern BYTE * iresetb;
-extern BYTE * ibyebyb;
-extern BYTE * ikeycnb;
-
-extern BYTE * inoguis;
-extern BYTE * idipsws;
-extern BYTE * ipl1sts;
-extern BYTE * ipl2sts;
-extern BYTE * ii30hzs;
-extern BYTE * ii60hzs;
-extern BYTE * icoinus;
-extern BYTE * isnapss;
-extern BYTE * iresets;
-extern BYTE * ibyebys;
-extern BYTE * ikeycns;
-extern BYTE * ichecks;
-
-extern BYTE * idswitch;
-extern BYTE * idsbutton;
-extern BYTE * idstext1;
-extern BYTE * idstext2;
-extern BYTE * idstext3;
-extern BYTE * idstext4;
-extern BYTE * idstext5;
-extern BYTE * idstext6;
-extern BYTE * idstext7;
-extern BYTE * idstext8;
-extern BYTE * idstext9;
-extern BYTE * idstext10;
-extern BYTE * idstext11;
-extern BYTE * idstext12;
+extern uint8 * sunknown;
+extern uint8 * scya;
+extern uint8 * scamera;
+extern uint32 sunknownlen;
+extern uint32 scyalen;
+extern uint32 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 * 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 * 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;
#ifdef __cplusplus
}
#endif
+
+#endif // __RESOURCE_H__
// JLH 07/23/2009 Added changelog ;-)
//
-#define THUNDER_VERSION "0.5.0"
+#define THUNDER_VERSION "0.9.9"
#include <iostream>
#include <iomanip>
SDL_Surface * screen;
-BYTE * gram, * grom; // Allocate RAM & ROM pointers
-BYTE * gram1, * gram2, * grom1, * grom2; // Actual memory
-BYTE * grom3, * grom4, * data_rom, * spr_rom, * voice_rom;
-BYTE * chr_rom; // Character ROM pointer
+uint8 * gram, * grom; // Allocate RAM & ROM pointers
+uint8 * gram1, * gram2, * grom1, * grom2; // Actual memory
+uint8 * grom3, * grom4, * data_rom, * spr_rom, * voice_rom;
+uint8 * chr_rom; // Character ROM pointer
V6809REGS cpu1, cpu2;
bool trace1 = false; // ditto...
bool looking_at_rom = true; // true = R1, false = R2
-DWORD banksw1, banksw2; // Bank switch addresses
-WORD game_over_switch; // Game over delay
-WORD dpc; // Debug pc reg...
+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
-WORD refresh_ = 0; // Crappy global screen stuff...
+uint16 refresh_ = 0; // Crappy global screen stuff...
bool refresh2 = true;
-DWORD psg_lens[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-BYTE * psg_adrs[16];
-DWORD voc_lens[32] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+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,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-BYTE * voc_adrs[32];
-DWORD fm_lens[14] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-BYTE * fm_adrs[14];
+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];
fstream tr; // Tracelog hook
-WORD pcx; // Where we at?
+uint16 pcx; // Where we at?
static char op_mat1[256] = {
1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,
//
// Read a byte from memory (without touching PC. Not a Fetch!)
//
-BYTE RdMem(WORD addr)
+uint8 RdMem(uint16 addr)
{
- BYTE b;
+ uint8 b;
if (addr < 0x8000)
{
//
// Write a byte to memory
//
-void WrMem(WORD addr, BYTE b)
+void WrMem(uint16 addr, uint8 b)
{
extern bool charbase; // Needed for screen. Extern it in it??
- //extern WORD sr, ur, xr, yr; // Needed for tracelog
- //extern WORD pcr;
+ //extern uint16 sr, ur, xr, yr; // Needed for tracelog
+ //extern uint16 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 << (WORD)gram1[0x4400+i] << " ";
+ // tr << hex << (uint16)gram1[0x4400+i] << " ";
//}
tr << endl;
}//*/
if (addr == 0x6400)
SpawnSound(GAMESOUND, gram1[0x6600], 1); // Do voice chan 2
if (addr == 0x6800)
- banksw1 = (DWORD)b << 13; // Set char data bankswitch base address
+ banksw1 = (uint32)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)
//
-BYTE RdMemB(WORD addr)
+uint8 RdMemB(uint16 addr)
{
-// extern WORD cpu2.s, cpu2.u, cpu2.x, cpu2.y; // Needed for tracelog
- BYTE b;
+// extern uint16 cpu2.s, cpu2.u, cpu2.x, cpu2.y; // Needed for tracelog
+ uint8 b;
if (addr < 0x8000)
{
//
// Write a byte to memory (2nd processor)
//
-void WrMemB(WORD addr, BYTE b)
+void WrMemB(uint16 addr, uint8 b)
{
extern bool charbase;
- //extern WORD sr, ur, xr, yr; // Needed for tracelog
- //extern WORD pcr;
+ //extern uint16 sr, ur, xr, yr; // Needed for tracelog
+ //extern uint16 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 << (WORD)gram1[0x4400+i] << " ";
+ // tr << hex << (uint16)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 = (DWORD)(b & 0x03) << 13; // Set sprite data bank switch
+ banksw2 = (uint32)(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(WORD src, unsigned long dst)
+void DisplayBytes(uint16 src, unsigned long dst)
{
- BYTE cnt;
+ uint8 cnt;
unsigned long i;
printf("%04X: ", src);
if (src > dst) dst += 0x10000; // That should fix the FFFF bug...
for(i=src; i<dst; i++)
{
- printf("%02X ", (BYTE)(looking_at_rom ? RdMem(i) : RdMemB(i)));
+ printf("%02X ", (uint8)(looking_at_rom ? RdMem(i) : RdMemB(i)));
cnt++; // Bump counter...
}
for(i=cnt; i<5; i++) // Pad the leftover spaces...
}
// temp crap...
-BYTE Fetch(void) { return 0; }
-WORD FetchW(void) { return 0; }
-BYTE FetchB(void) { return 0; }
-WORD FetchWB(void) { return 0; }
+uint8 Fetch(void) { return 0; }
+uint16 FetchW(void) { return 0; }
+uint8 FetchB(void) { return 0; }
+uint16 FetchWB(void) { return 0; }
//
// Decode a 6809 instruction at 'addr'
//
void Decode_6809()
{
- BYTE (* DFetch)(); // Decode Fetch() pointer...
- WORD (* DFetchW)(); // Decode FetchW() pointer...
+ uint8 (* DFetch)(); // Decode Fetch() pointer...
+ uint16 (* DFetchW)(); // Decode FetchW() pointer...
DFetch = (looking_at_rom ? Fetch : FetchB);
DFetchW = (looking_at_rom ? FetchW : FetchWB);
-/* extern*/ WORD pcr, pcrB; // Pull in 'pcr' from '6809.cpp'
- WORD pc_save = pcr, pcB_save = pcrB;
+/* extern*/ uint16 pcr, pcrB; // Pull in 'pcr' from '6809.cpp'
+ uint16 pc_save = pcr, pcB_save = pcrB;
pcr = dpc; pcrB = dpc;
- BYTE opcode = DFetch(); // Get the opcode ('fetch' cycle)
- BYTE opcode2, operand;
- WORD loperand;
- BYTE admode = op_mat1[opcode]; // addressing mode
+ 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
break; }
case 3: // Relative
{ operand = DFetch(); // Get offset
- WORD tmpc = (looking_at_rom ? pcr : pcrB);
- sprintf(outbuf, "%s $%04X", mnem, tmpc+(SWORD)(SBYTE)operand);
+ 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
- WORD tmpc = (looking_at_rom ? pcr : pcrB);
- sprintf(outbuf, "%s $%04X", mnem, tmpc+(SWORD)loperand);
+ 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 7: // Indexed (the tough one!)
{ operand = DFetch(); // Get IDX byte
- BYTE reg = ((operand & 0x60) >> 5), idxind = ((operand & 0x10) >> 4),
+ uint8 reg = ((operand & 0x60) >> 5), idxind = ((operand & 0x10) >> 4),
lo_nyb = (operand & 0x0F), boff;
- WORD woff;
+ uint16 woff;
strcpy(tmp, "??");
if (!(operand & 0x80)) // Hi bit set? Then decode 4 bit offset
//
// Convert hex to dec
//
-WORD htod(char *str)
+uint16 htod(char *str)
{
- WORD value = 0;
+ uint16 value = 0;
int len = strlen(str);
for(int i=0; i<len; i++)
//
// Load 32K file into ROM image space
//
-bool Load32KImg(char * filename, WORD address)
+bool Load32KImg(char * filename, uint16 address)
{
ifstream ff;
char ch;
// Generic Load file into image space
// (No error checking performed! Responsibility of caller!)
//
-bool LoadImg(const char * filename, BYTE * mem, DWORD address, DWORD length)
+bool LoadImg(const char * filename, uint8 * mem, uint32 address, uint32 length)
{
ifstream ff;
char path[80];
ff.open(path, ios::binary | ios::in); // Open 'da file...
if (ff)
{
- for(DWORD i=0; i<length; i++) // Read it in...
+ for(uint32 i=0; i<length; i++) // Read it in...
{
ff.get(ch);
mem[address+i] = ch;
bool ReadColorPROMs(void)
{
fstream ff1, ff2;
-// BYTE ch;
+// uint8 ch;
char ch;
- extern BYTE palette[768]; // Screen physical palette
- extern BYTE ccolor[256][8]; // Character color PROM values
- extern BYTE scolor[128][16]; // Sprite color PROM values
+ 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 j=0; j<8; j++)
{
ff1.get(ch);
- ccolor[i][j] = (BYTE)ch;
+ ccolor[i][j] = (uint8)ch;
}
}
ff1.close();
for(int j=0; j<16; j++)
{
ff1.get(ch);
- scolor[i][j] = (BYTE)ch;
+ scolor[i][j] = (uint8)ch;
}
}
ff1.close();
for(int i=0; i<768; i+=3)
{
ff1.get(ch);
- palette[i] = (BYTE)(ch&0x0F);
- palette[i+1] = (BYTE)(ch>>4);
+ palette[i] = (uint8)(ch&0x0F);
+ palette[i+1] = (uint8)(ch>>4);
ff2.get(ch);
- palette[i+2] = (BYTE)ch;
+ palette[i+2] = (uint8)ch;
}
// Do palette stretching here... I.e. add 0 to hinyb 0, 1 to hinyb 1, etc.
//
bool UnpackFonts(void)
{
-// BYTE b1, b2, b3;
+// uint8 b1, b2, b3;
char b1, b2, b3;
fstream f1, f2;
//0x4000 $800 chars
//
// Get length of sample from WAV format
//
-DWORD GetWAVLength(fstream &file)
+uint32 GetWAVLength(fstream &file)
{
char ch;
- DWORD len;
+ uint32 len;
file.ignore(16); // Skip header BS
for(int i=0; i<2; i++)
{
- file.get(ch); len = (int)(BYTE)ch;
- file.get(ch); len |= (int)(BYTE)ch << 8;
- file.get(ch); len |= (int)(BYTE)ch << 16;
- file.get(ch); len |= (int)(BYTE)ch << 24;
+ 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.ignore(len + 4); // Skip intermediate data
}
- file.get(ch); len = (int)(BYTE)ch; // & finally get length of data
- file.get(ch); len |= (int)(BYTE)ch << 8;
- file.get(ch); len |= (int)(BYTE)ch << 16;
- file.get(ch); len |= (int)(BYTE)ch << 24;
+ 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;
return len;
}
{
char file[40];
char ch;
- DWORD len;
+ uint32 len;
for(int i=0; i<16; i++)
{
{
len = GetWAVLength(fp); // Get WAV data length...
- psg_adrs[i] = new BYTE[len]; // Attempt to allocate space...
+ psg_adrs[i] = new uint8[len]; // Attempt to allocate space...
if (psg_adrs[i] != NULL)
{
{
char file[200];
char ch;
- DWORD len;
+ uint32 len;
for(int i=0; i<14; i++)
{
{
len = GetWAVLength(fp); // Get WAV length...
- fm_adrs[i] = new BYTE[len]; // Attempt to allocate space...
+ fm_adrs[i] = new uint8[len]; // Attempt to allocate space...
if (fm_adrs[i] != NULL)
{
{
InitLog("thunder.log");
-/* extern WORD cpu1.pc, cpu1.s, cpu1.u, cpu1.x, cpu1.y; // Pull in vars from '6809.cpp'
- extern BYTE cpu1.a, cpu1.b, cpu1.cc, cpu1.dp;
+/* extern uint16 cpu1.pc, cpu1.s, cpu1.u, cpu1.x, cpu1.y; // Pull in vars from '6809.cpp'
+ extern uint8 cpu1.a, cpu1.b, cpu1.cc, cpu1.dp;
extern long iclock;
extern bool illegal;
- extern WORD cpu2.pc, cpu2.s, cpu2.u, cpu2.x, cpu2.y; // Pull in vars from '6809B.cpp'
- extern BYTE cpu2.a, cpu2.b, cpu2.cc, cpu2.dp;
+ extern uint16 cpu2.pc, cpu2.s, cpu2.u, cpu2.x, cpu2.y; // Pull in vars from '6809B.cpp'
+ extern uint8 cpu2.a, cpu2.b, cpu2.cc, cpu2.dp;
extern long iclockB;
extern bool illegalB;
extern void (* exec_op0[256])(); // Array of page zero opcode functions...
char lbuff[80];
fstream ff; // Declare fstream without file hooks...
bool brk = false, brk2 = false; // Breakpoint set flag
- WORD brkpnt, brkpnt2; // Where the breakpoint is...
+ 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
- WORD debounce = 0; // Key de-bounce counter
- WORD fire_debounce = 0; // Fire button debounce counter
+ uint16 debounce = 0; // Key de-bounce counter
+ uint16 fire_debounce = 0; // Fire button debounce counter
// bool refresh2 = true; // Default to 60 Hz...
- BYTE x; // General placeholder...
+ uint8 x; // General placeholder...
bool active = true; // Program running flag
// SDL_Surface * screen = NULL; // SDL screen pointer
SDL_Event event; // SDL "event"
// int keyPressed; // SDL key pressed...
- BYTE keys[256]; // Keyboard "switch-like" buffer
- extern BYTE palette[768]; // Screen physical palette
- DWORD ticks, oldTicks;
+ uint8 keys[256]; // Keyboard "switch-like" buffer
+ extern uint8 palette[768]; // Screen physical palette
+ uint32 ticks, oldTicks;
// tr.open("exe.log", ios::binary | ios::out); // Tracelog
cout << "Allocating memory..." << endl;
//Does this anyway... set_new_handler(0); // Make 'new' return NULL on failure...
- gram1 = new BYTE[0x10000];
+ gram1 = new uint8[0x10000];
if (gram1 == NULL) { cout << "Could not allocate RAM space #1!" << endl
<< "Aborting!" << endl; return -1; }
- grom1 = new BYTE[0x10000];
+ grom1 = new uint8[0x10000];
if (grom1 == NULL) { cout << "Could not allocate ROM space #1!" << endl
<< "Aborting!" << endl; return -1; }
- gram2 = new BYTE[0x10000];
+ gram2 = new uint8[0x10000];
if (gram2 == NULL) { cout << "Could not allocate RAM space #2!" << endl
<< "Aborting!" << endl; return -1; }
- grom2 = new BYTE[0x10000];
+ grom2 = new uint8[0x10000];
if (grom2 == NULL) { cout << "Could not allocate ROM space #2!" << endl
<< "Aborting!" << endl; return -1; }
- chr_rom = new BYTE[0x60000];
+ chr_rom = new uint8[0x60000];
if (chr_rom == NULL) { cout << "Could not allocate character RAM!" << endl
<< "Aborting!" << endl; return -1; }
- grom3 = new BYTE[0x8000];
+ grom3 = new uint8[0x8000];
if (grom3 == NULL) { cout << "Could not allocate ROM space #4!" << endl
<< "Aborting!" << endl; return -1; }
- grom4 = new BYTE[0x8000];
+ grom4 = new uint8[0x8000];
if (grom4 == NULL) { cout << "Could not allocate ROM space #5!" << endl
<< "Aborting!" << endl; return -1; }
- data_rom = new BYTE[0x40000];
+ data_rom = new uint8[0x40000];
if (data_rom == NULL) { cout << "Could not allocate ROM level data!" << endl
<< "Aborting!" << endl; return -1; }
- spr_rom = new BYTE[0x80000];
+ spr_rom = new uint8[0x80000];
if (spr_rom == NULL) { cout << "Could not allocate ROM sprite data!" << endl
<< "Aborting!" << endl; return -1; }
- voice_rom = new BYTE[0x20000];
+ voice_rom = new uint8[0x20000];
if (voice_rom == NULL) { cout << "Could not allocate ROM voice data!" << endl
<< "Aborting!" << endl; return -1; }
LoadFMs();
// Quick 'n' Dirty voice dump (sound 0x0E)
-/* DWORD adc = (voice_rom[26]<<8) | voice_rom[27];
+/* uint32 adc = (voice_rom[26]<<8) | voice_rom[27];
bool doneWitIt = false;
int crh = 0;
while (!doneWitIt)
dpc = htod(lbuff);
}
printf("%04X: ", dpc);
- WORD pc_save = cpu1.pc, pcB_save = cpu2.pc;
+ uint16 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++)
{
- BYTE a = (looking_at_rom ? Fetch() : FetchB());
+ uint8 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 ", (BYTE)gram[dpc++]);
+ for(int i=0; i<16; i++) printf("%02X ", (uint8)gram[dpc++]);
cout << endl;
}
else if (lbuff[0] == 'l')
else if ((lbuff[0] == 'r') || (lbuff[0] == 'c')) // Run/continue...
{
WriteLog("Executing 'run' command...\n");
- DWORD my_clock = 0;
+ uint32 my_clock = 0;
running = true; // Set running status...
trace1 = false;
SetRefreshRate(refresh2); // Tell GUI our refresh rate
- //for(WORD i=0; i<0x8000; i++) gram2[i] = grom3[i]; //Temp
+ //for(uint16 i=0; i<0x8000; i++) gram2[i] = grom3[i]; //Temp
if (lbuff[0] == 'r') // If run, then reset CPUs
{
}
if (keys[28]) // Return
{
- BYTE retval = UserSelectedSomething();
+ uint8 retval = UserSelectedSomething();
if (retval == EXIT)
running = false;
if (retval == REFRESH)
printf("%04X: ", dpc); // Show data found...
for(int i=0; i<16; i++)
- printf("%02X ", gram1[(WORD)(dpc+i)]);
+ printf("%02X ", gram1[(uint16)(dpc+i)]);
cout << " ";
for(int i=0; i<16; i++)
{
- BYTE a = gram1[dpc++];
+ uint8 a = gram1[dpc++];
if (a<10)
cout << (char)(a+48);
if ((a>9) && (a<37))
//
// 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__
-// This is only good on certain intel 32-bit platforms...
-// You may need to tweak to suit your specific platform.
-
-typedef unsigned char uint8;
-typedef signed char int8;
-typedef unsigned short uint16;
-typedef signed short int16;
-typedef unsigned uint32;
-typedef signed int32;
-typedef unsigned long long uint64;
-typedef signed long long int64;
-
-typedef uint8 UINT8;
-typedef int8 INT8;
-typedef uint16 UINT16;
-typedef int16 INT16;
-typedef uint32 UINT32;
-typedef int32 INT32;
-typedef uint64 UINT64;
-typedef int64 INT64;
+#include <stdint.h>
-typedef uint8 BYTE;
-typedef uint16 WORD;
-//ugly, ugly kludge
-#ifndef __SDLEMU_OPENGL_H__
-typedef uint32 DWORD;
-#endif
-typedef int8 SBYTE;
-typedef int16 SWORD;
-typedef int32 SDWORD;
+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__
// Private global variables
static V6809REGS regs;
-static WORD addr; // Temporary variables common to all funcs...
-static BYTE tmp;
+static uint16 addr; // Temporary variables common to all funcs...
+static uint8 tmp;
// Private function prototypes
-static int SignedB(BYTE); // Return signed byte from unsigned
-static int SignedW(WORD); // Return signed word from unsigned
-static WORD FetchW(void);
-static WORD RdMemW(WORD addr);
-static void WrMemW(WORD addr, WORD w);
-static WORD ReadEXG(BYTE); // Read TFR/EXG post byte
-static void WriteEXG(BYTE, WORD); // Set TFR/EXG data
-static WORD DecodeReg(BYTE); // Decode register data
-static WORD DecodeIDX(BYTE); // Decode IDX data
+static int SignedB(uint8); // Return signed byte from unsigned
+static int SignedW(uint16); // Return signed word from unsigned
+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
// This is here because of the stupid forward declaration rule that C++ forces (the C++ compiler
// isn't smart enough to know that the identifiers in the arrays are declared later, it doesn't
// Fetch a word out of 6809 memory (little endian format)
// This is a leftover from when fetches were separated from garden variety reads...
//
-static WORD FetchW()
+static uint16 FetchW()
{
- WORD w = RdMemW(regs.pc);
+ uint16 w = RdMemW(regs.pc);
regs.pc += 2;
return w;
}
//
// Fetch word function
//
-/*WORD FetchW(void)
+/*uint16 FetchW(void)
{
- return (WORD)(regs.RdMem(regs.pc++) << 8) | regs.RdMem(regs.pc++);
+ return (uint16)(regs.RdMem(regs.pc++) << 8) | regs.RdMem(regs.pc++);
}*/
//
// Read word from memory function
//
-WORD RdMemW(WORD addr)
+uint16 RdMemW(uint16 addr)
{
- return (WORD)(regs.RdMem(addr) << 8) | regs.RdMem(addr + 1);
+ return (uint16)(regs.RdMem(addr) << 8) | regs.RdMem(addr + 1);
}
//
// Write word to memory function
//
-void WrMemW(WORD addr, WORD w)
+void WrMemW(uint16 addr, uint16 w)
{
regs.WrMem(addr + 0, w >> 8);
regs.WrMem(addr + 1, w & 0xFF);
//
// return signed byte from unsigned
//
-int SignedB(BYTE b)
+int SignedB(uint8 b)
{
return (b & 0x80 ? b - 256 : b);
}
//
// return signed word from unsigned
//
-int SignedW(WORD w)
+int SignedW(uint16 w)
{
return (w & 0x8000 ? w - 65536 : w);
}
//
// Function to read TFR/EXG post byte
//
-WORD ReadEXG(BYTE code)
+uint16 ReadEXG(uint8 code)
{
- WORD retval;
+ uint16 retval;
switch (code)
{
//
// Function to set TFR/EXG data
//
-void WriteEXG(BYTE code, WORD data)
+void WriteEXG(uint8 code, uint16 data)
{
switch (code)
{
//
// Function to decode register data
//
-WORD DecodeReg(BYTE reg)
+uint16 DecodeReg(uint8 reg)
{
- WORD retval;
+ uint16 retval;
switch (reg)
{
//
// Function to decode IDX data
//
-WORD DecodeIDX(BYTE code)
+uint16 DecodeIDX(uint8 code)
{
- WORD addr, woff;
- BYTE reg = (code & 0x60) >> 5, idxind = (code & 0x10) >> 4, lo_nyb = code & 0x0F;
+ uint16 addr, woff;
+ uint8 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);
}
static void Op06(void) // ROR DP
{
- addr = (regs.dp<<8) | regs.RdMem(regs.pc++); BYTE tmp2 = regs.RdMem(addr);
+ addr = (regs.dp<<8) | regs.RdMem(regs.pc++); uint8 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++); BYTE tmp2 = regs.RdMem(addr);
+ addr = (regs.dp<<8) | regs.RdMem(regs.pc++); uint8 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
{
tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++));
regs.cc &= 0xFD; // CLV
- (tmp == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
+ (tmp == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
+ (tmp&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
regs.clock += 6;
}
static void Op0E(void) // JMP DP
}
static void Op13(void) // SYNC
-{
+{
regs.clock += 2;
}
static void Op16(void) // LBRA
regs.a += 0x60; regs.cc |= 0x01; // Then adjust & set carry
}
regs.cc &= 0xF1; // CL NZV
- if (regs.a == 0) regs.cc |= 0x04; // Adjust Zero flag
+ if (regs.a == 0) regs.cc |= 0x04; // Adjust Zero flag
if (regs.a&0x80) regs.cc |= 0x08; // Adjust Negative flag
regs.clock += 2;
}
{
}
static void Op40(void) // NEGA
-{
+{
regs.a = 256 - regs.a;
(regs.a > 0x7F ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Adjust carry
(regs.a == 0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
(regs.a&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
regs.clock += 2;
}
-static void Op49(void) // ROLA
+static void Op49(void) // ROLA
{
tmp = regs.a; regs.a = (tmp<<1) + (regs.cc&0x01);
(tmp&0x80 ? regs.cc |= 0x01 : regs.cc &= 0xFE); // Shift hi bit into carry
regs.clock += 2;
}
static void Op50(void) // NEGB
- {
+ {
regs.b = 256 - regs.b;
// ((regs.b^tmp)&0x10 ? regs.cc |= 0x20 : regs.cc &= 0xDF); // Adjust H carry
(regs.b == 0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
static void Op5C(void) // INCB
{
regs.b++;
- (regs.b == 0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // Adjust oVerflow flag
+ (regs.b == 0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // Adjust oVerflow flag
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
regs.clock += 2;
regs.clock += 2;
}
static void Op60(void) // NEG IDX
- {
+ {
addr = DecodeIDX(regs.RdMem(regs.pc++));
- tmp = regs.RdMem(addr); BYTE res = 256 - tmp;
+ tmp = regs.RdMem(addr); uint8 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); BYTE tmp2 = tmp;
+ tmp = regs.RdMem(addr); uint8 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
{
- BYTE tmp2 = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
+ uint8 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
{
- BYTE tmp; WORD addr;
+ uint8 tmp; uint16 addr;
addr = DecodeIDX(regs.RdMem(regs.pc++));
tmp = regs.RdMem(addr) - 1;
regs.WrMem(addr, tmp);
regs.clock += 6;
}
static void Op6C(void) // INC IDX
- {
+ {
addr = DecodeIDX(regs.RdMem(regs.pc++));
tmp = regs.RdMem(addr) + 1;
regs.WrMem(addr, tmp);
static void Op6D(void) // TST IDX
{
tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
- (tmp == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
+ (tmp == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
+ (tmp&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
regs.clock += 6;
}
static void Op6E(void) // JMP IDX
regs.clock += 6;
}
static void Op70(void) // NEG ABS
- {
+ {
addr = FetchW();
- tmp = regs.RdMem(addr); BYTE res = 256 - tmp;
+ tmp = regs.RdMem(addr); uint8 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
{
- BYTE tmp; WORD addr;
+ uint8 tmp; uint16 addr;
addr = FetchW();
- tmp = regs.RdMem(addr); BYTE tmp2 = tmp;
+ tmp = regs.RdMem(addr); uint8 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
{
- BYTE tmp; WORD addr;
+ uint8 tmp; uint16 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
{
- BYTE tmp; WORD addr;
+ uint8 tmp; uint16 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
{
- BYTE tmp2 = regs.RdMem(FetchW());
+ uint8 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
{
- BYTE tmp; WORD addr;
+ uint8 tmp; uint16 addr;
addr = FetchW();
tmp = regs.RdMem(addr) - 1;
regs.WrMem(addr, tmp);
regs.clock += 7;
}
static void Op7C(void) // INC ABS
- {
- BYTE tmp; WORD addr;
+ {
+ uint8 tmp; uint16 addr;
addr = FetchW();
tmp = regs.RdMem(addr) + 1;
regs.WrMem(addr, tmp);
static void Op7D(void) // TST ABS
{
- BYTE tmp = regs.RdMem(FetchW());
+ uint8 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
+ (tmp == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
+ (tmp&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
regs.clock += 7;
}
regs.clock += 7;
}
static void Op80(void) // SUBA #
-{
- BYTE tmp = regs.RdMem(regs.pc++); BYTE as = regs.a;
+{
+ uint8 tmp = regs.RdMem(regs.pc++); uint8 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++);
- BYTE db = regs.a - tmp;
+ uint8 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++); BYTE as = regs.a;
+ tmp = regs.RdMem(regs.pc++); uint8 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(); WORD dr = (regs.a<<8)|regs.b, ds = dr;
+ addr = FetchW(); uint16 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 = (WORD)regs.a + (WORD)tmp + (WORD)(regs.cc&0x01);
+ addr = (uint16)regs.a + (uint16)tmp + (uint16)(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
+ ((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
regs.a = addr & 0xFF; // Set accumulator
(regs.a == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero
(regs.a&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative
regs.clock += 2;
}
static void Op8B(void) // ADDA #
-{
+{
tmp = regs.RdMem(regs.pc++); addr = regs.a + tmp;
(addr > 0xFF ? 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
+ ((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
regs.a = addr & 0xFF; // Set accumulator
(regs.a == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.a&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
static void Op8C(void) // CMPX #
{
addr = FetchW();
- WORD dw = regs.x - addr;
+ uint16 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
regs.clock += 3;
}
static void Op90(void) // SUBA DP
- {
- tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); BYTE as = regs.a;
+ {
+ tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8 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++));
- BYTE db = regs.a - tmp;
+ uint8 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++)); BYTE as = regs.a;
+ tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8 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++); WORD dr = (regs.a<<8)|regs.b, ds = dr;
- WORD adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ 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);
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 = (WORD)regs.a + (WORD)tmp + (WORD)(regs.cc&0x01);
+ addr = (uint16)regs.a + (uint16)tmp + (uint16)(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
+ ((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
regs.a = addr & 0xFF; // Set accumulator
(regs.a == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero
(regs.a&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative
regs.clock += 4;
}
static void Op9B(void) // ADDA DP
-{
+{
tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++));
- addr = (WORD)regs.a + (WORD)tmp;
+ addr = (uint16)regs.a + (uint16)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
+ ((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
regs.a = addr & 0xFF; // Set accumulator
(regs.a == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.a&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
static void Op9C(void) // CMPX DP
{
addr = (regs.dp<<8)|regs.RdMem(regs.pc++);
- WORD adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- WORD dw = regs.x - adr2;
+ uint16 adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16 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
regs.clock += 5;
}
static void OpA0(void) // SUBA IDX
- {
- tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); BYTE as = regs.a;
+ {
+ tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8 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++)));
- BYTE db = regs.a - tmp;
+ uint8 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++))); BYTE as = regs.a;
+ tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8 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++)); WORD dr = (regs.a<<8)|regs.b, ds = dr;
- WORD adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ 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);
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 = (WORD)regs.a + (WORD)tmp + (WORD)(regs.cc&0x01);
+ addr = (uint16)regs.a + (uint16)tmp + (uint16)(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
+ ((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
regs.a = addr & 0xFF; // Set accumulator
(regs.a == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.a&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
regs.clock += 4;
}
static void OpAB(void) // ADDA IDX
-{
+{
tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
- addr = (WORD)regs.a + (WORD)tmp;
+ addr = (uint16)regs.a + (uint16)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
+ ((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
regs.a = addr & 0xFF; // Set accumulator
(regs.a == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.a&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
static void OpAC(void) // CMPX IDX
{
addr = DecodeIDX(regs.RdMem(regs.pc++));
- WORD addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- WORD dw = regs.x - addr2;
+ uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16 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
regs.clock += 5;
}
static void OpB0(void) // SUBA ABS
- {
- tmp = regs.RdMem(FetchW()); BYTE as = regs.a;
+ {
+ tmp = regs.RdMem(FetchW()); uint8 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());
- BYTE db = regs.a - tmp;
+ uint8 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()); BYTE as = regs.a;
+ tmp = regs.RdMem(FetchW()); uint8 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(); WORD dr = (regs.a<<8)|regs.b, ds = dr;
- WORD adr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ addr = FetchW(); uint16 dr = (regs.a<<8)|regs.b, ds = dr;
+ uint16 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 = (WORD)regs.a + (WORD)tmp + (WORD)(regs.cc&0x01);
+ addr = (uint16)regs.a + (uint16)tmp + (uint16)(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
+ ((regs.a^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
regs.a = addr; // Set accumulator
(regs.a == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.a&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
regs.clock += 5;
}
static void OpBB(void) // ADDA ABS
-{
+{
tmp = regs.RdMem(FetchW());
- addr = (WORD)regs.a + (WORD)tmp;
+ addr = (uint16)regs.a + (uint16)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(); WORD addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- WORD dw = regs.x - addr2;
+ addr = FetchW(); uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16 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
{
addr = FetchW();
regs.WrMem(--regs.s, regs.pc&0xFF); regs.WrMem(--regs.s, regs.pc>>8);
- regs.pc = addr; // Go to absolute address (Not indir)
+ regs.pc = addr; // Go to absolute address (Not indir)
regs.clock += 8;
}
}
static void OpC0(void) // SUBB #
- {
- tmp = regs.RdMem(regs.pc++); BYTE bs = regs.b;
+ {
+ tmp = regs.RdMem(regs.pc++); uint8 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++);
- BYTE db = regs.b - tmp;
+ uint8 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++); BYTE bs = regs.b;
+ tmp = regs.RdMem(regs.pc++); uint8 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 = (WORD)regs.b + (WORD)tmp + (WORD)(regs.cc&0x01);
+ addr = (uint16)regs.b + (uint16)tmp + (uint16)(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
+ ((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
regs.b = addr & 0xFF; // Set accumulator
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
regs.clock += 2;
}
static void OpCB(void) // ADDB #
-{
+{
tmp = regs.RdMem(regs.pc++); addr = regs.b + tmp;
(addr > 0xFF ? 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
+ ((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
regs.b = addr & 0xFF; // Set accumulator
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
regs.clock += 3;
}
static void OpD0(void) // SUBB DP
-{
- tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); BYTE bs = regs.b;
+{
+ tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8 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++));
- BYTE db = regs.b - tmp;
+ uint8 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++)); BYTE bs = regs.b;
+ tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++)); uint8 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;
- WORD adr2 = (regs.RdMem(addr)<<8)|regs.RdMem(addr+1);
+ uint16 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 = (WORD)regs.b + (WORD)tmp + (WORD)(regs.cc&0x01);
+ addr = (uint16)regs.b + (uint16)tmp + (uint16)(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
+ ((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
regs.b = addr; // Set accumulator
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
regs.clock += 4;
}
static void OpDB(void) // ADDB DP
-{
+{
tmp = regs.RdMem((regs.dp<<8)|regs.RdMem(regs.pc++));
- addr = (WORD)regs.b + (WORD)tmp;
+ addr = (uint16)regs.b + (uint16)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
+ ((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
regs.b = addr & 0xFF; // Set accumulator
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
regs.clock += 5;
}
static void OpE0(void) // SUBB IDX
-{
- tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); BYTE bs = regs.b;
+{
+ tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8 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++)));
- BYTE db = regs.b - tmp;
+ uint8 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++))); BYTE bs = regs.b;
+ tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++))); uint8 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;
- WORD adr2 = (regs.RdMem(addr)<<8)|regs.RdMem(addr+1);
+ uint16 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 = (WORD)regs.b + (WORD)tmp + (WORD)(regs.cc&0x01);
+ addr = (uint16)regs.b + (uint16)tmp + (uint16)(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
+ ((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
regs.b = addr; // Set accumulator
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
regs.clock += 4;
}
static void OpEB(void) // ADDB IDX
-{
+{
tmp = regs.RdMem(DecodeIDX(regs.RdMem(regs.pc++)));
- addr = (WORD)regs.b + (WORD)tmp;
+ addr = (uint16)regs.b + (uint16)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
+ ((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflow
regs.b = addr; // Set accumulator
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
regs.clock += 5;
}
static void OpF0(void) // SUBB ABS
- {
- tmp = regs.RdMem(FetchW()); BYTE bs = regs.b;
+ {
+ tmp = regs.RdMem(FetchW()); uint8 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());
- BYTE db = regs.b - tmp;
+ uint8 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()); BYTE bs = regs.b;
+ tmp = regs.RdMem(FetchW()); uint8 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;
- WORD adr2 = (regs.RdMem(addr)<<8)|regs.RdMem(addr+1);
+ uint16 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 = (WORD)regs.b + (WORD)tmp + (WORD)(regs.cc&0x01);
+ addr = (uint16)regs.b + (uint16)tmp + (uint16)(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
+ ((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
regs.b = addr & 0xFF; // Set accumulator
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
regs.clock += 5;
- }
+ }
static void OpFB(void) // ADDB ABS
-{
+{
tmp = regs.RdMem(FetchW());
- addr = (WORD)regs.b + (WORD)tmp;
+ addr = (uint16)regs.b + (uint16)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
+ ((regs.b^tmp^addr^(regs.cc<<7))&0x80 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerflo
regs.b = addr & 0xFF; // Set accumulator
(regs.b == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Set Zero flag
(regs.b&0x80 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Set Negative flag
}
static void Op1083(void) // CMPD #
{
- addr = FetchW(); WORD dr = (regs.a<<8)|regs.b;
- WORD dw = dr - addr;
+ addr = FetchW(); uint16 dr = (regs.a<<8)|regs.b;
+ uint16 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^((WORD)regs.cc<<15))&0x8000 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerfl
+ ((dr^addr^dw^((uint16)regs.cc<<15))&0x8000 ? regs.cc |= 0x02 : regs.cc &= 0xFD); // oVerfl
regs.clock += 5;
}
static void Op108C(void) // CMPY #
{
addr = FetchW();
- WORD dw = regs.y - addr;
+ uint16 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
{
- WORD adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++), dr = (regs.a<<8)|regs.b;
+ uint16 adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++), dr = (regs.a<<8)|regs.b;
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- WORD dw = dr - addr;
+ uint16 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
{
- WORD adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
+ uint16 adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- WORD dw = regs.y - addr;
+ uint16 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
{
- WORD adr2 = DecodeIDX(regs.RdMem(regs.pc++)), dr = (regs.a<<8)|regs.b;
+ uint16 adr2 = DecodeIDX(regs.RdMem(regs.pc++)), dr = (regs.a<<8)|regs.b;
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- WORD dw = dr - addr;
+ uint16 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
{
- WORD adr2 = DecodeIDX(regs.RdMem(regs.pc++));
+ uint16 adr2 = DecodeIDX(regs.RdMem(regs.pc++));
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- WORD dw = regs.y - addr;
+ uint16 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(); WORD dr = (regs.a<<8)|regs.b;
- WORD addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- WORD dw = dr - addr2;
+ addr = FetchW(); uint16 dr = (regs.a<<8)|regs.b;
+ uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16 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(); WORD addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- WORD dw = regs.y - addr2;
+ addr = FetchW(); uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16 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
regs.cc &= 0xFD; // CLV
(regs.s == 0 ? regs.cc |= 0x04 : regs.cc &= 0xFB); // Adjust Zero flag
(regs.s&0x8000 ? regs.cc |= 0x08 : regs.cc &= 0xF7); // Adjust Negative flag
- regs.clock += 6;
+ regs.clock += 6;
}
static void Op10DF(void) // STS DP
{
static void Op1183(void) // CMPU #
{
addr = FetchW();
- WORD dw = regs.u - addr;
+ uint16 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();
- WORD dw = regs.s - addr;
+ uint16 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
{
- WORD adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
+ uint16 adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- WORD dw = regs.u - addr;
+ uint16 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
{
- WORD adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
+ uint16 adr2 = (regs.dp<<8)|regs.RdMem(regs.pc++);
addr = (regs.RdMem(adr2)<<8) | regs.RdMem(adr2+1);
- WORD dw = regs.s - addr;
+ uint16 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
{
- WORD addr2 = DecodeIDX(regs.RdMem(regs.pc++));
+ uint16 addr2 = DecodeIDX(regs.RdMem(regs.pc++));
addr = (regs.RdMem(addr2)<<8) | regs.RdMem(addr2+1);
- WORD dw = regs.u - addr;
+ uint16 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
{
- WORD addr2 = DecodeIDX(regs.RdMem(regs.pc++));
+ uint16 addr2 = DecodeIDX(regs.RdMem(regs.pc++));
addr = (regs.RdMem(addr2)<<8) | regs.RdMem(addr2+1);
- WORD dw = regs.s - addr;
+ uint16 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(); WORD addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- WORD dw = regs.u - addr2;
+ addr = FetchW(); uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16 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(); WORD addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
- WORD dw = regs.s - addr2;
+ addr = FetchW(); uint16 addr2 = (regs.RdMem(addr)<<8) | regs.RdMem(addr+1);
+ uint16 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...
-/*static BYTE backTrace[256];
-static WORD btPC[256];
+/*static uint8 backTrace[256];
+static uint16 btPC[256];
static int btPtr = 0;//*/
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, DWORD size)
+static void myMemcpy(void * dst, void * src, uint32 size)
{
- BYTE * d = (BYTE *)dst, * s = (BYTE *)src;
+ uint8 * d = (uint8 *)dst, * s = (uint8 *)src;
- for(DWORD i=0; i<size; i++)
+ for(uint32 i=0; i<size; i++)
d[i] = s[i];
}
//
// Function to execute 6809 instructions
//
-void Execute6809(V6809REGS * context, DWORD cycles)
+void Execute6809(V6809REGS * context, uint32 cycles)
{
myMemcpy(®s, context, sizeof(V6809REGS));
// Execute here...
-DWORD clockSave = regs.clock;
+uint32 clockSave = regs.clock;
regs.clock = 0;
while (regs.clock < cycles)
{
// Handle any pending interrupts
- DWORD flags = context->cpuFlags;
+ uint32 flags = context->cpuFlags;
if (flags & V6809_ASSERT_LINE_RESET) // *** RESET handler ***
{
struct V6809REGS
{
- WORD pc; // 6809 PC register
- WORD x; // 6809 X index register
- WORD y; // 6809 Y index register
- WORD s; // 6809 System stack pointer
- WORD u; // 6809 User stack pointer
- BYTE cc; // 6809 Condition Code register
- BYTE a; // 6809 A register
- BYTE b; // 6809 B register
- BYTE dp; // 6809 Direct Page register
- DWORD clock; // 6809 clock
-//DWORD _reserved;// BYTE (* Fetch)(WORD&); // Address of BYTE fetch routine
- BYTE (* RdMem)(WORD); // Address of BYTE read routine
- void (* WrMem)(WORD, BYTE); // Address of BYTE write routine
- DWORD cpuFlags; // v6809 IRQ/RESET flags
+ 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
+//uint32 _reserved;// uint8 (* Fetch)(uint16&); // Address of uint8 fetch routine
+ uint8 (* RdMem)(uint16); // Address of uint8 read routine
+ void (* WrMem)(uint16, uint8); // Address of uint8 write routine
+ uint32 cpuFlags; // v6809 IRQ/RESET flags
};
// Function prototypes
-void Execute6809(V6809REGS *, DWORD); // Function to execute 6809 instructions
+void Execute6809(V6809REGS *, uint32); // Function to execute 6809 instructions
#endif // __V6809_H__
+++ /dev/null
-// Virtual 6809B v1.2P (Last build: 5/30/1998)
-// Protected mode version
-//
-// by James L. Hammons
-//
-// (c) 1998 Underground Software
-
-#include "v6809b.h"
-#include "v6809.h" // Pull in some funcs...
-
-// Global defs (needed because functions can only return one value.
-// Maybe you could use a struct to pass multiple values, but
-// what a pain in the ass! This way makes a little more sense
-// to me.)
-
-WORD pcrB, xrB, yrB, srB, urB; // Double byte registers
-BYTE ccrB, arB, brB, dprB; // Single byte registers
-long iclockB; // Instruction clock
-bool illegalB = false; // Illegal instruction executed flag
-
-static WORD addr; // Temporary variables common to all funcs...
-static BYTE tmp;
-
-extern BYTE FetchB(); // You need to define these functions
-extern WORD FetchWB(); // externally because every hardware situation
-extern BYTE RdMemB(WORD); // is going to be different...
-extern void WrMemB(WORD, BYTE);
-
-void (* exec_op0B[256])(); // Array of page zero opcode functions...
-void (* exec_op1B[256])(); // Array of page one opcode functions...
-void (* exec_op2B[256])(); // Array of page two opcode functions...
-
-//
-// Function to read TFR/EXG post byte
-//
-WORD ReadEXGB(BYTE code)
-{
- WORD retval;
-
- switch(code)
- {
- case 0: retval = (arB<<8) | brB; break;
- case 1: retval = xrB; break;
- case 2: retval = yrB; break;
- case 3: retval = urB; break;
- case 4: retval = srB; break;
- case 5: retval = pcrB; break;
- case 8: retval = arB; break;
- case 9: retval = brB; break;
- case 10: retval = ccrB; break;
- case 11: retval = dprB; break;
- default: retval = 0xFF;
- }
- return(retval);
-}
-
-//
-// Function to set TFR/EXG data
-//
-void WriteEXGB(BYTE code, WORD data)
-{
- switch(code)
- {
- case 0: { arB = data>>8; brB = data&0xFF; break; }
- case 1: xrB = data; break;
- case 2: yrB = data; break;
- case 3: urB = data; break;
- case 4: srB = data; break;
- case 5: pcrB = data; break;
- case 8: arB = data&0xFF; break;
- case 9: brB = data&0xFF; break;
- case 10: ccrB = data&0xFF; break;
- case 11: dprB = data&0xFF; break;
- }
-}
-
-//
-// Function to decode register data
-//
-WORD DecodeRegB(BYTE reg)
-{
- WORD retval;
-
- switch(reg)
- {
- case 0: retval = xrB; break;
- case 1: retval = yrB; break;
- case 2: retval = urB; break;
- case 3: retval = srB; break;
- }
- return(retval);
-}
-
-//
-// Function to decode IDX data
-//
-WORD DecodeIDXB(BYTE code)
-{
- WORD addr, woff;
- BYTE reg = (code&0x60)>>5, idxind = (code&0x10)>>4, lo_nyb = code&0x0F;
-
- if (!(code&0x80)) // Hi bit unset? Then decode 4 bit offset
- {
- addr = DecodeRegB(reg) + (idxind ? lo_nyb-16 : lo_nyb);
- }
- else
- {
- if (idxind)
- {
- switch(lo_nyb)
- {
- case 1: { woff = DecodeRegB(reg);
- addr = (RdMemB(woff)<<8) | RdMemB(woff+1);
- switch(reg)
- {
- case 0: xrB++; xrB++; break;
- case 1: yrB++; yrB++; break;
- case 2: urB++; urB++; break;
- case 3: srB++; srB++; break;
- }
- break; }
- case 3: { switch(reg)
- {
- case 0: xrB--; xrB--; break;
- case 1: yrB--; yrB--; break;
- case 2: urB--; urB--; break;
- case 3: srB--; srB--; break;
- }
- woff = DecodeRegB(reg);
- addr = (RdMemB(woff)<<8) | RdMemB(woff+1); break; }
- case 4: { woff = DecodeRegB(reg);
- addr = (RdMemB(woff)<<8) | RdMemB(woff+1); break; }
- case 5: { woff = DecodeRegB(reg) + SignedB(brB);
- addr = (RdMemB(woff)<<8) | RdMemB(woff+1); break; }
- case 6: { woff = DecodeRegB(reg) + SignedB(arB);
- addr = (RdMemB(woff)<<8) | RdMemB(woff+1); break; }
- case 8: { woff = DecodeRegB(reg) + SignedB(FetchB());
- addr = (RdMemB(woff)<<8) | RdMemB(woff+1); break; }
- case 9: { woff = DecodeRegB(reg) + SignedW(FetchWB());
- addr = (RdMemB(woff)<<8) | RdMemB(woff+1); break; }
- case 11: { woff = DecodeRegB(reg) + SignedW((arB<<8) | brB);
- addr = (RdMemB(woff)<<8) | RdMemB(woff+1); break; }
- case 12: { woff = pcrB + SignedB(FetchB());
- addr = (RdMemB(woff)<<8) | RdMemB(woff+1); break; }
- case 13: { woff = pcrB + SignedW(FetchWB());
- addr = (RdMemB(woff)<<8) | RdMemB(woff+1); break; }
- case 15: { woff = FetchWB();
- addr = (RdMemB(woff)<<8) | RdMemB(woff+1); break; }
- }
- }
- else
- {
- switch(lo_nyb)
- {
- case 0: { addr = DecodeRegB(reg);
- switch(reg)
- {
- case 0: xrB++; break;
- case 1: yrB++; break;
- case 2: urB++; break;
- case 3: srB++; break;
- }
- break; }
- case 1: { addr = DecodeRegB(reg);
- switch(reg)
- {
- case 0: xrB++; xrB++; break;
- case 1: yrB++; yrB++; break;
- case 2: urB++; urB++; break;
- case 3: srB++; srB++; break;
- }
- break; }
- case 2: { switch(reg)
- {
- case 0: xrB--; break;
- case 1: yrB--; break;
- case 2: urB--; break;
- case 3: srB--; break;
- }
- addr = DecodeRegB(reg); break; }
- case 3: { switch(reg)
- {
- case 0: xrB--; xrB--; break;
- case 1: yrB--; yrB--; break;
- case 2: urB--; urB--; break;
- case 3: srB--; srB--; break;
- }
- addr = DecodeRegB(reg); break; }
- case 4: { addr = DecodeRegB(reg); break; }
- case 5: { addr = DecodeRegB(reg) + SignedB(brB); break; }
- case 6: { addr = DecodeRegB(reg) + SignedB(arB); break; }
- case 8: { addr = DecodeRegB(reg) + SignedB(FetchB()); break; }
- case 9: { addr = DecodeRegB(reg) + SignedW(FetchWB()); break; }
- case 11: { addr = DecodeRegB(reg) + SignedW((arB<<8) | brB); break; }
- case 12: { addr = pcrB + SignedB(FetchB()); break; }
- case 13: { addr = pcrB + SignedW(FetchWB()); break; }
- }
- }
- }
- return(addr);
-}
-
-//
-// Page zero instructions...
-//
-
-void BOp00(void) // NEG DP
-{
- addr = (dprB<<8) | FetchB();
- tmp = 256 - RdMemB(addr);
- WrMemB(addr, tmp);
- (tmp == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (tmp > 0x7F ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust carry
- iclockB += 6;
-}
-void BOp03(void) // COM DP
-{
- addr = (dprB<<8) | FetchB();
- tmp = 0xFF ^ RdMemB(addr);
- WrMemB(addr, tmp);
- ccrB &= 0xFD; ccrB |= 0x01; // CLV SEC
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
-}
-void BOp04(void) // LSR DP
-{
- addr = (dprB<<8) | FetchB();
- tmp = RdMemB(addr);
- (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift low bit into carry
- tmp >>= 1; WrMemB(addr, tmp);
- ccrB &= 0xF7; // CLN
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- iclockB += 6;
-}
-void BOp06(void) // ROR DP
-{
- addr = (dprB<<8) | FetchB(); BYTE tmp2 = RdMemB(addr);
- tmp = (tmp2>>1) + (ccrB&0x01)*128;
- WrMemB(addr, tmp);
- (tmp2&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
-}
-void BOp07(void) // ASR DP
-{
- addr = (dprB<<8) | FetchB(); tmp = RdMemB(addr);
- (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
- tmp >>= 1;
- if (tmp&0x40) tmp |= 0x80; // Set Neg if it was set
- WrMemB(addr, tmp);
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
-}
-void BOp08(void) // LSL DP
-{
- addr = (dprB<<8) | FetchB(); // NEEDS OVERFLOW ADJUSTMENT
- tmp = RdMemB(addr);
- (tmp&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
- tmp <<= 1;
- WrMemB(addr, tmp);
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
-}
-void BOp09(void) // ROL DP
-{
- addr = (dprB<<8) | FetchB(); BYTE tmp2 = RdMemB(addr);
- tmp = (tmp2<<1) + (ccrB&0x01);
- WrMemB(addr, tmp);
- (tmp2&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
- ((tmp2&0x80)^((tmp2<<1)&0x80) ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
-}
-void BOp0A(void) // DEC DP
-{
- addr = (dprB<<8) | FetchB();
- tmp = RdMemB(addr) - 1;
- WrMemB(addr, tmp);
- (tmp == 0x7F ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
-}
-void BOp0C(void) // INC DP
-{
- addr = (dprB<<8) | FetchB();
- tmp = RdMemB(addr) + 1;
- WrMemB(addr, tmp);
- (tmp == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
-}
-void BOp0D(void) // TST DP
-{
- tmp = RdMemB((dprB<<8)|FetchB());
- ccrB &= 0xFD; // CLV
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
-}
-void BOp0E(void) // JMP DP
-{
- pcrB = (dprB<<8) | FetchB();
- iclockB += 3;
-}
-void BOp0F(void) // CLR DP
-{
- WrMemB((dprB<<8)|FetchB(), 0);
- ccrB &= 0xF0; ccrB |= 0x04; // CLN, SEZ, CLV, CLC
- iclockB += 6;
-}
-void BOp12(void) // NOP
-{
- iclockB += 2;
-}
-void BOp13(void) // SYNC
-{
- iclockB += 2;
-}
-void BOp16(void) // LBRA
-{
- pcrB += SignedW(FetchWB());
- iclockB += 5;
-}
-void BOp17(void) // LBSR
-{
- addr = FetchWB();
- WrMemB(--srB, pcrB&0xFF); WrMemB(--srB, pcrB>>8);
- pcrB += SignedW(addr);
- iclockB += 9;
-}
-void BOp19(void) // DAA
-{
- /*if ((ccrB&0x20) || ((arB&0x0F) > 0x09)) // H set or lo nyb too big?
- {
- arB += 0x06; ccrB |= 0x20; // Then adjust & set half carry
- }
- if ((ccrB&0x01) || (arB > 0x9F)) // C set or hi nyb too big?
- {
- arB += 0x60; ccrB |= 0x01; // Then adjust & set carry
- }
- ccrB &= 0xF1; // CL NZV
- if (arB == 0) ccrB |= 0x04; // Adjust Zero flag
- if (arB&0x80) ccrB |= 0x08; // Adjust Negative flag
- iclockB += 2; //*/
-
- BYTE msn, lsn; // Will this work??
- WORD t, cf = 0;
- msn=arB & 0xf0; lsn=arB & 0x0f;
- if( lsn>0x09 || ccrB&0x20 ) cf |= 0x06;
- if( msn>0x80 && lsn>0x09 ) cf |= 0x60;
- if( msn>0x90 || ccrB&0x01 ) cf |= 0x60;
- t = cf + arB;
- ccrB &= 0xF1; // CL NZV
- //CLR_NZV; /* keep carry from previous operation */
- if (arB == 0) ccrB |= 0x04; // Adjust Zero flag
- if (arB&0x80) ccrB |= 0x08; // Adjust Negative flag
- //SET_NZ8((byte)t); SET_C8(t);
- ccrB |= ((t&0x100)>>8); // Adjust Carry (?)
- arB = t;
-}
-void BOp1A(void) // ORCC #
-{
- ccrB |= FetchB();
- iclockB += 3;
-}
-void BOp1C(void) // ANDCC #
-{
- ccrB &= FetchB();
- iclockB += 3;
-}
-void BOp1D(void) // SEX
-{
- (brB&0x80 ? arB = 0xFF : arB = 0x00);
- ((arB|brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp1E(void) // EXG
-{
- tmp = FetchB();
- addr = ReadEXGB(tmp>>4); WriteEXGB(tmp>>4, ReadEXGB(tmp&0xF));
- WriteEXGB(tmp&0xF, addr);
- iclockB += 8;
-}
-void BOp1F(void) // TFR
-{
- tmp = FetchB();
- WriteEXGB(tmp&0xF, ReadEXGB(tmp>>4));
- iclockB += 7;
-}
-void BOp20(void) // BRA
-{
- pcrB += SignedB(FetchB()); // Branch always
- iclockB += 3;
-}
-void BOp21(void) // BRN
-{
- FetchB();
- iclockB += 3;
-}
-void BOp22(void) // BHI
-{
- tmp = FetchB();
- if (!(ccrB&0x05)) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp23(void) // BLS
-{
- tmp = FetchB();
- if (ccrB&0x05) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp24(void) // BCC (BHS)
-{
- tmp = FetchB();
- if (!(ccrB&0x01)) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp25(void) // BCS (BLO)
-{
- tmp = FetchB();
- if (ccrB&0x01) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp26(void) // BNE
-{
- tmp = FetchB();
- if (!(ccrB&0x04)) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp27(void) // BEQ
-{
- tmp = FetchB();
- if (ccrB&0x04) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp28(void) // BVC
-{
- tmp = FetchB();
- if (!(ccrB&0x02)) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp29(void) // BVS
-{
- tmp = FetchB();
- if (ccrB&0x02) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp2A(void) // BPL
-{
- tmp = FetchB();
- if (!(ccrB&0x08)) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp2B(void) // BMI
-{
- tmp = FetchB();
- if (ccrB&0x08) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp2C(void) // BGE
-{
- tmp = FetchB();
- if (!(((ccrB&0x08) >> 2) ^ (ccrB&0x02))) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp2D(void) // BLT
-{
- tmp = FetchB();
- if (((ccrB&0x08) >> 2) ^ (ccrB&0x02)) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp2E(void) // BGT
-{
- tmp = FetchB();
- if (!((ccrB&0x04) | (((ccrB&0x08) >> 2) ^ (ccrB&0x02)))) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp2F(void) // BLE
-{
- tmp = FetchB();
- if ((ccrB&0x04) | (((ccrB&0x08) >> 2) ^ (ccrB&0x02))) pcrB += SignedB(tmp);
- iclockB += 3;
-}
-void BOp30(void) // LEAX
-{
- xrB = DecodeIDXB(FetchB());
- (xrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- iclockB += 4;
-}
-void BOp31(void) // LEAY
-{
- yrB = DecodeIDXB(FetchB());
- (yrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- iclockB += 4;
-}
-void BOp32(void) // LEAS
-{
- srB = DecodeIDXB(FetchB());
- (srB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- iclockB += 4;
-}
-void BOp33(void) // LEAU
-{
- urB = DecodeIDXB(FetchB());
- (urB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- iclockB += 4;
-}
-void BOp34(void) // PSHS
-{
- tmp = FetchB();
- if (tmp&0x80) { WrMemB(--srB, pcrB&0xFF); WrMemB(--srB, pcrB>>8); }
- if (tmp&0x40) { WrMemB(--srB, urB&0xFF); WrMemB(--srB, urB>>8); }
- if (tmp&0x20) { WrMemB(--srB, yrB&0xFF); WrMemB(--srB, yrB>>8); }
- if (tmp&0x10) { WrMemB(--srB, xrB&0xFF); WrMemB(--srB, xrB>>8); }
- if (tmp&0x08) WrMemB(--srB, dprB);
- if (tmp&0x04) WrMemB(--srB, brB);
- if (tmp&0x02) WrMemB(--srB, arB);
- if (tmp&0x01) WrMemB(--srB, ccrB);
- iclockB += 5;
-}
-void BOp35(void) // PULS
-{
- tmp = FetchB();
- if (tmp&0x01) ccrB = RdMemB(srB++);
- if (tmp&0x02) arB = RdMemB(srB++);
- if (tmp&0x04) brB = RdMemB(srB++);
- if (tmp&0x08) dprB = RdMemB(srB++);
- if (tmp&0x10) xrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
- if (tmp&0x20) yrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
- if (tmp&0x40) urB = (RdMemB(srB++)<<8) | RdMemB(srB++);
- if (tmp&0x80) pcrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
- iclockB += 5;
-}
-void BOp36(void) // PSHU
-{
- tmp = FetchB();
- if (tmp&0x80) { WrMemB(--urB, pcrB&0xFF); WrMemB(--urB, pcrB>>8); }
- if (tmp&0x40) { WrMemB(--urB, srB&0xFF); WrMemB(--urB, srB>>8); }
- if (tmp&0x20) { WrMemB(--urB, yrB&0xFF); WrMemB(--urB, yrB>>8); }
- if (tmp&0x10) { WrMemB(--urB, xrB&0xFF); WrMemB(--urB, xrB>>8); }
- if (tmp&0x08) WrMemB(--urB, dprB);
- if (tmp&0x04) WrMemB(--urB, brB);
- if (tmp&0x02) WrMemB(--urB, arB);
- if (tmp&0x01) WrMemB(--urB, ccrB);
- iclockB += 5;
-}
-void BOp37(void) // PULU
-{
- tmp = FetchB();
- if (tmp&0x01) ccrB = RdMemB(urB++);
- if (tmp&0x02) arB = RdMemB(urB++);
- if (tmp&0x04) brB = RdMemB(urB++);
- if (tmp&0x08) dprB = RdMemB(urB++);
- if (tmp&0x10) xrB = (RdMemB(urB++)<<8) | RdMemB(urB++);
- if (tmp&0x20) yrB = (RdMemB(urB++)<<8) | RdMemB(urB++);
- if (tmp&0x40) srB = (RdMemB(urB++)<<8) | RdMemB(urB++);
- if (tmp&0x80) pcrB = (RdMemB(urB++)<<8) | RdMemB(urB++);
- iclockB += 5;
-}
-void BOp39(void) // RTS
-{
- pcrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
- iclockB += 5;
-}
-void BOp3A(void) // ABX
-{
- xrB += brB;
- iclockB += 3;
-}
-void BOp3B(void) // RTI
-{
- ccrB = RdMemB(srB++);
- if (ccrB&0x80) // If E flag set, pull all regs
- {
- arB = RdMemB(srB++); brB = RdMemB(srB++); dprB = RdMemB(srB++);
- xrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
- yrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
- urB = (RdMemB(srB++)<<8) | RdMemB(srB++);
- iclockB += 15;
- }
- else
- {
- iclockB += 6;
- }
- pcrB = (RdMemB(srB++)<<8) | RdMemB(srB++);
-}
-void BOp3C(void) // CWAI
-{
- ccrB &= FetchB(); ccrB |= 0x80;
- iclockB += 1000000; // Force interrupt
-}
-void BOp3D(void) // MUL
-{
- addr = arB * brB; arB = addr>>8; brB = addr&0xFF;
- (addr == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero
- (brB&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry
- iclockB += 11;
-}
-void BOp3E(void) // RESET
-{
-}
-void BOp3F(void) // SWI
-{
-}
-void BOp40(void) // NEGA
-{
- arB = 256 - arB;
- (arB > 0x7F ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust carry
- (arB == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp43(void) // COMA
-{
- arB ^= 0xFF;
- ccrB &= 0xFD; ccrB |= 0x01; // CLV, SEC
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp44(void) // LSRA
-{
- (arB&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift low bit into carry
- arB >>= 1;
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp46(void) // RORA
-{
- tmp = arB; arB = (tmp>>1) + (ccrB&0x01)*128;
- (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp47(void) // ASRA
-{
- (arB&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
- arB >>= 1; // Do the shift
- if (arB&0x40) arB |= 0x80; // Set neg if it was set
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp48(void) // LSLA [Keep checking from here...]
-{
- (arB&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
- arB <<= 1;
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp49(void) // ROLA
-{
- tmp = arB; arB = (tmp<<1) + (ccrB&0x01);
- (tmp&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp4A(void) // DECA
-{
- arB--;
- (arB == 0x7F ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp4C(void) // INCA
- {
- arB++;
- (arB == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp4D(void) // TSTA
- {
- ccrB &= 0xFD; // Clear oVerflow flag
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp4F(void) // CLRA
-{
- arB = 0;
- ccrB &= 0xF0; ccrB |= 0x04; // Set NZVC
- iclockB += 2;
-}
-void BOp50(void) // NEGB
- {
- brB = 256 - brB;
-// ((brB^tmp)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Adjust H carry
- (brB == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (brB > 0x7F ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust carry
- iclockB += 2;
- }
-void BOp53(void) // COMB
- {
- brB ^= 0xFF;
- ccrB &= 0xFD; ccrB |= 0x01; // CLV, SEC
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp54(void) // LSRB
- {
- (brB&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift low bit into carry
- brB >>= 1;
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp56(void) // RORB
- {
- tmp = brB; brB = (brB >> 1) + (ccrB&0x01)*128;
- (tmp&0x01 ? ccrB |=0x01 : ccrB &= 0xFE); // Shift bit into carry
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp57(void) // ASRB
- {
- (brB&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
- brB >>= 1; // Do the shift
- if (brB&0x40) brB |= 0x80; // Set neg if it was set
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp58(void) // LSLB
- {
- (brB&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
- brB <<= 1;
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp59(void) // ROLB
-{
- tmp = brB;
- brB = (tmp<<1) + (ccrB&0x01);
- (tmp&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp5A(void) // DECB
- {
- brB--;
- (brB == 0x7F ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp5C(void) // INCB
- {
- brB++;
- (brB == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp5D(void) // TSTB
- {
- ccrB &= 0xFD; // Clear oVerflow flag
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp5F(void) // CLRB
- {
- brB = 0;
- ccrB &= 0xF0; ccrB |= 0x04; // Set NZVC
- iclockB += 2;
- }
-void BOp60(void) // NEG IDX
- {
- addr = DecodeIDXB(FetchB());
- tmp = RdMemB(addr); BYTE res = 256 - tmp;
- WrMemB(addr, res);
-// ((res^tmp)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Adjust H carry
- (res == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (res == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (res&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (res > 0x7F ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust carry
- iclockB += 6;
- }
-void BOp63(void) // COM IDX
- {
- addr = DecodeIDXB(FetchB());
- tmp = RdMemB(addr) ^ 0xFF;
- WrMemB(addr, tmp);
- ccrB &= 0xFD; ccrB |= 0x01; // CLV, SEC
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp64(void) // LSR IDX
- {
- addr = DecodeIDXB(FetchB());
- tmp = RdMemB(addr);
- (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift low bit into carry
- tmp >>= 1; WrMemB(addr, tmp);
- ccrB &= 0xF7; // CLN
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- iclockB += 6;
- }
-void BOp66(void) // ROR IDX
- {
- addr = DecodeIDXB(FetchB());
- tmp = RdMemB(addr); BYTE tmp2 = tmp;
- tmp = (tmp >> 1) + (ccrB&0x01)*128;
- WrMemB(addr, tmp);
- (tmp2&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp67(void) // ASR IDX
- {
- addr = DecodeIDXB(FetchB());
- tmp = RdMemB(addr);
- (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
- tmp >>= 1;
- if (tmp&0x40) tmp |= 0x80; // Set Neg if it was set
- WrMemB(addr, tmp);
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp68(void) // LSL IDX
- {
- addr = DecodeIDXB(FetchB());
- tmp = RdMemB(addr);
- (tmp&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
- tmp <<= 1;
- WrMemB(addr, tmp);
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp69(void) // ROL IDX
-{
- BYTE tmp2 = RdMemB(DecodeIDXB(FetchB()));
- tmp = (tmp2<<1) + (ccrB&0x01);
- WrMemB(addr, tmp);
- (tmp2&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
-}
-void BOp6A(void) // DEC IDX
- {
- BYTE tmp; WORD addr;
- addr = DecodeIDXB(FetchB());
- tmp = RdMemB(addr) - 1;
- WrMemB(addr, tmp);
- (tmp == 0x7F ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp6C(void) // INC IDX
- {
- addr = DecodeIDXB(FetchB());
- tmp = RdMemB(addr) + 1;
- WrMemB(addr, tmp);
- (tmp == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp6D(void) // TST IDX
- {
- tmp = RdMemB(DecodeIDXB(FetchB()));
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp6E(void) // JMP IDX
-{
- pcrB = DecodeIDXB(FetchB());
- iclockB += 3;
-}
-void BOp6F(void) // CLR IDX
-{
- addr = DecodeIDXB(FetchB());
- WrMemB(addr, 0);
- ccrB &= 0xF0; ccrB |= 0x04; // Set NZVC
- iclockB += 6;
-}
-void BOp70(void) // NEG ABS
- {
- addr = FetchWB();
- tmp = RdMemB(addr); BYTE res = 256 - tmp;
- WrMemB(addr, res);
- (res == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (res == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (res&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (res > 0x7F ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust carry
- iclockB += 7;
- }
-void BOp73(void) // COM ABS
- {
- addr = FetchWB();
- tmp = RdMemB(addr) ^ 0xFF;
- WrMemB(addr, tmp);
- ccrB &= 0xFD; ccrB |= 0x01; // CLV, SEC
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
- }
-void BOp74(void) // LSR ABS
- {
- addr = FetchWB();
- tmp = RdMemB(addr);
- (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift low bit into carry
- tmp >>= 1; WrMemB(addr, tmp);
- ccrB &= 0xF7; // CLN
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- iclockB += 7;
- }
-void BOp76(void) // ROR ABS
- {
- BYTE tmp; WORD addr;
- addr = FetchWB();
- tmp = RdMemB(addr); BYTE tmp2 = tmp;
- tmp = (tmp >> 1) + (ccrB&0x01)*128;
- WrMemB(addr, tmp);
- (tmp2&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
- }
-void BOp77(void) // ASR ABS
- {
- BYTE tmp; WORD addr;
- addr = FetchWB();
- tmp = RdMemB(addr);
- (tmp&0x01 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift bit into carry
- tmp >>= 1;
- if (tmp&0x40) tmp |= 0x80; // Set Neg if it was set
- WrMemB(addr, tmp);
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
- }
-void BOp78(void) // LSL ABS
- {
- BYTE tmp; WORD addr;
- addr = FetchWB();
- tmp = RdMemB(addr);
- (tmp&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
- tmp <<= 1;
- WrMemB(addr, tmp);
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
- }
-void BOp79(void) // ROL ABS
-{
- BYTE tmp2 = RdMemB(FetchWB());
- tmp = (tmp2<<1) + (ccrB&0x01);
- WrMemB(addr, tmp);
- (tmp2&0x80 ? ccrB |= 0x01 : ccrB &= 0xFE); // Shift hi bit into carry
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
-}
-void BOp7A(void) // DEC ABS
- {
- BYTE tmp; WORD addr;
- addr = FetchWB();
- tmp = RdMemB(addr) - 1;
- WrMemB(addr, tmp);
- (tmp == 0x7F ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
- }
-void BOp7C(void) // INC ABS
- {
- BYTE tmp; WORD addr;
- addr = FetchWB();
- tmp = RdMemB(addr) + 1;
- WrMemB(addr, tmp);
- (tmp == 0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // Adjust oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
- }
-void BOp7D(void) // TST ABS
-{
- BYTE tmp = RdMemB(FetchWB());
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
-}
-void BOp7E(void) // JMP ABS
-{
- pcrB = FetchWB();
- iclockB += 3;
-}
-void BOp7F(void) // CLR ABS
- {
- WrMemB(FetchWB(), 0);
- ccrB &= 0xF0; ccrB |= 0x04; // Set NZVC
- iclockB += 7;
- }
-void BOp80(void) // SUBA #
-{
- BYTE tmp = FetchB(); BYTE as = arB;
- arB -= tmp;
- (as < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp81(void) // CMPA #
-{
- tmp = FetchB();
- BYTE db = arB - tmp;
- (arB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((arB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (db == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (db&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp82(void) // SBCA #
-{
- tmp = FetchB(); BYTE as = arB;
- arB = arB - tmp - (ccrB&0x01);
- (as < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOp83(void) // SUBD #
-{
- addr = FetchWB(); WORD dr = (arB<<8)|brB, ds = dr;
- dr -= addr;
- (ds < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((ds^addr^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (dr == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- arB = dr>>8; brB = dr&0xFF;
- iclockB += 4;
-}
-void BOp84(void) // ANDA #
- {
- arB &= FetchB();
- ccrB &= 0xFD; // Clear oVerflow flag
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp85(void) // BITA #
- {
- tmp = arB & FetchB();
- ccrB &= 0xFD; // Clear oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp86(void) // LDA #
- {
- arB = FetchB();
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp88(void) // EORA #
- {
- arB ^= FetchB();
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp89(void) // ADCA #
-{
- tmp = FetchB();
- addr = (WORD)arB + (WORD)tmp + (WORD)(ccrB&0x01);
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry
- ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- arB = addr & 0xFF; // Set accumulator
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative
- iclockB += 2;
-}
-void BOp8A(void) // ORA #
- {
- arB |= FetchB();
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOp8B(void) // ADDA #
-{
- tmp = FetchB(); addr = arB + tmp;
- (addr > 0xFF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- arB = addr & 0xFF; // Set accumulator
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 2;
-}
-void BOp8C(void) // CMPX #
-{
- addr = FetchWB();
- WORD dw = xrB - addr;
- (xrB < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((xrB^addr^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
-}
-void BOp8D(void) // BSR
- {
- tmp = FetchB();
- WrMemB(--srB, pcrB&0xFF); WrMemB(--srB, pcrB>>8);
- pcrB += SignedB(tmp);
- iclockB += 7;
- }
-void BOp8E(void) // LDX #
- {
- xrB = FetchWB();
- ccrB &= 0xFD; // CLV
- (xrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 3;
- }
-void BOp90(void) // SUBA DP
- {
- tmp = RdMemB((dprB<<8)|FetchB()); BYTE as = arB;
- arB -= tmp;
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (as < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 4;
- }
-void BOp91(void) // CMPA DP
- {
- tmp = RdMemB((dprB<<8)|FetchB());
- BYTE db = arB - tmp;
- (db == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (db&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (arB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((arB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 4;
- }
-void BOp92(void) // SBCA DP
-{
- tmp = RdMemB((dprB<<8)|FetchB()); BYTE as = arB;
- arB = arB - tmp - (ccrB&0x01);
- (as < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
-}
-void BOp93(void) // SUBD DP
-{
- addr = (dprB<<8)|FetchB(); WORD dr = (arB<<8)|brB, ds = dr;
- WORD adr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
- dr -= adr2;
- (ds < adr2 ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (dr == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- arB = dr>>8; brB = dr&0xFF;
- iclockB += 6;
-}
-void BOp94(void) // ANDA DP
-{
- arB &= RdMemB((dprB<<8)|FetchB());
- ccrB &= 0xF1; // CLV CLZ CLN
- if (arB == 0) ccrB |= 0x04; // Adjust Zero flag
- if (arB&0x80) ccrB |= 0x08; // Adjust Negative flag
- iclockB += 4;
-}
-void BOp95(void) // BITA DP
- {
- tmp = arB & RdMemB((dprB<<8)|FetchB());
- ccrB &= 0xFD; // Clear oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOp96(void) // LDA DP
-{
- arB = RdMemB((dprB<<8)|FetchB());
- ccrB &= 0xF1; // CLN CLZ CLV
- if (arB == 0) ccrB |= 0x04; // Set Zero flag
- if (arB&0x80) ccrB |= 0x08; // Set Negative flag
- iclockB += 4;
-}
-void BOp97(void) // STA DP
- {
- WrMemB((dprB<<8)|FetchB(), arB);
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOp98(void) // EORA DP
- {
- arB ^= RdMemB((dprB<<8)|FetchB());
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOp99(void) // ADCA DP
-{
- tmp = RdMemB((dprB<<8)|FetchB());
- addr = (WORD)arB + (WORD)tmp + (WORD)(ccrB&0x01);
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry
- ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- arB = addr & 0xFF; // Set accumulator
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative
- iclockB += 4;
-}
-void BOp9A(void) // ORA DP
- {
- arB |= RdMemB((dprB<<8)|FetchB());
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOp9B(void) // ADDA DP
-{
- tmp = RdMemB((dprB<<8)|FetchB());
- addr = (WORD)arB + (WORD)tmp;
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
- arB = addr & 0xFF; // Set accumulator
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 4;
-}
-void BOp9C(void) // CMPX DP
- {
- addr = (dprB<<8)|FetchB();
- WORD adr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
- WORD dw = xrB - adr2;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (xrB < adr2 ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((xrB^adr2^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 6;
- }
-void BOp9D(void) // JSR DP
- {
- addr = (dprB<<8) | FetchB();
- WrMemB(--srB, pcrB&0xFF); WrMemB(--srB, pcrB>>8);
- pcrB = addr; // JSR to DP location...
- iclockB += 7;
- }
-void BOp9E(void) // LDX DP
- {
- addr = (dprB<<8) | FetchB();
- xrB = (RdMemB(addr) << 8) | RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- (xrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
- }
-void BOp9F(void) // STX DP
- {
- addr = (dprB<<8) | FetchB();
- WrMemB(addr, xrB>>8); WrMemB(addr+1, xrB&0xFF);
- ccrB &= 0xFD; // CLV
- (xrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
- }
-void BOpA0(void) // SUBA IDX
- {
- tmp = RdMemB(DecodeIDXB(FetchB())); BYTE as = arB;
- arB -= tmp;
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (as < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 4;
- }
-void BOpA1(void) // CMPA IDX
- {
- tmp = RdMemB(DecodeIDXB(FetchB()));
- BYTE db = arB - tmp;
- (db == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (db&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (arB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((arB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 4;
- }
-void BOpA2(void) // SBCA IDX
-{
- tmp = RdMemB(DecodeIDXB(FetchB())); BYTE as = arB;
- arB = arB - tmp - (ccrB&0x01);
- (as < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
-}
-void BOpA3(void) // SUBD IDX
-{
- addr = DecodeIDXB(FetchB()); WORD dr = (arB<<8)|brB, ds = dr;
- WORD adr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
- dr -= adr2;
- (ds < adr2 ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (dr == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- arB = dr>>8; brB = dr&0xFF;
- iclockB += 6;
-}
-void BOpA4(void) // ANDA IDX
- {
- arB &= RdMemB(DecodeIDXB(FetchB()));
- ccrB &= 0xFD; // Clear oVerflow flag
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpA5(void) // BITA IDX
- {
- tmp = arB & RdMemB(DecodeIDXB(FetchB()));
- ccrB &= 0xFD; // Clear oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpA6(void) // LDA IDX
-{
- arB = RdMemB(DecodeIDXB(FetchB()));
- ccrB &= 0xF1; // CLV CLZ CLN
- if (arB == 0) ccrB |= 0x04; // Set Zero flag
- if (arB&0x80) ccrB |= 0x08; // Set Negative flag
- iclockB += 4;
-}
-void BOpA7(void) // STA IDX
-{
- WrMemB(DecodeIDXB(FetchB()), arB);
- ccrB &= 0xF1; // CLV CLZ CLN
- if (arB == 0) ccrB |= 0x04; // Set Zero flag
- if (arB&0x80) ccrB |= 0x08; // Set Negative flag
- iclockB += 4;
-}
-void BOpA8(void) // EORA IDX
- {
- arB ^= RdMemB(DecodeIDXB(FetchB()));
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpA9(void) // ADCA IDX
-{
- tmp = RdMemB(DecodeIDXB(FetchB()));
- addr = (WORD)arB + (WORD)tmp + (WORD)(ccrB&0x01);
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
- arB = addr & 0xFF; // Set accumulator
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 4;
-}
-void BOpAA(void) // ORA IDX
-{
- arB |= RdMemB(DecodeIDXB(FetchB()));
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
-}
-void BOpAB(void) // ADDA IDX
-{
- tmp = RdMemB(DecodeIDXB(FetchB()));
- addr = (WORD)arB + (WORD)tmp;
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
- arB = addr & 0xFF; // Set accumulator
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 4;
-}
-void BOpAC(void) // CMPX IDX
-{
- addr = DecodeIDXB(FetchB());
- WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
- WORD dw = xrB - addr2;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (xrB < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((xrB^addr2^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 6;
-}
-void BOpAD(void) // JSR IDX
-{
- addr = DecodeIDXB(FetchB());
- WrMemB(--srB, pcrB&0xFF); WrMemB(--srB, pcrB>>8);
- pcrB = addr; // JSR directly to IDX ptr
- iclockB += 7;
-}
-void BOpAE(void) // LDX IDX
-{
- addr = DecodeIDXB(FetchB());
- xrB = (RdMemB(addr) << 8) | RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- (xrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpAF(void) // STX IDX
-{
- addr = DecodeIDXB(FetchB());
- WrMemB(addr, xrB>>8); WrMemB(addr+1, xrB&0xFF);
- ccrB &= 0xF1; // CLV CLZ CLN
- if (xrB == 0) ccrB |= 0x04; // Set Zero flag
- if (xrB&0x8000) ccrB |= 0x08; // Set Negative flag
- iclockB += 5;
-}
-void BOpB0(void) // SUBA ABS
- {
- tmp = RdMemB(FetchWB()); BYTE as = arB;
- arB -= tmp;
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (as < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 5;
- }
-void BOpB1(void) // CMPA ABS
- {
- tmp = RdMemB(FetchWB());
- BYTE db = arB - tmp;
- (db == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (db&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (arB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((arB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 5;
- }
-void BOpB2(void) // SBCA ABS
-{
- tmp = RdMemB(FetchWB()); BYTE as = arB;
- arB = arB - tmp - (ccrB&0x01);
- (as < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((as^tmp^arB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpB3(void) // SUBD ABS
-{
- addr = FetchWB(); WORD dr = (arB<<8)|brB, ds = dr;
- WORD adr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
- dr -= adr2;
- (ds < adr2 ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- (dr == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- arB = dr>>8; brB = dr&0xFF;
- iclockB += 7;
-}
-void BOpB4(void) // ANDA ABS
-{
- arB &= RdMemB(FetchWB());
- ccrB &= 0xFD; // Clear oVerflow flag
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpB5(void) // BITA ABS
-{
- tmp = arB & RdMemB(FetchWB());
- ccrB &= 0xFD; // Clear oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpB6(void) // LDA ABS
-{
- arB = RdMemB(FetchWB());
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpB7(void) // STA ABS
-{
- WrMemB(FetchWB(), arB);
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpB8(void) // EORA ABS
-{
- arB ^= RdMemB(FetchWB());
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpB9(void) // ADCA ABS
-{
- tmp = RdMemB(FetchWB());
- addr = (WORD)arB + (WORD)tmp + (WORD)(ccrB&0x01);
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- arB = addr; // Set accumulator
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 5;
-}
-void BOpBA(void) // ORA ABS
-{
- arB |= RdMemB(FetchWB());
- ccrB &= 0xFD; // CLV
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpBB(void) // ADDA ABS
-{
- tmp = RdMemB(FetchWB());
- addr = (WORD)arB + (WORD)tmp;
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((arB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((arB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
- arB = addr & 0xFF; // Set accumulator
- (arB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 5;
-}
-void BOpBC(void) // CMPX ABS
-{
- addr = FetchWB(); WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
- WORD dw = xrB - addr2;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (xrB < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((xrB^addr2^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 7;
-}
-void BOpBD(void) // JSR ABS
-{
- addr = FetchWB();
- WrMemB(--srB, pcrB&0xFF); WrMemB(--srB, pcrB>>8);
- pcrB = addr; // Go to absolute address (Not indir)
- iclockB += 8;
-}
-void BOpBE(void) // LDX ABS
-{
- addr = FetchWB();
- xrB = (RdMemB(addr) << 8) | RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- (xrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
-}
-void BOpBF(void) // STX ABS
- {
- addr = FetchWB();
- WrMemB(addr, xrB>>8); WrMemB(addr+1, xrB&0xFF);
- ccrB &= 0xFD; // CLV
- (xrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (xrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOpC0(void) // SUBB #
- {
- tmp = FetchB(); BYTE bs = brB;
- brB -= tmp;
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (bs < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 2;
- }
-void BOpC1(void) // CMPB #
- {
- tmp = FetchB();
- BYTE db = brB - tmp;
- (brB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((brB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (db == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (db&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOpC2(void) // SBCB #
-{
- tmp = FetchB(); BYTE bs = brB;
- brB = brB - tmp - (ccrB&0x01);
- (bs < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
-}
-void BOpC3(void) // ADDD #
-{
- addr = FetchWB(); long dr = ((arB<<8)|brB)&0xFFFF, ds = dr;
- dr += addr;
- (dr > 0xFFFF ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- dr &= 0xFFFF;
- (dr == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- ((ds^addr^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- arB = dr>>8; brB = dr&0xFF;
- iclockB += 4;
-}
-void BOpC4(void) // ANDB #
- {
- brB &= FetchB();
- ccrB &= 0xFD; // Clear oVerflow flag
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOpC5(void) // BITB #
-{
- tmp = brB & FetchB();
- ccrB &= 0xF1; // CLV CLZ CLN
- if (tmp == 0) ccrB |= 0x04; // Set Zero flag
- if (tmp&0x80) ccrB |= 0x08; // Set Negative flag
- iclockB += 2;
-}
-void BOpC6(void) // LDB #
-{
- brB = FetchB();
- ccrB &= 0xF1; // CLV CLZ CLN
- if (brB == 0) ccrB |= 0x04; // Set Zero flag
- if (brB&0x80) ccrB |= 0x08; // Set Negative flag
- iclockB += 2;
-}
-void BOpC8(void) // EORB #
- {
- brB ^= FetchB();
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOpC9(void) // ADCB #
-{
- tmp = FetchB();
- addr = (WORD)brB + (WORD)tmp + (WORD)(ccrB&0x01);
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
- brB = addr & 0xFF; // Set accumulator
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 2;
-}
-void BOpCA(void) // ORB #
- {
- brB |= FetchB();
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 2;
- }
-void BOpCB(void) // ADDB #
-{
- tmp = FetchB(); addr = brB + tmp;
- (addr > 0xFF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
- brB = addr & 0xFF; // Set accumulator
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 2;
-}
-void BOpCC(void) // LDD #
-{
- arB = FetchB(); brB = FetchB();
- ccrB &= 0xFD; // CLV
- ((arB+brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 3;
-}
-void BOpCE(void) // LDU #
-{
- urB = FetchWB();
- ccrB &= 0xFD; // CLV
- (urB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (urB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 3;
-}
-void BOpD0(void) // SUBB DP
-{
- tmp = RdMemB((dprB<<8)|FetchB()); BYTE bs = brB;
- brB -= tmp;
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (bs < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 4;
-}
-void BOpD1(void) // CMPB DP
-{
- tmp = RdMemB((dprB<<8)|FetchB());
- BYTE db = brB - tmp;
- (db == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (db&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (brB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((brB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 4;
-}
-void BOpD2(void) // SBCB DP
-{
- tmp = RdMemB((dprB<<8)|FetchB()); BYTE bs = brB;
- brB = brB - tmp - (ccrB&0x01);
- (bs < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
-}
-void BOpD3(void) // ADDD DP
-{
- addr = (dprB<<8)|FetchB(); long dr = ((arB<<8)|brB)&0xFFFF, ds = dr;
- WORD adr2 = (RdMemB(addr)<<8)|RdMemB(addr+1);
- dr += adr2;
- (dr > 0xFFFF ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- dr &= 0xFFFF;
- (dr == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- arB = dr>>8; brB = dr&0xFF;
- iclockB += 6;
-}
-void BOpD4(void) // ANDB DP
- {
- brB &= RdMemB((dprB<<8)|FetchB());
- ccrB &= 0xFD; // Clear oVerflow flag
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpD5(void) // BITB DP
- {
- tmp = brB & RdMemB((dprB<<8)|FetchB());
- ccrB &= 0xFD; // Clear oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpD6(void) // LDB DP
-{
- brB = RdMemB((dprB<<8)|FetchB());
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
-}
-void BOpD7(void) // STB DP
- {
- WrMemB((dprB<<8)|FetchB(), brB);
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpD8(void) // EORB DP
- {
- brB ^= RdMemB((dprB<<8)|FetchB());
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpD9(void) // ADCB DP
-{
- tmp = RdMemB((dprB<<8)|FetchB());
- addr = (WORD)brB + (WORD)tmp + (WORD)(ccrB&0x01);
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- brB = addr; // Set accumulator
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 4;
-}
-void BOpDA(void) // ORB DP
- {
- brB |= RdMemB((dprB<<8)|FetchB());
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpDB(void) // ADDB DP
-{
- tmp = RdMemB((dprB<<8)|FetchB());
- addr = (WORD)brB + (WORD)tmp;
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- brB = addr & 0xFF; // Set accumulator
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 4;
-}
-void BOpDC(void) // LDD DP
-{
- addr = (dprB<<8)|FetchB();
- arB = RdMemB(addr); brB = RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- ((arB|brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpDD(void) // STD DP
-{
- addr = (dprB<<8)|FetchB();
- WrMemB(addr, arB); WrMemB(addr+1, brB);
- ccrB &= 0xFD; // CLV
- ((arB|brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpDE(void) // LDU DP
-{
- addr = (dprB<<8)|FetchB();
- urB = (RdMemB(addr) << 8) | RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- (urB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (urB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpDF(void) // STU DP
-{
- addr = (dprB<<8)|FetchB();
- WrMemB(addr, urB>>8); WrMemB(addr+1, urB&0xFF);
- ccrB &= 0xFD; // CLV
- (urB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (urB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
-}
-void BOpE0(void) // SUBB IDX
-{
- tmp = RdMemB(DecodeIDXB(FetchB())); BYTE bs = brB;
- brB -= tmp;
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (bs < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 4;
-}
-void BOpE1(void) // CMPB IDX
-{
- tmp = RdMemB(DecodeIDXB(FetchB()));
- BYTE db = brB - tmp;
- (db == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (db&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (brB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((brB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 4;
-}
-void BOpE2(void) // SBCB IDX
-{
- tmp = RdMemB(DecodeIDXB(FetchB())); BYTE bs = brB;
- brB = brB - tmp - (ccrB&0x01);
- (bs < (tmp+(ccrB&0x01)) ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
-}
-void BOpE3(void) // ADDD IDX
-{
- addr = DecodeIDXB(FetchB()); long dr = ((arB<<8)|brB)&0xFFFF, ds = dr;
- WORD adr2 = (RdMemB(addr)<<8)|RdMemB(addr+1);
- dr += adr2;
- (dr > 0xFFFF ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- dr &= 0xFFFF;
- (dr == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- arB = dr>>8; brB = dr&0xFF;
- iclockB += 6;
-}
-void BOpE4(void) // ANDB IDX
- {
- brB &= RdMemB(DecodeIDXB(FetchB()));
- ccrB &= 0xFD; // Clear oVerflow flag
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpE5(void) // BITB IDX
- {
- tmp = brB & RdMemB(DecodeIDXB(FetchB()));
- ccrB &= 0xFD; // Clear oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpE6(void) // LDB IDX
- {
- brB = RdMemB(DecodeIDXB(FetchB()));
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpE7(void) // STB IDX
-{
- WrMemB(DecodeIDXB(FetchB()), brB);
- ccrB &= 0xF1; // CLV CLZ CLN
- if (brB == 0) ccrB |= 0x04; // Adjust Zero flag
- if (brB&0x80) ccrB |= 0x08; // Adjust Negative flag
- iclockB += 4;
-}
-void BOpE8(void) // EORB IDX
- {
- brB ^= RdMemB(DecodeIDXB(FetchB()));
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpE9(void) // ADCB IDX
-{
- tmp = RdMemB(DecodeIDXB(FetchB()));
- addr = (WORD)brB + (WORD)tmp + (WORD)(ccrB&0x01);
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- brB = addr; // Set accumulator
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 4;
-}
-void BOpEA(void) // ORB IDX
- {
- brB |= RdMemB(DecodeIDXB(FetchB()));
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOpEB(void) // ADDB IDX
-{
- tmp = RdMemB(DecodeIDXB(FetchB()));
- addr = (WORD)brB + (WORD)tmp;
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- brB = addr; // Set accumulator
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 4;
-}
-void BOpEC(void) // LDD IDX
-{
- addr = DecodeIDXB(FetchB());
- arB = RdMemB(addr); brB = RdMemB(addr+1);
- ccrB &= 0xF1; // CLV CLZ CLN
- if (!(arB|brB)) ccrB |= 0x04; // Adjust Zero flag
- if (arB&0x80) ccrB |= 0x08; // Adjust Negative flag
- iclockB += 5;
-}
-void BOpED(void) // STD IDX
-{
- addr = DecodeIDXB(FetchB());
- WrMemB(addr, arB); WrMemB(addr+1, brB);
- ccrB &= 0xF1; // CLV CLZ CLZ
- if (!(arB|brB)) ccrB |= 0x04; // Adjust Zero flag
- if (arB&0x80) ccrB |= 0x08; // Adjust Negative flag
- iclockB += 5;
-}
-void BOpEE(void) // LDU IDX
-{
- addr = DecodeIDXB(FetchB());
- urB = (RdMemB(addr) << 8) | RdMemB(addr+1);
- ccrB &= 0xF1; // CLV CLZ CLN
- if (urB == 0) ccrB |= 0x04; // Set Zero flag
- if (urB&0x8000) ccrB |= 0x08; // Set Negative flag
- iclockB += 5;
-}
-void BOpEF(void) // STU IDX
-{
- addr = DecodeIDXB(FetchB());
- WrMemB(addr, urB>>8); WrMemB(addr+1, urB&0xFF);
- ccrB &= 0xF1; // CLV CLZ CLN
- if (urB == 0) ccrB |= 0x04; // Set Zero flag
- if (urB&0x8000) ccrB |= 0x08; // Set Negative flag
- iclockB += 5;
-}
-void BOpF0(void) // SUBB ABS
- {
- tmp = RdMemB(FetchWB()); BYTE bs = brB;
- brB -= tmp;
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (bs < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- }
-void BOpF1(void) // CMPB ABS
- {
- tmp = RdMemB(FetchWB());
- BYTE db = brB - tmp;
- (db == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (db&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (brB < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((brB^tmp^db^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 5;
- }
-void BOpF2(void) // SBCB ABS
-{
- tmp = RdMemB(FetchWB()); BYTE bs = brB;
- brB = brB - tmp - (ccrB&0x01);
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (bs < tmp ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((bs^tmp^brB^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflow
- iclockB += 5;
-}
-void BOpF3(void) // ADDD ABS
-{
- addr = FetchWB(); long dr = ((arB<<8)|brB)&0xFFFF, ds = dr;
- WORD adr2 = (RdMemB(addr)<<8)|RdMemB(addr+1);
- dr += adr2;
- (dr > 0xFFFF ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- dr &= 0xFFFF;
- (dr == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dr&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- ((ds^adr2^dr^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- arB = dr>>8; brB = dr&0xFF;
- iclockB += 7;
-}
-void BOpF4(void) // ANDB ABS
- {
- brB &= RdMemB(FetchWB());
- ccrB &= 0xFD; // Clear oVerflow flag
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
- }
-void BOpF5(void) // BITB ABS
- {
- tmp = brB & RdMemB(FetchWB());
- ccrB &= 0xFD; // Clear oVerflow flag
- (tmp == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (tmp&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
- }
-void BOpF6(void) // LDB ABS
- {
- brB = RdMemB(FetchWB());
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
- }
-void BOpF7(void) // STB ABS
- {
- WrMemB(FetchWB(), brB);
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
- }
-void BOpF8(void) // EORB ABS
- {
- brB ^= RdMemB(FetchWB());
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
- }
-void BOpF9(void) // ADCB ABS
-{
- tmp = RdMemB(FetchWB());
- addr = (WORD)brB + (WORD)tmp + (WORD)(ccrB&0x01);
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
- brB = addr & 0xFF; // Set accumulator
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 5;
-}
-void BOpFA(void) // ORB ABS
- {
- brB |= RdMemB(FetchWB());
- ccrB &= 0xFD; // CLV
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 5;
- }
-void BOpFB(void) // ADDB ABS
-{
- tmp = RdMemB(FetchWB());
- addr = (WORD)brB + (WORD)tmp;
- (addr > 0x00FF ? ccrB |= 0x01 : ccrB &= 0xFE); // Set Carry flag
- ((brB^tmp^addr)&0x10 ? ccrB |= 0x20 : ccrB &= 0xDF); // Set Half carry
- ((brB^tmp^addr^(ccrB<<7))&0x80 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerflo
- brB = addr & 0xFF; // Set accumulator
- (brB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Set Zero flag
- (brB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Set Negative flag
- iclockB += 5;
-}
-void BOpFC(void) // LDD ABS
- {
- addr = FetchWB();
- arB = RdMemB(addr); brB = RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- ((arB+brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOpFD(void) // STD ABS
- {
- addr = FetchWB();
- WrMemB(addr, arB); WrMemB(addr+1, brB);
- ccrB &= 0xFD; // CLV
- ((arB+brB) == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (arB&0x80 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOpFE(void) // LDU ABS
- {
- addr = FetchWB();
- urB = (RdMemB(addr) << 8) | RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- (urB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (urB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOpFF(void) // STU ABS
- {
- addr = FetchWB();
- WrMemB(addr, urB>>8); WrMemB(addr+1, urB&0xFF);
- ccrB &= 0xFD; // CLV
- (urB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (urB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-
-//
-// Page one opcodes' execute code
-//
-
-void BOp1021(void) // LBRN
-{
- addr = FetchWB();
- iclockB += 5;
-}
-void BOp1022(void) // LBHI
-{
- addr = FetchWB();
- if (!((ccrB&0x01)|(ccrB&0x04))) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp1023(void) // LBLS
-{
- addr = FetchWB();
- if ((ccrB&0x01)|(ccrB&0x04)) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp1024(void) // LBCC (LBHS)
-{
- addr = FetchWB();
- if (!(ccrB&0x01)) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp1025(void) // LBCS (LBLO)
-{
- addr = FetchWB();
- if (ccrB&0x01) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp1026(void) // LBNE
-{
- addr = FetchWB();
- if (!(ccrB&0x04)) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp1027(void) // LBEQ
-{
- addr = FetchWB();
- if (ccrB&0x04) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp1028(void) // LBVC
-{
- addr = FetchWB();
- if (!(ccrB&0x02)) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp1029(void) // LBVS
-{
- addr = FetchWB();
- if (ccrB&0x02) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp102A(void) // LBPL
-{
- addr = FetchWB();
- if (!(ccrB&0x08)) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp102B(void) // LBMI
-{
- addr = FetchWB();
- if (ccrB&0x08) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp102C(void) // LBGE
-{
- addr = FetchWB();
- if (!(((ccrB&0x08) >> 2) ^ (ccrB&0x02))) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp102D(void) // LBLT
-{
- addr = FetchWB();
- if (((ccrB&0x08) >> 2) ^ (ccrB&0x02)) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp102E(void) // LBGT
-{
- addr = FetchWB();
- if (!((ccrB&0x04) | (((ccrB&0x08) >> 2) ^ (ccrB&0x02)))) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp102F(void) // LBLE
-{
- addr = FetchWB();
- if ((ccrB&0x04) | (((ccrB&0x08) >> 2) ^ (ccrB&0x02))) pcrB += SignedW(addr);
- iclockB += 5;
-}
-void BOp103F(void) // SWI2 (Not yet implemented)
-{
- iclockB += 20;
-}
-void BOp1083(void) // CMPD #
- {
- addr = FetchWB(); WORD dr = (arB<<8)|brB;
- WORD dw = dr - addr;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (dr < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((dr^addr^dw^((WORD)ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 5;
- }
-void BOp108C(void) // CMPY #
- {
- addr = FetchWB();
- WORD dw = yrB - addr;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (yrB < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((yrB^addr^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 5;
- }
-void BOp108E(void) // LDY #
- {
- yrB = FetchWB();
- ccrB &= 0xFD; // CLV
- (yrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOp1093(void) // CMPD DP
- {
- WORD adr2 = (dprB<<8)|FetchB(), dr = (arB<<8)|brB;
- addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
- WORD dw = dr - addr;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (dr < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((dr^addr^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 7;
- }
-void BOp109C(void) // CMPY DP
- {
- WORD adr2 = (dprB<<8)|FetchB();
- addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
- WORD dw = yrB - addr;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (yrB < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- ((yrB^addr^dw^(ccrB<<15))&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 7;
- }
-void BOp109E(void) // LDY DP
- {
- addr = (dprB<<8)|FetchB();
- yrB = (RdMemB(addr)<<8) | RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- (yrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp109F(void) // STY DP
- {
- addr = (dprB<<8)|FetchB();
- WrMemB(addr, yrB>>8); WrMemB(addr+1, yrB&0xFF);
- ccrB &= 0xFD; // CLV
- (yrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp10A3(void) // CMPD IDX
-{
- WORD adr2 = DecodeIDXB(FetchB()), dr = (arB<<8)|brB;
- addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
- WORD dw = dr - addr;
- ccrB &= 0xF0; // CLC CLV CLZ CLN
- if (dr < addr) ccrB |= 0x01; // Set Carry flag
- if ((dr^addr^dw^(ccrB<<15))&0x8000) ccrB |= 0x02; // Set oVerflow
- if (dw == 0) ccrB |= 0x04; // Set Zero flag
- if (dw&0x8000) ccrB |= 0x08; // Set Negative flag
- iclockB += 7;
-}
-void BOp10AC(void) // CMPY IDX
- {
- WORD adr2 = DecodeIDXB(FetchB());
- addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
- WORD dw = yrB - addr;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (yrB < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- (((ccrB<<15)^yrB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 7;
- }
-void BOp10AE(void) // LDY IDX
-{
- addr = DecodeIDXB(FetchB());
- yrB = (RdMemB(addr)<<8) | RdMemB(addr+1);
- ccrB &= 0xF1; // CLV CLZ CLN
- if (yrB == 0) ccrB |= 0x04; // Adjust Zero flag
- if (yrB&0x8000) ccrB |= 0x08; // Adjust Negative flag
- iclockB += 6;
-}
-void BOp10AF(void) // STY IDX
- {
- addr = DecodeIDXB(FetchB());
- WrMemB(addr, yrB>>8); WrMemB(addr+1, yrB&0xFF);
- ccrB &= 0xFD; // CLV
- (yrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp10B3(void) // CMPD ABS
- {
- addr = FetchWB(); WORD dr = (arB<<8)|brB;
- WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
- WORD dw = dr - addr2;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (dr < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- (((ccrB<<15)^dr^addr2^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 8;
- }
-void BOp10BC(void) // CMPY ABS
- {
- addr = FetchWB(); WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
- WORD dw = yrB - addr2;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (yrB < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- (((ccrB<<15)^yrB^addr2^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 8;
- }
-void BOp10BE(void) // LDY ABS
- {
- addr = FetchWB();
- yrB = (RdMemB(addr)<<8) | RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- (yrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
- }
-void BOp10BF(void) // STY ABS
- {
- addr = FetchWB();
- WrMemB(addr, yrB>>8); WrMemB(addr+1, yrB&0xFF);
- ccrB &= 0xFD; // CLV
- (yrB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (yrB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
- }
-void BOp10CE(void) // LDS #
- {
- srB = FetchWB();
- ccrB &= 0xFD; // CLV
- (srB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 4;
- }
-void BOp10DE(void) // LDS DP
- {
- addr = (dprB<<8)|FetchB();
- srB = (RdMemB(addr)<<8) | RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- (srB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp10DF(void) // STS DP
- {
- addr = (dprB<<8)|FetchB();
- WrMemB(addr, srB>>8); WrMemB(addr+1, srB&0xFF);
- ccrB &= 0xFD; // CLV
- (srB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp10EE(void) // LDS IDX
- {
- addr = DecodeIDXB(FetchB());
- srB = (RdMemB(addr)<<8) | RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- (srB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp10EF(void) // STS IDX
- {
- addr = DecodeIDXB(FetchB());
- WrMemB(addr, srB>>8); WrMemB(addr+1, srB&0xFF);
- ccrB &= 0xFD; // CLV
- (srB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 6;
- }
-void BOp10FE(void) // LDS ABS
- {
- addr = FetchWB();
- srB = (RdMemB(addr)<<8) | RdMemB(addr+1);
- ccrB &= 0xFD; // CLV
- (srB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
- }
-void BOp10FF(void) // STS ABS
-{
- addr = FetchWB();
- WrMemB(addr, srB>>8); WrMemB(addr+1, srB&0xFF);
- ccrB &= 0xFD; // CLV
- (srB == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (srB&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- iclockB += 7;
-}
-
-//
-// Page two opcodes' execute code
-//
-
-void BOp113F(void) // SWI3
- {
- iclockB += 20;
- }
-void BOp1183(void) // CMPU #
- {
- addr = FetchWB();
- WORD dw = urB - addr;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (urB < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- (((ccrB<<15)^urB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 5;
- }
-void BOp118C(void) // CMPS #
- {
- addr = FetchWB();
- WORD dw = srB - addr;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (srB < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- (((ccrB<<15)^srB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 5;
- }
-void BOp1193(void) // CMPU DP
- {
- WORD adr2 = (dprB<<8)|FetchB();
- addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
- WORD dw = urB - addr;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (urB < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- (((ccrB<<15)^urB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 7;
- }
-void BOp119C(void) // CMPS DP
- {
- WORD adr2 = (dprB<<8)|FetchB();
- addr = (RdMemB(adr2)<<8) | RdMemB(adr2+1);
- WORD dw = srB - addr;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (srB < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- (((ccrB<<15)^srB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 7;
- }
-void BOp11A3(void) // CMPU IDX
- {
- WORD addr2 = DecodeIDXB(FetchB());
- addr = (RdMemB(addr2)<<8) | RdMemB(addr2+1);
- WORD dw = urB - addr;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (urB < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- (((ccrB<<15)^urB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 7;
- }
-void BOp11AC(void) // CMPS IDX
- {
- WORD addr2 = DecodeIDXB(FetchB());
- addr = (RdMemB(addr2)<<8) | RdMemB(addr2+1);
- WORD dw = srB - addr;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (srB < addr ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- (((ccrB<<15)^srB^addr^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 7;
- }
-void BOp11B3(void) // CMPU ABS
- {
- addr = FetchWB(); WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
- WORD dw = urB - addr2;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (urB < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- (((ccrB<<15)^urB^addr2^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 8;
- }
-void BOp11BC(void) // CMPS ABS
- {
- addr = FetchWB(); WORD addr2 = (RdMemB(addr)<<8) | RdMemB(addr+1);
- WORD dw = srB - addr2;
- (dw == 0 ? ccrB |= 0x04 : ccrB &= 0xFB); // Adjust Zero flag
- (dw&0x8000 ? ccrB |= 0x08 : ccrB &= 0xF7); // Adjust Negative flag
- (srB < addr2 ? ccrB |= 0x01 : ccrB &= 0xFE); // Adjust Carry flag
- (((ccrB<<15)^srB^addr2^dw)&0x8000 ? ccrB |= 0x02 : ccrB &= 0xFD); // oVerfl
- iclockB += 8;
- }
-
-void IllegalBOp(void) { iclockB++; illegalB = true; }
-
-//
-// Initialize 6809 function adressess
-//
-void Init_6809B(void)
-{
- for(int i=0; i<256; i++) // Set all functions to illegal
- {
- exec_op0B[i] = IllegalBOp;
- exec_op1B[i] = IllegalBOp;
- exec_op2B[i] = IllegalBOp;
- }
- exec_op0B[0x00] = BOp00; exec_op0B[0x03] = BOp03; exec_op0B[0x04] = BOp04;
- exec_op0B[0x06] = BOp06; exec_op0B[0x07] = BOp07; exec_op0B[0x08] = BOp08;
- exec_op0B[0x09] = BOp09; exec_op0B[0x0A] = BOp0A; exec_op0B[0x0C] = BOp0C;
- exec_op0B[0x0D] = BOp0D; exec_op0B[0x0E] = BOp0E; exec_op0B[0x0F] = BOp0F;
- exec_op0B[0x12] = BOp12; exec_op0B[0x13] = BOp13; exec_op0B[0x16] = BOp16;
- exec_op0B[0x17] = BOp17; exec_op0B[0x19] = BOp19; exec_op0B[0x1A] = BOp1A;
- exec_op0B[0x1C] = BOp1C; exec_op0B[0x1D] = BOp1D; exec_op0B[0x1E] = BOp1E;
- exec_op0B[0x1F] = BOp1F; exec_op0B[0x20] = BOp20; exec_op0B[0x21] = BOp21;
- exec_op0B[0x22] = BOp22; exec_op0B[0x23] = BOp23; exec_op0B[0x24] = BOp24;
- exec_op0B[0x25] = BOp25; exec_op0B[0x26] = BOp26; exec_op0B[0x27] = BOp27;
- exec_op0B[0x28] = BOp28; exec_op0B[0x29] = BOp29; exec_op0B[0x2A] = BOp2A;
- exec_op0B[0x2B] = BOp2B; exec_op0B[0x2C] = BOp2C; exec_op0B[0x2D] = BOp2D;
- exec_op0B[0x2E] = BOp2E; exec_op0B[0x2F] = BOp2F; exec_op0B[0x30] = BOp30;
- exec_op0B[0x31] = BOp31; exec_op0B[0x32] = BOp32; exec_op0B[0x33] = BOp33;
- exec_op0B[0x34] = BOp34; exec_op0B[0x35] = BOp35; exec_op0B[0x36] = BOp36;
- exec_op0B[0x37] = BOp37; exec_op0B[0x39] = BOp39; exec_op0B[0x3A] = BOp3A;
- exec_op0B[0x3B] = BOp3B; exec_op0B[0x3C] = BOp3C; exec_op0B[0x3D] = BOp3D;
- exec_op0B[0x3E] = BOp3E; exec_op0B[0x3F] = BOp3F; exec_op0B[0x40] = BOp40;
- exec_op0B[0x43] = BOp43; exec_op0B[0x44] = BOp44; exec_op0B[0x46] = BOp46;
- exec_op0B[0x47] = BOp47; exec_op0B[0x48] = BOp48; exec_op0B[0x49] = BOp49;
- exec_op0B[0x4A] = BOp4A; exec_op0B[0x4C] = BOp4C; exec_op0B[0x4D] = BOp4D;
- exec_op0B[0x4F] = BOp4F; exec_op0B[0x50] = BOp50; exec_op0B[0x53] = BOp53;
- exec_op0B[0x54] = BOp54; exec_op0B[0x56] = BOp56; exec_op0B[0x57] = BOp57;
- exec_op0B[0x58] = BOp58; exec_op0B[0x59] = BOp59; exec_op0B[0x5A] = BOp5A;
- exec_op0B[0x5C] = BOp5C; exec_op0B[0x5D] = BOp5D; exec_op0B[0x5F] = BOp5F;
- exec_op0B[0x60] = BOp60; exec_op0B[0x63] = BOp63; exec_op0B[0x64] = BOp64;
- exec_op0B[0x66] = BOp66; exec_op0B[0x67] = BOp67; exec_op0B[0x68] = BOp68;
- exec_op0B[0x69] = BOp69; exec_op0B[0x6A] = BOp6A; exec_op0B[0x6C] = BOp6C;
- exec_op0B[0x6D] = BOp6D; exec_op0B[0x6E] = BOp6E; exec_op0B[0x6F] = BOp6F;
- exec_op0B[0x70] = BOp70; exec_op0B[0x73] = BOp73; exec_op0B[0x74] = BOp74;
- exec_op0B[0x76] = BOp76; exec_op0B[0x77] = BOp77; exec_op0B[0x78] = BOp78;
- exec_op0B[0x79] = BOp79; exec_op0B[0x7A] = BOp7A; exec_op0B[0x7C] = BOp7C;
- exec_op0B[0x7D] = BOp7D; exec_op0B[0x7E] = BOp7E; exec_op0B[0x7F] = BOp7F;
- exec_op0B[0x80] = BOp80; exec_op0B[0x81] = BOp81; exec_op0B[0x82] = BOp82;
- exec_op0B[0x83] = BOp83; exec_op0B[0x84] = BOp84; exec_op0B[0x85] = BOp85;
- exec_op0B[0x86] = BOp86; exec_op0B[0x88] = BOp88; exec_op0B[0x89] = BOp89;
- exec_op0B[0x8A] = BOp8A; exec_op0B[0x8B] = BOp8B; exec_op0B[0x8C] = BOp8C;
- exec_op0B[0x8D] = BOp8D; exec_op0B[0x8E] = BOp8E; exec_op0B[0x90] = BOp90;
- exec_op0B[0x91] = BOp91; exec_op0B[0x92] = BOp92; exec_op0B[0x93] = BOp93;
- exec_op0B[0x94] = BOp94; exec_op0B[0x95] = BOp95; exec_op0B[0x96] = BOp96;
- exec_op0B[0x97] = BOp97; exec_op0B[0x98] = BOp98; exec_op0B[0x99] = BOp99;
- exec_op0B[0x9A] = BOp9A; exec_op0B[0x9B] = BOp9B; exec_op0B[0x9C] = BOp9C;
- exec_op0B[0x9D] = BOp9D; exec_op0B[0x9E] = BOp9E; exec_op0B[0x9F] = BOp9F;
- exec_op0B[0xA0] = BOpA0; exec_op0B[0xA1] = BOpA1; exec_op0B[0xA2] = BOpA2;
- exec_op0B[0xA3] = BOpA3; exec_op0B[0xA4] = BOpA4; exec_op0B[0xA5] = BOpA5;
- exec_op0B[0xA6] = BOpA6; exec_op0B[0xA7] = BOpA7; exec_op0B[0xA8] = BOpA8;
- exec_op0B[0xA9] = BOpA9; exec_op0B[0xAA] = BOpAA; exec_op0B[0xAB] = BOpAB;
- exec_op0B[0xAC] = BOpAC; exec_op0B[0xAD] = BOpAD; exec_op0B[0xAE] = BOpAE;
- exec_op0B[0xAF] = BOpAF; exec_op0B[0xB0] = BOpB0; exec_op0B[0xB1] = BOpB1;
- exec_op0B[0xB2] = BOpB2; exec_op0B[0xB3] = BOpB3; exec_op0B[0xB4] = BOpB4;
- exec_op0B[0xB5] = BOpB5; exec_op0B[0xB6] = BOpB6; exec_op0B[0xB7] = BOpB7;
- exec_op0B[0xB8] = BOpB8; exec_op0B[0xB9] = BOpB9; exec_op0B[0xBA] = BOpBA;
- exec_op0B[0xBB] = BOpBB; exec_op0B[0xBC] = BOpBC; exec_op0B[0xBD] = BOpBD;
- exec_op0B[0xBE] = BOpBE; exec_op0B[0xBF] = BOpBF; exec_op0B[0xC0] = BOpC0;
- exec_op0B[0xC1] = BOpC1; exec_op0B[0xC2] = BOpC2; exec_op0B[0xC3] = BOpC3;
- exec_op0B[0xC4] = BOpC4; exec_op0B[0xC5] = BOpC5; exec_op0B[0xC6] = BOpC6;
- exec_op0B[0xC8] = BOpC8; exec_op0B[0xC9] = BOpC9; exec_op0B[0xCA] = BOpCA;
- exec_op0B[0xCB] = BOpCB; exec_op0B[0xCC] = BOpCC;
- exec_op0B[0xCE] = BOpCE; exec_op0B[0xD0] = BOpD0; exec_op0B[0xD1] = BOpD1;
- exec_op0B[0xD2] = BOpD2; exec_op0B[0xD3] = BOpD3; exec_op0B[0xD4] = BOpD4;
- exec_op0B[0xD5] = BOpD5; exec_op0B[0xD6] = BOpD6; exec_op0B[0xD7] = BOpD7;
- exec_op0B[0xD8] = BOpD8; exec_op0B[0xD9] = BOpD9; exec_op0B[0xDA] = BOpDA;
- exec_op0B[0xDB] = BOpDB; exec_op0B[0xDC] = BOpDC; exec_op0B[0xDD] = BOpDD;
- exec_op0B[0xDE] = BOpDE; exec_op0B[0xDF] = BOpDF; exec_op0B[0xE0] = BOpE0;
- exec_op0B[0xE1] = BOpE1; exec_op0B[0xE2] = BOpE2; exec_op0B[0xE3] = BOpE3;
- exec_op0B[0xE4] = BOpE4; exec_op0B[0xE5] = BOpE5; exec_op0B[0xE6] = BOpE6;
- exec_op0B[0xE7] = BOpE7; exec_op0B[0xE8] = BOpE8; exec_op0B[0xE9] = BOpE9;
- exec_op0B[0xEA] = BOpEA; exec_op0B[0xEB] = BOpEB; exec_op0B[0xEC] = BOpEC;
- exec_op0B[0xED] = BOpED; exec_op0B[0xEE] = BOpEE; exec_op0B[0xEF] = BOpEF;
- exec_op0B[0xF0] = BOpF0;
- exec_op0B[0xF1] = BOpF1; exec_op0B[0xF2] = BOpF2; exec_op0B[0xF3] = BOpF3;
- exec_op0B[0xF4] = BOpF4; exec_op0B[0xF5] = BOpF5; exec_op0B[0xF6] = BOpF6;
- exec_op0B[0xF7] = BOpF7; exec_op0B[0xF8] = BOpF8; exec_op0B[0xF9] = BOpF9;
- exec_op0B[0xFA] = BOpFA; exec_op0B[0xFB] = BOpFB; exec_op0B[0xFC] = BOpFC;
- exec_op0B[0xFD] = BOpFD; exec_op0B[0xFE] = BOpFE; exec_op0B[0xFF] = BOpFF;
-
- exec_op1B[0x21] = BOp1021; exec_op1B[0x22] = BOp1022; exec_op1B[0x23] = BOp1023;
- exec_op1B[0x24] = BOp1024; exec_op1B[0x25] = BOp1025; exec_op1B[0x26] = BOp1026;
- exec_op1B[0x27] = BOp1027; exec_op1B[0x28] = BOp1028; exec_op1B[0x29] = BOp1029;
- exec_op1B[0x2A] = BOp102A; exec_op1B[0x2B] = BOp102B; exec_op1B[0x2C] = BOp102C;
- exec_op1B[0x2D] = BOp102D; exec_op1B[0x2E] = BOp102E; exec_op1B[0x2F] = BOp102F;
- exec_op1B[0x3F] = BOp103F; exec_op1B[0x83] = BOp1083; exec_op1B[0x8C] = BOp108C;
- exec_op1B[0x8E] = BOp108E; exec_op1B[0x93] = BOp1093; exec_op1B[0x9C] = BOp109C;
- exec_op1B[0x9E] = BOp109E; exec_op1B[0x9F] = BOp109F; exec_op1B[0xA3] = BOp10A3;
- exec_op1B[0xAC] = BOp10AC; exec_op1B[0xAE] = BOp10AE; exec_op1B[0xAF] = BOp10AF;
- exec_op1B[0xB3] = BOp10B3; exec_op1B[0xBC] = BOp10BC; exec_op1B[0xBE] = BOp10BE;
- exec_op1B[0xBF] = BOp10BF; exec_op1B[0xCE] = BOp10CE; exec_op1B[0xDE] = BOp10DE;
- exec_op1B[0xDF] = BOp10DF; exec_op1B[0xEE] = BOp10EE; exec_op1B[0xEF] = BOp10EF;
- exec_op1B[0xFE] = BOp10FE; exec_op1B[0xFF] = BOp10FF;
-
- exec_op2B[0x3F] = BOp113F; exec_op2B[0x83] = BOp1183; exec_op2B[0x8C] = BOp118C;
- exec_op2B[0x93] = BOp1193; exec_op2B[0x9C] = BOp119C; exec_op2B[0xA3] = BOp11A3;
- exec_op2B[0xAC] = BOp11AC; exec_op2B[0xB3] = BOp11B3; exec_op2B[0xBC] = BOp11BC;
-}
-
-//
-// Function to execute one 6809 instruction
-//
-void Execute_6809B(long num_of_instrs_to_exec)
-{
- for(long i=0; i<num_of_instrs_to_exec; i++)
- {
- BYTE opcode = FetchB(); // Get the opcode
- if (opcode == 0x10) { exec_op1B[FetchB()](); goto EXE_NEXT; }
- if (opcode == 0x11) { exec_op2B[FetchB()](); goto EXE_NEXT; }
- exec_op0B[opcode]();
- EXE_NEXT:
-
- if (iclockB > 24550) // Slightly faster IRQs for SUB processor
- {
- iclockB = 0;
- if (!(ccrB&0x10) /*&& (!inter)*/) // Process an interrupt?
- {
- ccrB |= 0x80; // Set E
- WrMemB(--srB, pcrB&0xFF); WrMemB(--srB, pcrB>>8); // Save all regs...
- WrMemB(--srB, urB&0xFF); WrMemB(--srB, urB>>8);
- WrMemB(--srB, yrB&0xFF); WrMemB(--srB, yrB>>8);
- WrMemB(--srB, xrB&0xFF); WrMemB(--srB, xrB>>8);
- WrMemB(--srB, dprB); WrMemB(--srB, brB);
- WrMemB(--srB, arB); WrMemB(--srB, ccrB);
- ccrB |= 0x50; // Set F,I
- pcrB = (RdMemB(0xFFF8)<<8) | RdMemB(0xFFF9); // And do it!
- }
- }
- }
-}
+++ /dev/null
-// Virtual 6809B Header file
-//
-// by James L. Hammons
-//
-// (c) 1998 Underground Software
-
-#define BYTE unsigned char
-#define WORD unsigned short int
-
-// Function prototypes
-
-void Init_6809B(void); // Initialize function pointers
-void Execute_6809B(long); // Function to execute 6809 instructions
projects / thunder / commitdiff