Apple-2-Tools
/
AppleIIGo
mirror of https://github.com/sicklittlemonkey/AppleIIGo.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
AppleIIGo/Source/EmAppleII.java

1187 lines
30 KiB
Java
Raw Blame History

/**
* AppleIIGo
* Apple II Emulator for J2ME
* (C) 2006 by Marc S. Ressl(ressl@lonetree.com)
* Released under the GPL
*/
import java.io.*;
public class EmAppleII extends Em6502 implements Runnable {
/*
* Apple II memory map
*/
public static final int MEM_PHYS_ZP = 0x00000;
public static final int MEM_PHYS_STACK = 0x00100;
public static final int MEM_PHYS_RAM1 = 0x00200;
public static final int MEM_PHYS_TEXT = 0x00400;
public static final int MEM_PHYS_RAM2 = 0x00800;
public static final int MEM_PHYS_HIRES = 0x02000;
public static final int MEM_PHYS_RAM3 = 0x04000;
public static final int MEM_PHYS_IO = 0x0c000;
public static final int MEM_PHYS_ROM_LOW = 0x0d000;
public static final int MEM_PHYS_ROM_HIGH = 0x0e000;
public static final int MEM_MAIN_RAM1 = 0x00200;
public static final int MEM_MAIN_TEXT = 0x00400;
public static final int MEM_MAIN_RAM2 = 0x00800;
public static final int MEM_MAIN_HIRES = 0x02000;
public static final int MEM_MAIN_RAM3 = 0x04000;
public static final int MEM_MAIN_LC1 = 0x0c000;
public static final int MEM_MAIN_LC2 = 0x0d000;
public static final int MEM_MAIN_LC_HIGH = 0x0e000;
public static final int MEM_AUX_ZP = 0x10000;
public static final int MEM_AUX_STACK = 0x10100;
public static final int MEM_AUX_RAM1 = 0x10200;
public static final int MEM_AUX_TEXT = 0x10400;
public static final int MEM_AUX_RAM2 = 0x10800;
public static final int MEM_AUX_HIRES = 0x12000;
public static final int MEM_AUX_RAM3 = 0x14000;
public static final int MEM_AUX_LC1 = 0x1c000;
public static final int MEM_AUX_LC2 = 0x1d000;
public static final int MEM_AUX_LC_HIGH = 0x1e000;
public static final int MEM_ROM_MAIN_LOW = 0x20000;
public static final int MEM_ROM_MAIN_HIGH = 0x21000;
public static final int MEM_ROM_INTERNAL = 0x23000;
public static final int MEM_ROM_EXTERNAL = 0x24000;
public static final int MEM_MAIN_ZP = 0x25000;
public static final int MEM_MAIN_STACK = 0x25100;
public static final int MEM_WASTE = 0x25200;
public static final int MEM_END = 0x28000;
// Peripherals
public Paddle paddle;
public Peripheral[] slots;
// Graphics (dirty buffer every 0x80 bytes)
public int graphicsMode;
public boolean[] graphicsDirty = new boolean[0x10000 >> 7];
public static final int GR_TEXT = (1 << 0);
public static final int GR_MIXMODE = (1 << 1);
public static final int GR_PAGE2 = (1 << 2);
public static final int GR_HIRES = (1 << 3);
public static final int GR_80STORE = (1 << 4);
public static final int GR_80CHAR = (1 << 5);
public static final int GR_ALTCHAR = (1 << 6);
public static final int GR_DHIRES = (1 << 7);
// Sound
public static final int SPEAKER_FLIPS_SIZE = 4096;
public static final int SPEAKER_FLIPS_MASK = 4095;
public int speakerFlips[] = new int[SPEAKER_FLIPS_SIZE];
public int speakerFlipsPointer = 0;
// Default ROM
private static final int[] defaultRom = {
// Reset routine
0xad,0x51,0xc0,
0xa9,0xa0,
0xa2,0xff,0x9d,0xff,0x03,0xca,0xd0,0xfa,
0xa2,0xff,0x9d,0xff,0x04,0xca,0xd0,0xfa,
0xa2,0xff,0x9d,0xff,0x05,0xca,0xd0,0xfa,
0xa2,0xff,0x9d,0xff,0x06,0xca,0xd0,0xfa,
0xa2,0x27,0xbd,0xb8,0xfe,0x9d,0x80,0x04,0xca,0x10,0xf7,
0xa2,0x27,0xbd,0xe0,0xfe,0x9d,0x00,0x05,0xca,0x10,0xf7,
0xa2,0x27,0xbd,0x08,0xff,0x9d,0x80,0x05,0xca,0x10,0xf7,
0xa2,0x27,0xbd,0x30,0xff,0x9d,0x00,0x06,0xca,0x10,0xf7,
0xa2,0x27,0xbd,0x58,0xff,0x9d,0x80,0x07,0xca,0x10,0xf7,
0xa2,0x27,0xbd,0x80,0xff,0x9d,0x28,0x04,0xca,0x10,0xf7,
0xa2,0x27,0xbd,0xa8,0xff,0x9d,0x00,0x07,0xca,0x10,0xf7,
0xa2,0x27,0xbd,0xd0,0xff,0x9d,0x00,0x07,0xca,0x10,0xf7,
0x4c,0xad,0xfe,
0xea,0xea,0xea,0xea,0xea,0xea,0xea,0xea,
// Text message
0xa0,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xa0,
0xa0,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x01,0x10,0x10,0x0c,0x05,0x09,0x09,
0x07,0x0f,0x20,0x12,0x05,0x11,0x15,0x09,0x12,0x05,0x13,0x20,0x01,0x0e,0x20,0x20,
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xa0, // APPLEIIGO REQUIRES AN
0xa0,0x20,0x20,0x20,0x20,0x20,0x20,0x01,0x10,0x10,0x0c,0x05,0x20,0x09,0x09,0x20,
0x12,0x0f,0x0d,0x20,0x09,0x0d,0x01,0x07,0x05,0x20,0x14,0x0f,0x20,0x12,0x15,0x0e,
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xa0, // APPLE II ROM IMAGE TO RUN
0xa0,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xa0,
0xa0,0xc6,0xcf,0xd2,0xa0,0xcd,0xcf,0xd2,0xc5,0xa0,0xc9,0xce,0xc6,0xcf,0xd2,0xcd,
0xc1,0xd4,0xc9,0xcf,0xce,0xa0,0xd0,0xcc,0xc5,0xc1,0xd3,0xc5,0xa0,0xc3,0xcc,0xc9,
0xc3,0xcb,0xa0,0xcf,0xce,0xa0,0xa0,0xa0, // FOR MORE INFORMATION PLEASE CLICK ON
0xa0,0xd4,0xc8,0xc5,0xa0,0xc1,0xd0,0xd0,0xcc,0xc5,0xc9,0xc9,0xc7,0xcf,0xa0,0xcc,
0xcf,0xc7,0xcf,0xa0,0xc2,0xc5,0xcc,0xcf,0xd7,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,
0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0, // THE APPLEIIGO LOGO BELOW
0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,
0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,
0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,
0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,
0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,
0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,0xa0,
// Interrupt vectors
0x00,0x00,0x30,0xfe,0x30,0xfe,0x30,0xfe
};
// Emulator
private boolean isRestart;
private int cpuSpeed;
private int clocksPerInterval;
private int refreshRate;
private long refreshInterval;
private long refreshDelayCumulative;
private long refreshDelayPerSecond;
private long refreshCycle;
// Keyboard
private int keyboardLatch;
// Memory offsets
private int[] memoryReadOffset = new int[0x101];
private int[] memoryWriteOffset = new int[0x101];
// Language card state
private boolean isLcReadEnable;
private boolean isLcWriteEnable;
private boolean isLcBank2;
// Apple IIe state
private boolean isRomInternal;
private boolean isRomC3External;
private boolean isAuxRead;
private boolean isAuxWrite;
private boolean isAuxZeroPage;
private boolean isVideoVBL;
// Thread stuff
private boolean isPaused = true;
private Thread thread;
private String threadError = null;
// Step mode
private boolean isStepMode = false;
private boolean isNextStep = false;
private int stepCount;
/**
* Apple II class constructor
*/
public EmAppleII() {
Em6502();
// Allocate compute memory
mem = new byte[MEM_END];
// Initialize CPU
initMemoryMap();
setRandomSeed();
setCpuSpeed(1000);
reset();
// Setup default ROM
loadDefaultRom();
// Setup paddles
paddle = new Paddle(this);
// Setup expansion slots
slots = new Peripheral[8];
for (int slot = 1; slot < 8; slot++)
setPeripheral(new Peripheral(), slot);
}
/**
* Set random seed (so programs start randomly)
*/
public void setRandomSeed() {
mem[0xcd] = (byte) System.currentTimeMillis();
}
/**
* Load default ROM
*/
public void loadDefaultRom() {
for(int offset = 0; offset < 0x1d0; offset++)
mem[(MEM_ROM_MAIN_LOW + 0x3000 - 0x1d0) + offset] = (byte) defaultRom[offset];
}
/**
* Loads ROM
*/
private boolean isValidRom(byte[] rom, int offset) {
// Integer BASIC?
if ((rom[offset + 0x1000] & 0xff) == 0x20)
return true;
// Applesoft BASIC?
if ((rom[offset + 0x1000] & 0xff) == 0x4c)
return true;
return false;
}
public boolean loadRom(InputStream is) {
byte[] rom = new byte[0x8000];
int offset = 0;
try {
is.read(rom, 0, 0x08000);
} catch (IOException e) {
return false;
}
if (isValidRom(rom, 0x0))
offset = 0x0;
else if (isValidRom(rom, 0x1000))
offset = 0x1000;
else if (isValidRom(rom, 0x2000))
offset = 0x2000;
else
return false;
// Copy main ROM
System.arraycopy(rom, offset, mem, MEM_ROM_MAIN_LOW, 0x03000);
// Copy internal ROM
System.arraycopy(rom, offset + 0x3000, mem, MEM_ROM_INTERNAL + 0x00000, 0x01000);
System.arraycopy(rom, offset + 0x3800, mem, MEM_ROM_EXTERNAL + 0x00800, 0x00800);
return true;
}
/**
* Set peripheral
*/
public void setPeripheral(Peripheral peripheral, int slot) {
slots[slot] = peripheral;
int offset = MEM_ROM_EXTERNAL + (slot << 8);
for(int i = 0; i < 0x100; i++)
mem[offset + i] = (byte) peripheral.memoryRead(i);
}
/**
* Set pause state
*/
public void setPaused(boolean value) {
if (isPaused == value)
return;
isPaused = value;
if (isPaused) {
try {
thread.join(1000);
} catch (InterruptedException e) {
}
} else {
thread = new Thread(this);
thread.start();
}
}
/**
* Get pause state
*/
public boolean getPaused() {
return isPaused;
}
/**
* Keyboard push key function
*/
public void setKeyLatch(int key) {
key &= 0x7f;
keyboardLatch = (key | 0x80);
}
/**
* Restart
*/
public void restart() {
isRestart = true;
assertReset();
}
/**
* Reset
*/
public void reset() {
isRestart = false;
assertReset();
}
/**
* Set CPU speed
*/
public void setCpuSpeed(int value) {
if (value < 0)
return;
cpuSpeed = value;
refreshRate = 20;
refreshInterval = (int) (1000.0 / refreshRate);
clocksPerInterval = (int) (cpuSpeed * refreshInterval);
}
/**
* Get debug mode
*/
public int getCpuSpeed() {
return cpuSpeed;
}
/**
* Get refresh rate
*/
public int getRefreshRate() {
return refreshRate;
}
/**
* Set debug mode
*/
public void setStepMode(boolean value) {
isNextStep = false;
isStepMode = value;
}
/**
* Get debug mode
*/
public boolean getStepMode() {
return isStepMode;
}
/**
* Step instruction in debug mode
*/
public void stepInstructions(int value) {
if (value <= 0)
return;
stepCount = value;
isNextStep = true;
}
/**
* Zero pad
*/
private String zeroPad(String value, int length) {
length -= value.length();
while (length > 0) {
value = "0" + value;
length--;
}
return value;
}
/**
* Print a hex value
*/
private String formatHex(int value, int length) {
return zeroPad(Integer.toString(value, 16), length);
}
/**
* Print a decimal value
*/
private String formatDec(int value, int commaPos) {
String valueString = zeroPad(Integer.toString(value), commaPos + 1);
int length = valueString.length();
return valueString.substring(0, length - commaPos) +
"." + valueString.substring(length - commaPos, length);
}
/**
* Step instruction in debug mode
*/
public String getStatInfo() {
String statInfo = "";
long cpuSpeedCurrent;
// Calculate effective CPU speed
if (isPaused || isStepMode)
cpuSpeedCurrent = 0;
else if (refreshDelayPerSecond > 1000)
cpuSpeedCurrent = cpuSpeed * 1000 / refreshDelayPerSecond;
else
cpuSpeedCurrent = cpuSpeed;
// Return A, X, Y, S, P, PC
statInfo += " A=" + formatHex(A, 2);
statInfo += " X=" + formatHex(X, 2);
statInfo += " Y=" + formatHex(Y, 2);
statInfo += " P=" + formatHex(P, 2);
statInfo += " S=" + formatHex(S, 2);
statInfo += "\n";
statInfo += " PC=" + formatHex(PC, 4) + "\n";
statInfo += " [PC]=";
statInfo += " " + formatHex(memoryRead(PC + 0), 2);
statInfo += " " + formatHex(memoryRead(PC + 1), 2);
statInfo += " " + formatHex(memoryRead(PC + 2), 2);
statInfo += " " + formatHex(memoryRead(PC + 3), 2);
statInfo += "\n";
statInfo += " MHZ=" + formatDec((int) cpuSpeedCurrent, 3) + " [" + refreshDelayPerSecond + " ms/s]\n";
if (threadError != null)
statInfo += threadError + "\n";
return statInfo;
}
/**
* Noise function
*
* We assume a "sort-of" floating bus
* (spanning memory locations 0000-3FFF)
*
* Correct way: We should look up the current video mode,
* and sample according to what is being shown.
*/
public int noise() {
return mem[clock & 0x3fff];
}
/**
* Read memory function
*
* @param address Address
*/
protected int memoryRead(int address) {
if ((address & 0xff00) == 0xc000)
return ioRead(address);
return (mem[address + memoryReadOffset[address >> 8]] & 0xff);
}
/**
* Write memory function
*
* @param adderss Address
* @param value value
*/
protected void memoryWrite(int address, int value) {
if ((address & 0xff00) == 0xc000)
ioWrite(address, value);
else {
mem[address + memoryWriteOffset[address >> 8]] = (byte) value;
graphicsDirty[address >> 7] = true;
}
}
/**
* Update memory maps
*/
private void updateMainMemoryMap() {
int ramReadOffset, textReadOffset, hiresReadOffset;
int ramWriteOffset, textWriteOffset, hiresWriteOffset;
boolean isPage2 = ((graphicsMode & GR_PAGE2) != 0);
boolean is80STORE = ((graphicsMode & GR_80STORE) != 0);
boolean isHires = ((graphicsMode & GR_HIRES) != 0);
textReadOffset = hiresReadOffset = ramReadOffset = isAuxRead ?
(MEM_AUX_RAM1 - MEM_PHYS_RAM1) : (MEM_MAIN_RAM1 - MEM_PHYS_RAM1);
textWriteOffset = hiresWriteOffset = ramWriteOffset = isAuxWrite ?
(MEM_AUX_RAM1 - MEM_PHYS_RAM1) : (MEM_MAIN_RAM1 - MEM_PHYS_RAM1);
if (is80STORE) {
textWriteOffset = textReadOffset = isPage2 ? (MEM_AUX_TEXT - MEM_PHYS_TEXT) :
(MEM_MAIN_TEXT - MEM_PHYS_TEXT);
if (isHires)
hiresWriteOffset = hiresReadOffset = textReadOffset;
}
memoryReadOffset[0x02] = memoryReadOffset[0x03] = ramReadOffset;
memoryWriteOffset[0x02] = memoryWriteOffset[0x03] = ramWriteOffset;
memoryReadOffset[0x04] = memoryReadOffset[0x05] = memoryReadOffset[0x06] = memoryReadOffset[0x07] = textReadOffset;
memoryWriteOffset[0x04] = memoryWriteOffset[0x05] = memoryWriteOffset[0x06] = memoryWriteOffset[0x07] = textWriteOffset;
for (int offset = 0x08; offset < 0x20; offset++) {
memoryReadOffset[offset] = ramReadOffset;
memoryWriteOffset[offset] = ramWriteOffset;
}
for (int offset = 0x20; offset < 0x40; offset++) {
memoryReadOffset[offset] = hiresReadOffset;
memoryWriteOffset[offset] = hiresWriteOffset;
}
for (int offset = 0x40; offset < 0xc0; offset++) {
memoryReadOffset[offset] = ramReadOffset;
memoryWriteOffset[offset] = ramWriteOffset;
}
}
private void updateIOMemoryMap() {
int romOffset;
if (isRomInternal)
romOffset = (MEM_ROM_INTERNAL - MEM_PHYS_IO);
else
romOffset = (MEM_ROM_EXTERNAL - MEM_PHYS_IO);
for (int offset = 0xc1; offset < 0xd0; offset++)
memoryReadOffset[offset] = romOffset;
if (isRomC3External)
memoryReadOffset[0xc3] = (MEM_ROM_EXTERNAL - MEM_PHYS_IO);
else
memoryReadOffset[0xc3] = (MEM_ROM_INTERNAL - MEM_PHYS_IO);
}
private void initIOMemoryMap() {
for (int offset = 0xc1; offset < 0xd0; offset++)
memoryWriteOffset[offset] = (MEM_WASTE - MEM_PHYS_IO);
}
private void updateLCMemoryMap() {
int lcReadOffset, lcReadOffsetHigh;
int lcWriteOffset, lcWriteOffsetHigh;
if (!isLcReadEnable) {
lcReadOffset = (MEM_ROM_MAIN_LOW - MEM_PHYS_ROM_LOW);
lcReadOffsetHigh = (MEM_ROM_MAIN_LOW - MEM_PHYS_ROM_LOW);
} else if (isAuxZeroPage) {
lcReadOffset = isLcBank2 ? (MEM_AUX_LC2 - MEM_PHYS_ROM_LOW) : (MEM_AUX_LC1 - MEM_PHYS_ROM_LOW);
lcReadOffsetHigh = (MEM_AUX_LC_HIGH - MEM_PHYS_ROM_HIGH);
} else {
lcReadOffset = isLcBank2 ? (MEM_MAIN_LC2 - MEM_PHYS_ROM_LOW) : (MEM_MAIN_LC1 - MEM_PHYS_ROM_LOW);
lcReadOffsetHigh = (MEM_MAIN_LC_HIGH - MEM_PHYS_ROM_HIGH);
}
if (!isLcWriteEnable) {
lcWriteOffset = (MEM_WASTE - MEM_PHYS_ROM_LOW);
lcWriteOffsetHigh = (MEM_WASTE - MEM_PHYS_ROM_HIGH);
} else if (isAuxZeroPage) {
lcWriteOffset = isLcBank2 ? (MEM_AUX_LC2 - MEM_PHYS_ROM_LOW) : (MEM_AUX_LC1 - MEM_PHYS_ROM_LOW);
lcWriteOffsetHigh = (MEM_AUX_LC_HIGH - MEM_PHYS_ROM_HIGH);
} else {
lcWriteOffset = isLcBank2 ? (MEM_MAIN_LC2 - MEM_PHYS_ROM_LOW) : (MEM_MAIN_LC1 - MEM_PHYS_ROM_LOW);
lcWriteOffsetHigh = (MEM_MAIN_LC_HIGH - MEM_PHYS_ROM_HIGH);
}
for (int offset = 0xd0; offset < 0xe0; offset++) {
memoryReadOffset[offset] = lcReadOffset;
memoryWriteOffset[offset] = lcWriteOffset;
}
for (int offset = 0xe0; offset < 0x100; offset++) {
memoryReadOffset[offset] = lcReadOffsetHigh;
memoryWriteOffset[offset] = lcWriteOffsetHigh;
}
}
void initMemoryMap() {
initIOMemoryMap();
updateMainMemoryMap();
updateIOMemoryMap();
updateLCMemoryMap();
}
/**
* Apple I/O reads
*
* @param address Address
*/
private int ioRead(int address) {
address &= 0xff;
if (address >= 0x90)
return slots[(address & 0x70) >> 4].ioRead(address);
switch (address) {
case 0x00: case 0x01: case 0x02: case 0x03:
case 0x04: case 0x05: case 0x06: case 0x07:
case 0x08: case 0x09: case 0x0a: case 0x0b:
case 0x0c: case 0x0d: case 0x0e: case 0x0f:
// Keyboard data
return keyboardLatch;
case 0x10:
// Keyboard strobe
keyboardLatch &= 0x7f;
return keyboardLatch;
case 0x11:
// Reading from LC Bank 2?
return (keyboardLatch & 0x7f) | (isLcBank2 ? 0x80 : 0x00);
case 0x12:
// Reading from LC?
return (keyboardLatch & 0x7f) | (isLcReadEnable ? 0x80 : 0x00);
case 0x13:
// Reading aux memory?
return (keyboardLatch & 0x7f) | (isAuxRead ? 0x80 : 0x00);
case 0x14:
// Writing aux memory?
return (keyboardLatch & 0x7f) | (isAuxWrite ? 0x80 : 0x00);
case 0x15:
// Using internal slot ROM?
return (keyboardLatch & 0x7f) | (isRomInternal ? 0x80 : 0x00);
case 0x16:
// Using slot zero page+stack+LC?
return (keyboardLatch & 0x7f) | (isAuxZeroPage ? 0x80 : 0x00);
case 0x17:
// Using external slot 3 ROM?
return (keyboardLatch & 0x7f) | (isRomC3External ? 0x80 : 0x00);
case 0x18:
// 80STORE?
return (keyboardLatch & 0x7f) | (((graphicsMode & GR_80STORE) != 0) ? 0x80 : 0x00);
case 0x19:
// VBL Signal low?
isVideoVBL = !isVideoVBL;
return (keyboardLatch & 0x7f) | (isVideoVBL ? 0x80 : 0x00);
case 0x1a:
// Using text mode?
return (keyboardLatch & 0x7f) | (((graphicsMode & GR_TEXT) != 0) ? 0x80 : 0x00);
case 0x1b:
// Using mixed mode?
return (keyboardLatch & 0x7f) | (((graphicsMode & GR_MIXMODE) != 0) ? 0x80 : 0x00);
case 0x1c:
// Using page 2?
return (keyboardLatch & 0x7f) | (((graphicsMode & GR_PAGE2) != 0) ? 0x80 : 0x00);
case 0x1d:
// Using hires?
return (keyboardLatch & 0x7f) | (((graphicsMode & GR_HIRES) != 0) ? 0x80 : 0x00);
case 0x1e:
// Using alt charset?
return (keyboardLatch & 0x7f) | (((graphicsMode & GR_ALTCHAR) != 0) ? 0x80 : 0x00);
case 0x1f:
// Using 80-column display mode?
return (keyboardLatch & 0x7f) | (((graphicsMode & GR_80CHAR) != 0) ? 0x80 : 0x00);
case 0x20: case 0x21: case 0x22: case 0x23:
case 0x24: case 0x25: case 0x26: case 0x27:
case 0x28: case 0x29: case 0x2a: case 0x2b:
case 0x2c: case 0x2d: case 0x2e: case 0x2f:
// Cassette output
break;
case 0x30: case 0x31: case 0x32: case 0x33:
case 0x34: case 0x35: case 0x36: case 0x37:
case 0x38: case 0x39: case 0x3a: case 0x3b:
case 0x3c: case 0x3d: case 0x3e: case 0x3f:
// Speaker
speakerFlips[speakerFlipsPointer] = clock;
speakerFlipsPointer = (speakerFlipsPointer + 1) & SPEAKER_FLIPS_MASK;
break;
case 0x40: case 0x41: case 0x42: case 0x43:
case 0x44: case 0x45: case 0x46: case 0x47:
case 0x48: case 0x49: case 0x4a: case 0x4b:
case 0x4c: case 0x4d: case 0x4e: case 0x4f:
// Game strobe
break;
case 0x50:
graphicsMode &= ~GR_TEXT;
break;
case 0x51:
graphicsMode |= GR_TEXT;
break;
case 0x52:
graphicsMode &= ~GR_MIXMODE;
break;
case 0x53:
graphicsMode |= GR_MIXMODE;
break;
case 0x54:
graphicsMode &= ~GR_PAGE2;
updateMainMemoryMap();
break;
case 0x55:
graphicsMode |= GR_PAGE2;
updateMainMemoryMap();
break;
case 0x56:
graphicsMode &= ~GR_HIRES;
updateMainMemoryMap();
break;
case 0x57:
graphicsMode |= GR_HIRES;
updateMainMemoryMap();
break;
case 0x58: case 0x59: case 0x5a: case 0x5b:
case 0x5c: case 0x5d:
// Annunciators
break;
case 0x5e:
graphicsMode |= GR_DHIRES;
break;
case 0x5f:
graphicsMode &= ~GR_DHIRES;
break;
case 0x60:
case 0x68:
// (Also cassette input)
return paddle.getButtonRegister(3);
case 0x61:
case 0x69:
return paddle.getButtonRegister(0);
case 0x62:
case 0x6a:
return paddle.getButtonRegister(1);
case 0x63:
case 0x6b:
return paddle.getButtonRegister(2);
case 0x64:
case 0x6c:
return paddle.getPaddleRegister(0);
case 0x65:
case 0x6d:
return paddle.getPaddleRegister(1);
case 0x66:
case 0x6e:
return paddle.getPaddleRegister(2);
case 0x67:
case 0x6f:
return paddle.getPaddleRegister(3);
case 0x70: case 0x71: case 0x72: case 0x73:
case 0x74: case 0x75: case 0x76: case 0x77:
case 0x78: case 0x79: case 0x7a: case 0x7b:
case 0x7c: case 0x7d: case 0x7e: case 0x7f:
paddle.triggerRegister();
break;
case 0x80:
case 0x84:
isLcBank2 = true;
isLcReadEnable = true;
isLcWriteEnable = false;
updateLCMemoryMap();
break;
case 0x81:
case 0x85:
isLcBank2 = true;
isLcReadEnable = false;
isLcWriteEnable = true;
updateLCMemoryMap();
break;
case 0x82:
case 0x86:
isLcBank2 = true;
isLcReadEnable = false;
isLcWriteEnable = false;
updateLCMemoryMap();
break;
case 0x83:
case 0x87:
isLcBank2 = true;
isLcReadEnable = true;
isLcWriteEnable = true;
updateLCMemoryMap();
break;
case 0x88:
case 0x8c:
isLcBank2 = false;
isLcReadEnable = true;
isLcWriteEnable = false;
updateLCMemoryMap();
break;
case 0x89:
case 0x8d:
isLcBank2 = false;
isLcReadEnable = false;
isLcWriteEnable = true;
updateLCMemoryMap();
break;
case 0x8a:
case 0x8e:
isLcBank2 = false;
isLcReadEnable = false;
isLcWriteEnable = false;
updateLCMemoryMap();
break;
case 0x8b:
case 0x8f:
isLcBank2 = false;
isLcReadEnable = true;
isLcWriteEnable = true;
updateLCMemoryMap();
break;
case 0x90: case 0x91: case 0x92: case 0x93:
case 0x94: case 0x95: case 0x96: case 0x97:
case 0x98: case 0x99: case 0x9a: case 0x9b:
case 0x9c: case 0x9d: case 0x9e: case 0x9f:
return slots[1].ioRead(address);
case 0xa0: case 0xa1: case 0xa2: case 0xa3:
case 0xa4: case 0xa5: case 0xa6: case 0xa7:
case 0xa8: case 0xa9: case 0xaa: case 0xab:
case 0xac: case 0xad: case 0xae: case 0xaf:
return slots[2].ioRead(address);
case 0xb0: case 0xb1: case 0xb2: case 0xb3:
case 0xb4: case 0xb5: case 0xb6: case 0xb7:
case 0xb8: case 0xb9: case 0xba: case 0xbb:
case 0xbc: case 0xbd: case 0xbe: case 0xbf:
return slots[3].ioRead(address);
case 0xc0: case 0xc1: case 0xc2: case 0xc3:
case 0xc4: case 0xc5: case 0xc6: case 0xc7:
case 0xc8: case 0xc9: case 0xca: case 0xcb:
case 0xcc: case 0xcd: case 0xce: case 0xcf:
return slots[4].ioRead(address);
case 0xd0: case 0xd1: case 0xd2: case 0xd3:
case 0xd4: case 0xd5: case 0xd6: case 0xd7:
case 0xd8: case 0xd9: case 0xda: case 0xdb:
case 0xdc: case 0xdd: case 0xde: case 0xdf:
return slots[5].ioRead(address);
case 0xe0: case 0xe1: case 0xe2: case 0xe3:
case 0xe4: case 0xe5: case 0xe6: case 0xe7:
case 0xe8: case 0xe9: case 0xea: case 0xeb:
case 0xec: case 0xed: case 0xee: case 0xef:
return slots[6].ioRead(address);
case 0xf0: case 0xf1: case 0xf2: case 0xf3:
case 0xf4: case 0xf5: case 0xf6: case 0xf7:
case 0xf8: case 0xf9: case 0xfa: case 0xfb:
case 0xfc: case 0xfd: case 0xfe: case 0xff:
return slots[7].ioRead(address);
}
return noise();
}
/**
* Apple I/O writes
*
* @param address Address
* @param value Value
*/
private void ioWrite(int address, int value) {
address &= 0xff;
if (address >= 0x90) {
slots[(address & 0x70) >> 4].ioWrite(address, value);
return;
}
switch (address) {
case 0x00:
// 80STORE off
graphicsMode &= ~GR_80STORE;
updateMainMemoryMap();
return;
case 0x01:
// 80STORE on
graphicsMode |= GR_80STORE;
updateMainMemoryMap();
return;
case 0x02:
// Read aux mem off
isAuxRead = false;
updateMainMemoryMap();
return;
case 0x03:
// Read aux mem on
isAuxRead = true;
updateMainMemoryMap();
return;
case 0x04:
// Write aux mem off
isAuxWrite = false;
updateMainMemoryMap();
return;
case 0x05:
// Write aux mem on
isAuxWrite = true;
updateMainMemoryMap();
return;
case 0x06:
// Do not use internal ROM
isRomInternal = false;
updateIOMemoryMap();
return;
case 0x07:
// Use internal ROM
isRomInternal = true;
updateIOMemoryMap();
return;
case 0x08:
if (isAuxZeroPage) {
// Physically get main zero page
System.arraycopy(mem, MEM_PHYS_ZP, mem, MEM_AUX_ZP, 0x200);
System.arraycopy(mem, MEM_MAIN_ZP, mem, MEM_PHYS_ZP, 0x200);
}
// Aux zero page off
isAuxZeroPage = false;
updateLCMemoryMap();
return;
case 0x09:
if (!isAuxZeroPage) {
// Physically get aux zero page
System.arraycopy(mem, MEM_PHYS_ZP, mem, MEM_MAIN_ZP, 0x200);
System.arraycopy(mem, MEM_AUX_ZP, mem, MEM_PHYS_ZP, 0x200);
}
// Aux zero page on
isAuxZeroPage = true;
updateLCMemoryMap();
return;
case 0x0a:
// Do not use external slot 3 ROM
isRomC3External = false;
updateIOMemoryMap();
return;
case 0x0b:
// Use external slot 3 ROM
isRomC3External = true;
updateIOMemoryMap();
return;
case 0x0c:
// 80c off
graphicsMode &= ~GR_80CHAR;
return;
case 0x0d:
// 80c on
graphicsMode |= GR_80CHAR;
return;
case 0x0e:
// Alt charset off
graphicsMode &= ~GR_ALTCHAR;
return;
case 0x0f:
// Alt charset on
graphicsMode |= GR_ALTCHAR;
return;
case 0x10: case 0x11: case 0x12: case 0x13:
case 0x14: case 0x15: case 0x16: case 0x17:
case 0x18: case 0x19: case 0x1a: case 0x1b:
case 0x1c: case 0x1d: case 0x1e: case 0x1f:
// Keyboard strobe
keyboardLatch &= 0x7f;
return;
case 0x20: case 0x21: case 0x22: case 0x23:
case 0x24: case 0x25: case 0x26: case 0x27:
case 0x28: case 0x29: case 0x2a: case 0x2b:
case 0x2c: case 0x2d: case 0x2e: case 0x2f:
// Cassette output
return;
case 0x30: case 0x31: case 0x32: case 0x33:
case 0x34: case 0x35: case 0x36: case 0x37:
case 0x38: case 0x39: case 0x3a: case 0x3b:
case 0x3c: case 0x3d: case 0x3e: case 0x3f:
// Speaker
speakerFlips[speakerFlipsPointer] = clock;
speakerFlipsPointer = (speakerFlipsPointer + 1) & SPEAKER_FLIPS_MASK;
return;
case 0x40: case 0x41: case 0x42: case 0x43:
case 0x44: case 0x45: case 0x46: case 0x47:
case 0x48: case 0x49: case 0x4a: case 0x4b:
case 0x4c: case 0x4d: case 0x4e: case 0x4f:
// Game strobe
return;
case 0x50:
graphicsMode &= ~GR_TEXT;
return;
case 0x51:
graphicsMode |= GR_TEXT;
return;
case 0x52:
graphicsMode &= ~GR_MIXMODE;
return;
case 0x53:
graphicsMode |= GR_MIXMODE;
return;
case 0x54:
graphicsMode &= ~GR_PAGE2;
updateMainMemoryMap();
return;
case 0x55:
graphicsMode |= GR_PAGE2;
updateMainMemoryMap();
return;
case 0x56:
graphicsMode &= ~GR_HIRES;
updateMainMemoryMap();
return;
case 0x57:
graphicsMode |= GR_HIRES;
updateMainMemoryMap();
return;
case 0x58: case 0x59: case 0x5a: case 0x5b:
case 0x5c: case 0x5d:
// Annunciators
return;
case 0x5e:
graphicsMode |= GR_DHIRES;
break;
case 0x5f:
graphicsMode &= ~GR_DHIRES;
break;
case 0x60: case 0x61: case 0x62: case 0x63:
case 0x64: case 0x65: case 0x66: case 0x67:
case 0x68: case 0x69: case 0x6a: case 0x6b:
case 0x6c: case 0x6d: case 0x6e: case 0x6f:
// Cassette input/paddle data
return;
case 0x70: case 0x71: case 0x72: case 0x73:
case 0x74: case 0x75: case 0x76: case 0x77:
case 0x78: case 0x79: case 0x7a: case 0x7b:
case 0x7c: case 0x7d: case 0x7e: case 0x7f:
paddle.triggerRegister();
return;
case 0x80:
case 0x84:
isLcBank2 = true;
isLcReadEnable = true;
isLcWriteEnable = false;
updateLCMemoryMap();
break;
case 0x81:
case 0x85:
isLcBank2 = true;
isLcReadEnable = false;
isLcWriteEnable = true;
updateLCMemoryMap();
break;
case 0x82:
case 0x86:
isLcBank2 = true;
isLcReadEnable = false;
isLcWriteEnable = false;
updateLCMemoryMap();
break;
case 0x83:
case 0x87:
isLcBank2 = true;
isLcReadEnable = true;
isLcWriteEnable = true;
updateLCMemoryMap();
break;
case 0x88:
case 0x8c:
isLcBank2 = false;
isLcReadEnable = true;
isLcWriteEnable = false;
updateLCMemoryMap();
break;
case 0x89:
case 0x8d:
isLcBank2 = false;
isLcReadEnable = false;
isLcWriteEnable = true;
updateLCMemoryMap();
break;
case 0x8a:
case 0x8e:
isLcBank2 = false;
isLcReadEnable = false;
isLcWriteEnable = false;
updateLCMemoryMap();
break;
case 0x8b:
case 0x8f:
isLcBank2 = false;
isLcReadEnable = true;
isLcWriteEnable = true;
updateLCMemoryMap();
break;
}
}
/**
* Emulator thread
*/
public void run() {
try {
while (!isPaused) {
long refreshStart = System.currentTimeMillis();
long refreshDelay;
checkInterrupts();
if (isStepMode) {
if (isNextStep) {
isNextStep = false;
executeInstructions(stepCount);
}
} else {
int clocksNeeded = clocksPerInterval;
while (clocksNeeded > 0)
clocksNeeded -= executeInstructions(1 + (clocksNeeded >> 3));
}
refreshDelay = System.currentTimeMillis() - refreshStart;
refreshDelayCumulative += refreshDelay;
refreshCycle++;
if (refreshCycle >= refreshRate) {
refreshDelayPerSecond = refreshDelayCumulative;
refreshDelayCumulative = refreshCycle = 0;
}
if (refreshDelay < refreshInterval)
Thread.sleep(refreshInterval - refreshDelay);
}
} catch (InterruptedException e) {
};
}
/**
* Reset assertion code
*/
protected void onReset() {
// Reset IOU + MMU
ioWrite(0x00, 0);
ioWrite(0x02, 0);
ioWrite(0x04, 0);
ioWrite(0x06, 0);
ioWrite(0x08, 0);
ioWrite(0x0a, 0);
ioWrite(0x0c, 0);
ioWrite(0x0e, 0);
ioWrite(0x50, 0);
ioWrite(0x52, 0);
ioWrite(0x54, 0);
ioWrite(0x56, 0);
ioWrite(0x5F, 0);
ioWrite(0x82, 0);
if (isRestart) {
// Clear RAM
for (int i = 0; i < MEM_ROM_MAIN_LOW; i++)
mem[i] = 0;
setRandomSeed();
}
// Reset devices
for (int slot = 1; slot < 8; slot++)
slots[slot].reset();
}
}
Reference in New Issue View Git Blame Copy Permalink