generated from tilera/1710mod
2029 lines
52 KiB
Java
2029 lines
52 KiB
Java
package com.eloraam.redpower.control;
|
|
|
|
import com.eloraam.redpower.RedPowerControl;
|
|
import com.eloraam.redpower.core.CoreLib;
|
|
import com.eloraam.redpower.core.IFrameSupport;
|
|
import com.eloraam.redpower.core.IRedbusConnectable;
|
|
import com.eloraam.redpower.core.RedbusLib;
|
|
import com.eloraam.redpower.core.TileExtended;
|
|
import com.eloraam.redpower.core.WorldCoord;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.init.Blocks;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.world.IBlockAccess;
|
|
|
|
public class TileCPU extends TileExtended implements IRedbusConnectable, IFrameSupport {
|
|
public int Rotation = 0;
|
|
public byte[] memory = new byte[8192];
|
|
private int addrPOR;
|
|
private int addrBRK;
|
|
private int regSP;
|
|
private int regPC;
|
|
private int regA;
|
|
private int regB;
|
|
private int regX;
|
|
private int regY;
|
|
private int regR;
|
|
private int regI;
|
|
private int regD;
|
|
private boolean flagC;
|
|
private boolean flagZ;
|
|
private boolean flagID;
|
|
private boolean flagD;
|
|
private boolean flagBRK;
|
|
private boolean flagO;
|
|
private boolean flagN;
|
|
private boolean flagE;
|
|
private boolean flagM;
|
|
private boolean flagX;
|
|
private int mmuRBB = 0;
|
|
private int mmuRBA = 0;
|
|
private int mmuRBW = 0;
|
|
private boolean mmuEnRB = false;
|
|
private boolean mmuEnRBW = false;
|
|
private boolean rbTimeout = false;
|
|
private boolean waiTimeout = false;
|
|
private IRedbusConnectable rbCache = null;
|
|
private TileBackplane[] backplane = new TileBackplane[7];
|
|
private int rtcTicks = 0;
|
|
int sliceCycles = -1;
|
|
int diskAddr = 2;
|
|
int displayAddr = 1;
|
|
int rbaddr = 0;
|
|
|
|
public TileCPU() {
|
|
this.coldBootCPU();
|
|
}
|
|
|
|
public void coldBootCPU() {
|
|
this.addrPOR = 8192;
|
|
this.addrBRK = 8192;
|
|
this.regSP = 512;
|
|
this.regPC = 1024;
|
|
this.regR = 768;
|
|
this.regA = 0;
|
|
this.regX = 0;
|
|
this.regY = 0;
|
|
this.regD = 0;
|
|
this.flagC = false;
|
|
this.flagZ = false;
|
|
this.flagID = false;
|
|
this.flagD = false;
|
|
this.flagBRK = false;
|
|
this.flagO = false;
|
|
this.flagN = false;
|
|
this.flagE = true;
|
|
this.flagM = true;
|
|
this.flagX = true;
|
|
this.memory[0] = (byte)this.diskAddr;
|
|
this.memory[1] = (byte)this.displayAddr;
|
|
|
|
try {
|
|
InputStream is = RedPowerControl.class.getResourceAsStream("/assets/rpcontrol/forth/rpcboot.bin");
|
|
Throwable var2 = null;
|
|
|
|
try {
|
|
is.read(this.memory, 1024, 256);
|
|
} catch (Throwable var12) {
|
|
var2 = var12;
|
|
throw var12;
|
|
} finally {
|
|
if (is != null) {
|
|
if (var2 != null) {
|
|
try {
|
|
is.close();
|
|
} catch (Throwable var11) {
|
|
var2.addSuppressed(var11);
|
|
}
|
|
} else {
|
|
is.close();
|
|
}
|
|
}
|
|
|
|
}
|
|
} catch (IOException var14) {
|
|
var14.printStackTrace();
|
|
}
|
|
|
|
this.sliceCycles = -1;
|
|
}
|
|
|
|
public void warmBootCPU() {
|
|
if (this.sliceCycles >= 0) {
|
|
this.regSP = 512;
|
|
this.regR = 768;
|
|
this.regPC = this.addrPOR;
|
|
}
|
|
|
|
this.sliceCycles = 0;
|
|
}
|
|
|
|
public void haltCPU() {
|
|
this.sliceCycles = -1;
|
|
}
|
|
|
|
public boolean isRunning() {
|
|
return this.sliceCycles >= 0;
|
|
}
|
|
|
|
@Override
|
|
public int rbGetAddr() {
|
|
return this.rbaddr;
|
|
}
|
|
|
|
@Override
|
|
public void rbSetAddr(int addr) {
|
|
}
|
|
|
|
@Override
|
|
public int rbRead(int reg) {
|
|
return !this.mmuEnRBW ? 0 : this.readOnlyMem(this.mmuRBW + reg);
|
|
}
|
|
|
|
@Override
|
|
public void rbWrite(int reg, int dat) {
|
|
if (this.mmuEnRBW) {
|
|
this.writeOnlyMem(this.mmuRBW + reg, dat);
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public int getConnectableMask() {
|
|
return 16777215;
|
|
}
|
|
|
|
@Override
|
|
public int getConnectClass(int side) {
|
|
return 66;
|
|
}
|
|
|
|
@Override
|
|
public int getCornerPowerMode() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void onBlockPlaced(ItemStack ist, int side, EntityLivingBase ent) {
|
|
this.Rotation = (int)Math.floor((double)(ent.rotationYaw * 4.0F / 360.0F) + 0.5) + 1 & 3;
|
|
if (ent instanceof EntityPlayer) {
|
|
super.Owner = ((EntityPlayer)ent).getGameProfile();
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public boolean onBlockActivated(EntityPlayer player) {
|
|
if (player.isSneaking()) {
|
|
return false;
|
|
} else {
|
|
if (!super.worldObj.isRemote) {
|
|
player.openGui(RedPowerControl.instance, 2, super.worldObj, super.xCoord, super.yCoord, super.zCoord);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public Block getBlockType() {
|
|
return RedPowerControl.blockPeripheral;
|
|
}
|
|
|
|
@Override
|
|
public int getExtendedID() {
|
|
return 1;
|
|
}
|
|
|
|
public boolean isUseableByPlayer(EntityPlayer player) {
|
|
return !this.isInvalid()
|
|
&& super.worldObj.getTileEntity(super.xCoord, super.yCoord, super.zCoord) == this
|
|
&& player.getDistanceSq((double)super.xCoord + 0.5, (double)super.yCoord + 0.5, (double)super.zCoord + 0.5) <= 64.0;
|
|
}
|
|
|
|
protected void refreshBackplane() {
|
|
boolean bpok = true;
|
|
WorldCoord wc = new WorldCoord(this);
|
|
|
|
for(int i = 0; i < 7; ++i) {
|
|
if (!bpok) {
|
|
this.backplane[i] = null;
|
|
} else {
|
|
wc.step(CoreLib.rotToSide(this.Rotation));
|
|
TileBackplane tbp = CoreLib.getTileEntity(super.worldObj, wc, TileBackplane.class);
|
|
this.backplane[i] = tbp;
|
|
if (tbp == null) {
|
|
bpok = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public void updateEntity() {
|
|
++this.rtcTicks;
|
|
if (this.sliceCycles >= 0) {
|
|
this.rbTimeout = false;
|
|
this.rbCache = null;
|
|
this.waiTimeout = false;
|
|
this.sliceCycles += 1000;
|
|
if (this.sliceCycles > 100000) {
|
|
this.sliceCycles = 100000;
|
|
}
|
|
|
|
this.refreshBackplane();
|
|
|
|
while(this.sliceCycles > 0 && !this.waiTimeout && !this.rbTimeout) {
|
|
--this.sliceCycles;
|
|
this.executeInsn();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
protected int readOnlyMem(int addr) {
|
|
addr &= 65535;
|
|
if (addr < 8192) {
|
|
return this.memory[addr] & 0xFF;
|
|
} else {
|
|
int atop = (addr >> 13) - 1;
|
|
return this.backplane[atop] == null ? 255 : this.backplane[atop].readBackplane(addr & 8191);
|
|
}
|
|
}
|
|
|
|
public int readMem(int addr) {
|
|
if (this.mmuEnRB && addr >= this.mmuRBB && addr < this.mmuRBB + 256) {
|
|
if (this.rbCache == null) {
|
|
this.rbCache = RedbusLib.getAddr(super.worldObj, new WorldCoord(this), this.mmuRBA);
|
|
}
|
|
|
|
if (this.rbCache == null) {
|
|
this.rbTimeout = true;
|
|
return 0;
|
|
} else {
|
|
return this.rbCache.rbRead(addr - this.mmuRBB);
|
|
}
|
|
} else {
|
|
return this.readOnlyMem(addr);
|
|
}
|
|
}
|
|
|
|
protected void writeOnlyMem(int addr, int val) {
|
|
addr &= 65535;
|
|
if (addr < 8192) {
|
|
this.memory[addr] = (byte)val;
|
|
} else {
|
|
int atop = (addr >> 13) - 1;
|
|
if (this.backplane[atop] != null) {
|
|
this.backplane[atop].writeBackplane(addr & 8191, val);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public void writeMem(int addr, int val) {
|
|
if (this.mmuEnRB && addr >= this.mmuRBB && addr < this.mmuRBB + 256) {
|
|
if (this.rbCache == null) {
|
|
this.rbCache = RedbusLib.getAddr(super.worldObj, new WorldCoord(this), this.mmuRBA);
|
|
}
|
|
|
|
if (this.rbCache == null) {
|
|
this.rbTimeout = true;
|
|
} else {
|
|
this.rbCache.rbWrite(addr - this.mmuRBB, val & 0xFF);
|
|
}
|
|
} else {
|
|
this.writeOnlyMem(addr, val);
|
|
}
|
|
|
|
}
|
|
|
|
private void incPC() {
|
|
++this.regPC;
|
|
}
|
|
|
|
private int maskM() {
|
|
return this.flagM ? 255 : 65535;
|
|
}
|
|
|
|
private int maskX() {
|
|
return this.flagX ? 255 : 65535;
|
|
}
|
|
|
|
private int negM() {
|
|
return this.flagM ? 128 : 32768;
|
|
}
|
|
|
|
private int negX() {
|
|
return this.flagX ? 128 : 32768;
|
|
}
|
|
|
|
private int readB() {
|
|
int i = this.readMem(this.regPC);
|
|
this.incPC();
|
|
return i;
|
|
}
|
|
|
|
private int readM() {
|
|
int i = this.readMem(this.regPC);
|
|
this.incPC();
|
|
if (!this.flagM) {
|
|
i |= this.readMem(this.regPC) << 8;
|
|
this.incPC();
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
private int readX() {
|
|
int i = this.readMem(this.regPC);
|
|
this.incPC();
|
|
if (!this.flagX) {
|
|
i |= this.readMem(this.regPC) << 8;
|
|
this.incPC();
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
private int readM(int addr) {
|
|
int i = this.readMem(addr);
|
|
if (!this.flagM) {
|
|
i |= this.readMem(addr + 1) << 8;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
private int readX(int addr) {
|
|
int i = this.readMem(addr);
|
|
if (!this.flagX) {
|
|
i |= this.readMem(addr + 1) << 8;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
private void writeM(int addr, int reg) {
|
|
this.writeMem(addr, reg);
|
|
if (!this.flagM) {
|
|
this.writeMem(addr + 1, reg >> 8);
|
|
}
|
|
|
|
}
|
|
|
|
private void writeX(int addr, int reg) {
|
|
this.writeMem(addr, reg);
|
|
if (!this.flagX) {
|
|
this.writeMem(addr + 1, reg >> 8);
|
|
}
|
|
|
|
}
|
|
|
|
private int readBX() {
|
|
int i = this.readMem(this.regPC) + this.regX;
|
|
if (this.flagX) {
|
|
i &= 255;
|
|
}
|
|
|
|
this.incPC();
|
|
return i;
|
|
}
|
|
|
|
private int readBY() {
|
|
int i = this.readMem(this.regPC) + this.regY;
|
|
if (this.flagX) {
|
|
i &= 255;
|
|
}
|
|
|
|
this.incPC();
|
|
return i;
|
|
}
|
|
|
|
private int readBS() {
|
|
int i = this.readMem(this.regPC) + this.regSP;
|
|
this.incPC();
|
|
return i;
|
|
}
|
|
|
|
private int readBR() {
|
|
int i = this.readMem(this.regPC) + this.regR;
|
|
this.incPC();
|
|
return i;
|
|
}
|
|
|
|
private int readBSWY() {
|
|
int i = this.readMem(this.regPC) + this.regSP;
|
|
this.incPC();
|
|
return this.readW(i) + this.regY;
|
|
}
|
|
|
|
private int readBRWY() {
|
|
int i = this.readMem(this.regPC) + this.regR;
|
|
this.incPC();
|
|
return this.readW(i) + this.regY;
|
|
}
|
|
|
|
private int readW() {
|
|
int i = this.readMem(this.regPC);
|
|
this.incPC();
|
|
i |= this.readMem(this.regPC) << 8;
|
|
this.incPC();
|
|
return i;
|
|
}
|
|
|
|
private int readW(int addr) {
|
|
int i = this.readMem(addr);
|
|
return i | this.readMem(addr + 1) << 8;
|
|
}
|
|
|
|
private int readWX() {
|
|
int i = this.readMem(this.regPC);
|
|
this.incPC();
|
|
i |= this.readMem(this.regPC) << 8;
|
|
this.incPC();
|
|
return i + this.regX;
|
|
}
|
|
|
|
private int readWY() {
|
|
int i = this.readMem(this.regPC);
|
|
this.incPC();
|
|
i |= this.readMem(this.regPC) << 8;
|
|
this.incPC();
|
|
return i + this.regY;
|
|
}
|
|
|
|
private int readWXW() {
|
|
int i = this.readMem(this.regPC);
|
|
this.incPC();
|
|
i |= this.readMem(this.regPC) << 8;
|
|
this.incPC();
|
|
i += this.regX;
|
|
int j = this.readMem(i);
|
|
return j | this.readMem(i + 1) << 8;
|
|
}
|
|
|
|
private int readBW() {
|
|
int i = this.readMem(this.regPC);
|
|
this.incPC();
|
|
int j = this.readMem(i);
|
|
return j | this.readMem(i + 1) << 8;
|
|
}
|
|
|
|
private int readWW() {
|
|
int i = this.readMem(this.regPC);
|
|
this.incPC();
|
|
i |= this.readMem(this.regPC) << 8;
|
|
this.incPC();
|
|
int j = this.readMem(i);
|
|
return j | this.readMem(i + 1) << 8;
|
|
}
|
|
|
|
private int readBXW() {
|
|
int i = this.readMem(this.regPC) + this.regX & 0xFF;
|
|
this.incPC();
|
|
int j = this.readMem(i);
|
|
return j | this.readMem(i + 1) << 8;
|
|
}
|
|
|
|
private int readBWY() {
|
|
int i = this.readMem(this.regPC);
|
|
this.incPC();
|
|
int j = this.readMem(i);
|
|
j |= this.readMem(i + 1) << 8;
|
|
return j + this.regY;
|
|
}
|
|
|
|
private void upNZ() {
|
|
this.flagN = (this.regA & this.negM()) > 0;
|
|
this.flagZ = this.regA == 0;
|
|
}
|
|
|
|
private void upNZ(int i) {
|
|
this.flagN = (i & this.negM()) > 0;
|
|
this.flagZ = i == 0;
|
|
}
|
|
|
|
private void upNZX(int i) {
|
|
this.flagN = (i & this.negX()) > 0;
|
|
this.flagZ = i == 0;
|
|
}
|
|
|
|
private void push1(int b) {
|
|
if (this.flagE) {
|
|
this.regSP = this.regSP - 1 & 0xFF | this.regSP & 0xFF00;
|
|
} else {
|
|
--this.regSP;
|
|
}
|
|
|
|
this.writeMem(this.regSP, b);
|
|
}
|
|
|
|
private void push1r(int b) {
|
|
--this.regR;
|
|
this.writeMem(this.regR, b);
|
|
}
|
|
|
|
private void push2(int w) {
|
|
this.push1(w >> 8);
|
|
this.push1(w & 0xFF);
|
|
}
|
|
|
|
private void push2r(int w) {
|
|
this.push1r(w >> 8);
|
|
this.push1r(w & 0xFF);
|
|
}
|
|
|
|
private void pushM(int b) {
|
|
if (this.flagM) {
|
|
this.push1(b);
|
|
} else {
|
|
this.push2(b);
|
|
}
|
|
|
|
}
|
|
|
|
private void pushX(int b) {
|
|
if (this.flagX) {
|
|
this.push1(b);
|
|
} else {
|
|
this.push2(b);
|
|
}
|
|
|
|
}
|
|
|
|
private void pushMr(int b) {
|
|
if (this.flagM) {
|
|
this.push1r(b);
|
|
} else {
|
|
this.push2r(b);
|
|
}
|
|
|
|
}
|
|
|
|
private void pushXr(int b) {
|
|
if (this.flagX) {
|
|
this.push1r(b);
|
|
} else {
|
|
this.push2r(b);
|
|
}
|
|
|
|
}
|
|
|
|
private int pop1() {
|
|
int tr = this.readMem(this.regSP);
|
|
if (this.flagE) {
|
|
this.regSP = this.regSP + 1 & 0xFF | this.regSP & 0xFF00;
|
|
} else {
|
|
++this.regSP;
|
|
}
|
|
|
|
return tr;
|
|
}
|
|
|
|
private int pop1r() {
|
|
int tr = this.readMem(this.regR);
|
|
++this.regR;
|
|
return tr;
|
|
}
|
|
|
|
private int pop2() {
|
|
int tr = this.pop1();
|
|
return tr | this.pop1() << 8;
|
|
}
|
|
|
|
private int pop2r() {
|
|
int tr = this.pop1r();
|
|
return tr | this.pop1r() << 8;
|
|
}
|
|
|
|
private int popM() {
|
|
return this.flagM ? this.pop1() : this.pop2();
|
|
}
|
|
|
|
private int popMr() {
|
|
return this.flagM ? this.pop1r() : this.pop2r();
|
|
}
|
|
|
|
private int popX() {
|
|
return this.flagX ? this.pop1() : this.pop2();
|
|
}
|
|
|
|
private int popXr() {
|
|
return this.flagX ? this.pop1r() : this.pop2r();
|
|
}
|
|
|
|
private int getFlags() {
|
|
return (this.flagC ? 1 : 0)
|
|
| (this.flagZ ? 2 : 0)
|
|
| (this.flagID ? 4 : 0)
|
|
| (this.flagD ? 8 : 0)
|
|
| (this.flagX ? 16 : 0)
|
|
| (this.flagM ? 32 : 0)
|
|
| (this.flagO ? 64 : 0)
|
|
| (this.flagN ? 128 : 0);
|
|
}
|
|
|
|
private void setFlags(int flags) {
|
|
this.flagC = (flags & 1) > 0;
|
|
this.flagZ = (flags & 2) > 0;
|
|
this.flagID = (flags & 4) > 0;
|
|
this.flagD = (flags & 8) > 0;
|
|
boolean m2 = (flags & 32) > 0;
|
|
this.flagO = (flags & 64) > 0;
|
|
this.flagN = (flags & 128) > 0;
|
|
if (this.flagE) {
|
|
this.flagX = false;
|
|
this.flagM = false;
|
|
} else {
|
|
this.flagX = (flags & 16) > 0;
|
|
if (this.flagX) {
|
|
this.regX &= 255;
|
|
this.regY &= 255;
|
|
}
|
|
|
|
if (m2 != this.flagM) {
|
|
if (m2) {
|
|
this.regB = this.regA >> 8;
|
|
this.regA &= 255;
|
|
} else {
|
|
this.regA |= this.regB << 8;
|
|
}
|
|
|
|
this.flagM = m2;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private void i_adc(int val) {
|
|
if (this.flagM) {
|
|
if (this.flagD) {
|
|
int v = (this.regA & 15) + (val & 15) + (this.flagC ? 1 : 0);
|
|
if (v > 9) {
|
|
v = (v + 6 & 15) + 16;
|
|
}
|
|
|
|
int v2 = (this.regA & 240) + (val & 240) + v;
|
|
if (v2 > 160) {
|
|
v2 += 96;
|
|
}
|
|
|
|
this.flagC = v2 > 100;
|
|
this.regA = v2 & 0xFF;
|
|
this.flagO = false;
|
|
} else {
|
|
int v = this.regA + val + (this.flagC ? 1 : 0);
|
|
this.flagC = v > 255;
|
|
this.flagO = ((v ^ this.regA) & (v ^ val) & 128) > 0;
|
|
this.regA = v & 0xFF;
|
|
}
|
|
} else {
|
|
int v = this.regA + val + (this.flagC ? 1 : 0);
|
|
this.flagC = v > 65535;
|
|
this.flagO = ((v ^ this.regA) & (v ^ val) & 32768) > 0;
|
|
this.regA = v;
|
|
}
|
|
|
|
this.upNZ();
|
|
}
|
|
|
|
private void i_sbc(int val) {
|
|
if (this.flagM) {
|
|
if (this.flagD) {
|
|
int v = (this.regA & 15) - (val & 15) + (this.flagC ? 1 : 0) - 1;
|
|
if (v < 0) {
|
|
v = (v - 6 & 15) - 16;
|
|
}
|
|
|
|
int v2 = (this.regA & 240) - (val & 240) + v;
|
|
if (v2 < 0) {
|
|
v2 -= 96;
|
|
}
|
|
|
|
this.flagC = v2 < 100;
|
|
this.regA = v2 & 0xFF;
|
|
this.flagO = false;
|
|
} else {
|
|
int v = this.regA - val + (this.flagC ? 1 : 0) - 1;
|
|
this.flagC = (v & 256) == 0;
|
|
this.flagO = ((v ^ this.regA) & (v ^ -val) & 128) > 0;
|
|
this.regA = v & 0xFF;
|
|
}
|
|
} else {
|
|
int v = this.regA - val + (this.flagC ? 1 : 0) - 1;
|
|
this.flagC = (v & 65536) == 0;
|
|
this.flagO = ((v ^ this.regA) & (v ^ -val) & 32768) > 0;
|
|
this.regA = v;
|
|
}
|
|
|
|
this.upNZ();
|
|
}
|
|
|
|
private void i_mul(int val) {
|
|
if (this.flagM) {
|
|
int v;
|
|
if (this.flagC) {
|
|
v = (byte)val * (byte)this.regA;
|
|
} else {
|
|
v = val * this.regA;
|
|
}
|
|
|
|
this.regA = v & 0xFF;
|
|
this.regD = v >> 8 & 0xFF;
|
|
this.flagN = v < 0;
|
|
this.flagZ = v == 0;
|
|
this.flagO = this.regD != 0 && this.regD != 255;
|
|
} else {
|
|
long v1;
|
|
if (this.flagC) {
|
|
v1 = (long)((short)val * (short)this.regA);
|
|
} else {
|
|
v1 = (long)(val * this.regA);
|
|
}
|
|
|
|
this.regA = (int)(v1 & 65535L);
|
|
this.regD = (int)(v1 >> 16 & 65535L);
|
|
this.flagN = v1 < 0L;
|
|
this.flagZ = v1 == 0L;
|
|
this.flagO = this.regD != 0 && this.regD != 65535;
|
|
}
|
|
|
|
}
|
|
|
|
private void i_div(int val) {
|
|
if (val == 0) {
|
|
this.regA = 0;
|
|
this.regD = 0;
|
|
this.flagO = true;
|
|
this.flagZ = false;
|
|
this.flagN = false;
|
|
} else if (this.flagM) {
|
|
int q;
|
|
if (this.flagC) {
|
|
q = (byte)this.regD << 8 | this.regA;
|
|
val = (byte)val;
|
|
} else {
|
|
q = this.regD << 8 | this.regA;
|
|
}
|
|
|
|
this.regD = q % val & 0xFF;
|
|
q /= val;
|
|
this.regA = q & 0xFF;
|
|
if (!this.flagC) {
|
|
this.flagO = q > 255;
|
|
} else {
|
|
this.flagO = q > 127 || q < -128;
|
|
}
|
|
|
|
this.flagZ = this.regA == 0;
|
|
this.flagN = q < 0;
|
|
} else if (this.flagC) {
|
|
int q = (short)this.regD << 16 | this.regA;
|
|
short val1 = (short)val;
|
|
this.regD = q % val1;
|
|
q /= val1;
|
|
this.regA = q;
|
|
this.flagO = q > 32767 || q < -32768;
|
|
this.flagZ = this.regA == 0;
|
|
this.flagN = q < 0;
|
|
} else {
|
|
long q1 = (long)(this.regD << 16 | this.regA);
|
|
this.regD = (int)(q1 % (long)val & 65535L);
|
|
q1 /= (long)val;
|
|
this.regA = (int)(q1 & 65535L);
|
|
this.flagO = q1 > 65535L;
|
|
this.flagZ = this.regA == 0;
|
|
this.flagN = q1 < 0L;
|
|
}
|
|
|
|
}
|
|
|
|
private void i_and(int val) {
|
|
this.regA &= val;
|
|
this.upNZ();
|
|
}
|
|
|
|
private void i_asl(int addr) {
|
|
int i = this.readM(addr);
|
|
this.flagC = (i & this.negM()) > 0;
|
|
i = i << 1 & this.maskM();
|
|
this.upNZ(i);
|
|
this.writeM(addr, i);
|
|
}
|
|
|
|
private void i_lsr(int addr) {
|
|
int i = this.readM(addr);
|
|
this.flagC = (i & 1) > 0;
|
|
i >>>= 1;
|
|
this.upNZ(i);
|
|
this.writeM(addr, i);
|
|
}
|
|
|
|
private void i_rol(int addr) {
|
|
int i = this.readM(addr);
|
|
int n = (i << 1 | (this.flagC ? 1 : 0)) & this.maskM();
|
|
this.flagC = (i & this.negM()) > 0;
|
|
this.upNZ(n);
|
|
this.writeM(addr, n);
|
|
}
|
|
|
|
private void i_ror(int addr) {
|
|
int i = this.readM(addr);
|
|
int n = i >>> 1 | (this.flagC ? this.negM() : 0);
|
|
this.flagC = (i & 1) > 0;
|
|
this.upNZ(n);
|
|
this.writeM(addr, n);
|
|
}
|
|
|
|
private void i_brc(boolean cond) {
|
|
int n = this.readB();
|
|
if (cond) {
|
|
this.regPC += (byte)n;
|
|
}
|
|
|
|
}
|
|
|
|
private void i_bit(int val) {
|
|
if (this.flagM) {
|
|
this.flagO = (val & 64) > 0;
|
|
this.flagN = (val & 128) > 0;
|
|
} else {
|
|
this.flagO = (val & 16384) > 0;
|
|
this.flagN = (val & 32768) > 0;
|
|
}
|
|
|
|
this.flagZ = (val & this.regA) > 0;
|
|
}
|
|
|
|
private void i_trb(int val) {
|
|
this.flagZ = (val & this.regA) > 0;
|
|
this.regA &= ~val;
|
|
}
|
|
|
|
private void i_tsb(int val) {
|
|
this.flagZ = (val & this.regA) > 0;
|
|
this.regA |= val;
|
|
}
|
|
|
|
private void i_cmp(int reg, int val) {
|
|
reg -= val;
|
|
this.flagC = reg >= 0;
|
|
this.flagZ = reg == 0;
|
|
this.flagN = (reg & this.negM()) > 0;
|
|
}
|
|
|
|
private void i_cmpx(int reg, int val) {
|
|
reg -= val;
|
|
this.flagC = reg >= 0;
|
|
this.flagZ = reg == 0;
|
|
this.flagN = (reg & this.negX()) > 0;
|
|
}
|
|
|
|
private void i_dec(int addr) {
|
|
int i = this.readM(addr);
|
|
i = i - 1 & this.maskM();
|
|
this.writeM(addr, i);
|
|
this.upNZ(i);
|
|
}
|
|
|
|
private void i_inc(int addr) {
|
|
int i = this.readM(addr);
|
|
i = i + 1 & this.maskM();
|
|
this.writeM(addr, i);
|
|
this.upNZ(i);
|
|
}
|
|
|
|
private void i_eor(int val) {
|
|
this.regA ^= val;
|
|
this.upNZ();
|
|
}
|
|
|
|
private void i_or(int val) {
|
|
this.regA |= val;
|
|
this.upNZ();
|
|
}
|
|
|
|
private void i_mmu(int mmu) {
|
|
switch(mmu) {
|
|
case 0:
|
|
int t = this.regA & 0xFF;
|
|
if (this.mmuRBA != t) {
|
|
if (this.rbCache != null) {
|
|
this.rbTimeout = true;
|
|
}
|
|
|
|
this.mmuRBA = t;
|
|
}
|
|
break;
|
|
case 1:
|
|
this.mmuRBB = this.regA;
|
|
break;
|
|
case 2:
|
|
this.mmuEnRB = true;
|
|
break;
|
|
case 3:
|
|
this.mmuRBW = this.regA;
|
|
break;
|
|
case 4:
|
|
this.mmuEnRBW = true;
|
|
break;
|
|
case 5:
|
|
this.addrBRK = this.regA;
|
|
break;
|
|
case 6:
|
|
this.addrPOR = this.regA;
|
|
break;
|
|
case 128:
|
|
this.regA = this.mmuRBA;
|
|
break;
|
|
case 129:
|
|
this.regA = this.mmuRBB;
|
|
if (this.flagM) {
|
|
this.regB = this.regA >> 8;
|
|
this.regA &= 255;
|
|
}
|
|
break;
|
|
case 130:
|
|
this.mmuEnRB = false;
|
|
break;
|
|
case 131:
|
|
this.regA = this.mmuRBW;
|
|
if (this.flagM) {
|
|
this.regB = this.regA >> 8;
|
|
this.regA &= 255;
|
|
}
|
|
break;
|
|
case 132:
|
|
this.mmuEnRBW = false;
|
|
break;
|
|
case 133:
|
|
this.regA = this.addrBRK;
|
|
if (this.flagM) {
|
|
this.regB = this.regA >> 8;
|
|
this.regA &= 255;
|
|
}
|
|
break;
|
|
case 134:
|
|
this.regA = this.addrPOR;
|
|
if (this.flagM) {
|
|
this.regB = this.regA >> 8;
|
|
this.regA &= 255;
|
|
}
|
|
break;
|
|
case 135:
|
|
this.regA = this.rtcTicks;
|
|
this.regD = this.rtcTicks >> 16;
|
|
}
|
|
|
|
}
|
|
|
|
public void executeInsn() {
|
|
int insn = this.readMem(this.regPC);
|
|
this.incPC();
|
|
switch(insn) {
|
|
case 0:
|
|
this.push2(this.regPC);
|
|
this.push1(this.getFlags());
|
|
this.flagBRK = true;
|
|
this.regPC = this.addrBRK;
|
|
break;
|
|
case 1:
|
|
this.i_or(this.readM(this.readBXW()));
|
|
break;
|
|
case 2:
|
|
this.regPC = this.readW(this.regI);
|
|
this.regI += 2;
|
|
break;
|
|
case 3:
|
|
this.i_or(this.readM(this.readBS()));
|
|
break;
|
|
case 4:
|
|
this.i_tsb(this.readM(this.readB()));
|
|
break;
|
|
case 5:
|
|
this.i_or(this.readM(this.readB()));
|
|
break;
|
|
case 6:
|
|
this.i_asl(this.readB());
|
|
break;
|
|
case 7:
|
|
this.i_or(this.readM(this.readBR()));
|
|
break;
|
|
case 8:
|
|
this.push1(this.getFlags());
|
|
break;
|
|
case 9:
|
|
this.i_or(this.readM());
|
|
break;
|
|
case 10:
|
|
this.flagC = (this.regA & this.negM()) > 0;
|
|
this.regA = this.regA << 1 & this.maskM();
|
|
this.upNZ();
|
|
break;
|
|
case 11:
|
|
this.push2r(this.regI);
|
|
break;
|
|
case 12:
|
|
this.i_tsb(this.readM(this.readW()));
|
|
break;
|
|
case 13:
|
|
this.i_or(this.readM(this.readW()));
|
|
break;
|
|
case 14:
|
|
this.i_asl(this.readW());
|
|
break;
|
|
case 15:
|
|
this.i_mul(this.readM(this.readB()));
|
|
break;
|
|
case 16:
|
|
this.i_brc(!this.flagN);
|
|
break;
|
|
case 17:
|
|
this.i_or(this.readM(this.readBWY()));
|
|
break;
|
|
case 18:
|
|
this.i_or(this.readM(this.readBW()));
|
|
break;
|
|
case 19:
|
|
this.i_or(this.readM(this.readBSWY()));
|
|
break;
|
|
case 20:
|
|
this.i_trb(this.readM(this.readB()));
|
|
break;
|
|
case 21:
|
|
this.i_or(this.readM(this.readBX()));
|
|
break;
|
|
case 22:
|
|
this.i_asl(this.readBX());
|
|
break;
|
|
case 23:
|
|
this.i_or(this.readM(this.readBRWY()));
|
|
break;
|
|
case 24:
|
|
this.flagC = false;
|
|
break;
|
|
case 25:
|
|
this.i_or(this.readM(this.readWY()));
|
|
break;
|
|
case 26:
|
|
this.regA = this.regA + 1 & this.maskM();
|
|
this.upNZ(this.regA);
|
|
break;
|
|
case 27:
|
|
this.pushXr(this.regX);
|
|
break;
|
|
case 28:
|
|
this.i_trb(this.readM(this.readW()));
|
|
break;
|
|
case 29:
|
|
this.i_or(this.readM(this.readWX()));
|
|
break;
|
|
case 30:
|
|
this.i_asl(this.readWX());
|
|
break;
|
|
case 31:
|
|
this.i_mul(this.readM(this.readBX()));
|
|
break;
|
|
case 32:
|
|
this.push2(this.regPC + 1);
|
|
this.regPC = this.readW();
|
|
break;
|
|
case 33:
|
|
this.i_and(this.readM(this.readBXW()));
|
|
break;
|
|
case 34:
|
|
this.push2r(this.regI);
|
|
this.regI = this.regPC + 2;
|
|
this.regPC = this.readW(this.regPC);
|
|
break;
|
|
case 35:
|
|
this.i_and(this.readM(this.readBS()));
|
|
break;
|
|
case 36:
|
|
this.i_bit(this.readM(this.readB()));
|
|
break;
|
|
case 37:
|
|
this.i_and(this.readM(this.readB()));
|
|
break;
|
|
case 38:
|
|
this.i_rol(this.readB());
|
|
break;
|
|
case 39:
|
|
this.i_and(this.readM(this.readBR()));
|
|
break;
|
|
case 40:
|
|
this.setFlags(this.pop1());
|
|
break;
|
|
case 41:
|
|
this.i_and(this.readM());
|
|
break;
|
|
case 42: {
|
|
int n = (this.regA << 1 | (this.flagC ? 1 : 0)) & this.maskM();
|
|
this.flagC = (this.regA & this.negM()) > 0;
|
|
this.regA = n;
|
|
this.upNZ();
|
|
break;
|
|
}
|
|
case 43:
|
|
this.regI = this.pop2r();
|
|
this.upNZX(this.regI);
|
|
break;
|
|
case 44:
|
|
this.i_bit(this.readM(this.readW()));
|
|
break;
|
|
case 45:
|
|
this.i_and(this.readM(this.readW()));
|
|
break;
|
|
case 46:
|
|
this.i_rol(this.readW());
|
|
break;
|
|
case 47:
|
|
this.i_mul(this.readM(this.readW()));
|
|
break;
|
|
case 48:
|
|
this.i_brc(this.flagN);
|
|
break;
|
|
case 49:
|
|
this.i_and(this.readM(this.readBWY()));
|
|
break;
|
|
case 50:
|
|
this.i_and(this.readM(this.readBW()));
|
|
break;
|
|
case 51:
|
|
this.i_and(this.readM(this.readBSWY()));
|
|
break;
|
|
case 52:
|
|
this.i_bit(this.readM(this.readBX()));
|
|
break;
|
|
case 53:
|
|
this.i_and(this.readM(this.readBX()));
|
|
break;
|
|
case 54:
|
|
this.i_rol(this.readBX());
|
|
break;
|
|
case 55:
|
|
this.i_and(this.readM(this.readBRWY()));
|
|
break;
|
|
case 56:
|
|
this.flagC = true;
|
|
break;
|
|
case 57:
|
|
this.i_and(this.readM(this.readWY()));
|
|
break;
|
|
case 58:
|
|
this.regA = this.regA - 1 & this.maskM();
|
|
this.upNZ(this.regA);
|
|
break;
|
|
case 59:
|
|
this.regX = this.popXr();
|
|
this.upNZX(this.regX);
|
|
break;
|
|
case 60:
|
|
this.i_bit(this.readM(this.readWX()));
|
|
break;
|
|
case 61:
|
|
this.i_and(this.readM(this.readWX()));
|
|
break;
|
|
case 62:
|
|
this.i_rol(this.readWX());
|
|
break;
|
|
case 63:
|
|
this.i_mul(this.readM(this.readWX()));
|
|
break;
|
|
case 64:
|
|
this.setFlags(this.pop1());
|
|
this.regPC = this.pop2();
|
|
break;
|
|
case 65:
|
|
this.i_eor(this.readM(this.readBXW()));
|
|
break;
|
|
case 66:
|
|
if (this.flagM) {
|
|
this.regA = this.readMem(this.regI);
|
|
++this.regI;
|
|
} else {
|
|
this.regA = this.readW(this.regI);
|
|
this.regI += 2;
|
|
}
|
|
break;
|
|
case 67:
|
|
this.i_eor(this.readM(this.readBS()));
|
|
break;
|
|
case 68:
|
|
this.push2r(this.readW());
|
|
break;
|
|
case 69:
|
|
this.i_eor(this.readM(this.readB()));
|
|
break;
|
|
case 70:
|
|
this.i_lsr(this.readB());
|
|
break;
|
|
case 71:
|
|
this.i_eor(this.readM(this.readBR()));
|
|
break;
|
|
case 72:
|
|
this.pushM(this.regA);
|
|
break;
|
|
case 73:
|
|
this.i_eor(this.readM());
|
|
break;
|
|
case 74:
|
|
this.flagC = (this.regA & 1) > 0;
|
|
this.regA >>>= 1;
|
|
this.upNZ();
|
|
break;
|
|
case 75:
|
|
this.pushMr(this.regA);
|
|
break;
|
|
case 76:
|
|
this.regPC = this.readW();
|
|
break;
|
|
case 77:
|
|
this.i_eor(this.readM(this.readW()));
|
|
break;
|
|
case 78:
|
|
this.i_lsr(this.readW());
|
|
break;
|
|
case 79:
|
|
this.i_div(this.readM(this.readB()));
|
|
break;
|
|
case 80:
|
|
this.i_brc(!this.flagO);
|
|
break;
|
|
case 81:
|
|
this.i_eor(this.readM(this.readBWY()));
|
|
break;
|
|
case 82:
|
|
this.i_eor(this.readM(this.readBW()));
|
|
break;
|
|
case 83:
|
|
this.i_eor(this.readM(this.readBSWY()));
|
|
break;
|
|
case 84:
|
|
this.push2r(this.readBW());
|
|
break;
|
|
case 85:
|
|
this.i_eor(this.readM(this.readBX()));
|
|
break;
|
|
case 86:
|
|
this.i_lsr(this.readBX());
|
|
break;
|
|
case 87:
|
|
this.i_eor(this.readM(this.readBRWY()));
|
|
break;
|
|
case 88:
|
|
this.flagID = false;
|
|
break;
|
|
case 89:
|
|
this.i_eor(this.readM(this.readWY()));
|
|
break;
|
|
case 90:
|
|
this.pushX(this.regY);
|
|
break;
|
|
case 91:
|
|
this.pushXr(this.regY);
|
|
break;
|
|
case 92:
|
|
this.regI = this.regX;
|
|
this.upNZX(this.regX);
|
|
break;
|
|
case 93:
|
|
this.i_eor(this.readM(this.readWX()));
|
|
break;
|
|
case 94:
|
|
this.i_lsr(this.readWX());
|
|
break;
|
|
case 95:
|
|
this.i_div(this.readM(this.readBX()));
|
|
break;
|
|
case 96:
|
|
this.regPC = this.pop2() + 1;
|
|
break;
|
|
case 97:
|
|
this.i_adc(this.readM(this.readBXW()));
|
|
break;
|
|
case 98: {
|
|
int n = this.readB();
|
|
this.push2(this.regPC + n);
|
|
break;
|
|
}
|
|
case 99:
|
|
this.i_adc(this.readM(this.readBS()));
|
|
break;
|
|
case 100:
|
|
this.writeM(this.readB(), 0);
|
|
break;
|
|
case 101:
|
|
this.i_adc(this.readM(this.readB()));
|
|
break;
|
|
case 102:
|
|
this.i_ror(this.readB());
|
|
break;
|
|
case 103:
|
|
this.i_adc(this.readM(this.readBR()));
|
|
break;
|
|
case 104:
|
|
this.regA = this.popM();
|
|
this.upNZ();
|
|
break;
|
|
case 105:
|
|
this.i_adc(this.readM());
|
|
break;
|
|
case 106: {
|
|
int n = this.regA >>> 1 | (this.flagC ? this.negM() : 0);
|
|
this.flagC = (this.regA & 1) > 0;
|
|
this.regA = n;
|
|
this.upNZ();
|
|
break;
|
|
}
|
|
case 107:
|
|
this.regA = this.popMr();
|
|
this.upNZ(this.regA);
|
|
break;
|
|
case 108:
|
|
this.regPC = this.readWW();
|
|
break;
|
|
case 109:
|
|
this.i_adc(this.readM(this.readW()));
|
|
break;
|
|
case 110:
|
|
this.i_ror(this.readW());
|
|
break;
|
|
case 111:
|
|
this.i_div(this.readM(this.readW()));
|
|
break;
|
|
case 112:
|
|
this.i_brc(this.flagO);
|
|
break;
|
|
case 113:
|
|
this.i_adc(this.readM(this.readBWY()));
|
|
break;
|
|
case 114:
|
|
this.i_adc(this.readM(this.readBW()));
|
|
break;
|
|
case 115:
|
|
this.i_adc(this.readM(this.readBSWY()));
|
|
break;
|
|
case 116:
|
|
this.writeM(this.readBX(), 0);
|
|
break;
|
|
case 117:
|
|
this.i_adc(this.readM(this.readBX()));
|
|
break;
|
|
case 118:
|
|
this.i_ror(this.readBX());
|
|
break;
|
|
case 119:
|
|
this.i_adc(this.readM(this.readBRWY()));
|
|
break;
|
|
case 120:
|
|
this.flagID = true;
|
|
break;
|
|
case 121:
|
|
this.i_adc(this.readM(this.readWY()));
|
|
break;
|
|
case 122:
|
|
this.regY = this.popX();
|
|
this.upNZX(this.regY);
|
|
break;
|
|
case 123:
|
|
this.regY = this.popXr();
|
|
this.upNZX(this.regY);
|
|
break;
|
|
case 124:
|
|
this.regPC = this.readWXW();
|
|
break;
|
|
case 125:
|
|
this.i_adc(this.readM(this.readWX()));
|
|
break;
|
|
case 126:
|
|
this.i_ror(this.readWX());
|
|
break;
|
|
case 127:
|
|
this.i_div(this.readM(this.readWX()));
|
|
break;
|
|
case 128:
|
|
this.i_brc(true);
|
|
break;
|
|
case 129:
|
|
this.writeM(this.readBXW(), this.regA);
|
|
break;
|
|
case 130: {
|
|
int n = this.readB();
|
|
this.push2r(this.regPC + n);
|
|
break;
|
|
}
|
|
case 131:
|
|
this.writeM(this.readBS(), this.regA);
|
|
break;
|
|
case 132:
|
|
this.writeX(this.readB(), this.regY);
|
|
break;
|
|
case 133:
|
|
this.writeM(this.readB(), this.regA);
|
|
break;
|
|
case 134:
|
|
this.writeX(this.readB(), this.regX);
|
|
break;
|
|
case 135:
|
|
this.writeM(this.readBR(), this.regA);
|
|
break;
|
|
case 136:
|
|
this.regY = this.regY - 1 & this.maskX();
|
|
this.upNZ(this.regY);
|
|
break;
|
|
case 137:
|
|
this.flagZ = (this.readM() & this.regA) == 0;
|
|
break;
|
|
case 138:
|
|
this.regA = this.regX;
|
|
if (this.flagM) {
|
|
this.regA &= 255;
|
|
}
|
|
|
|
this.upNZ();
|
|
break;
|
|
case 139:
|
|
if (this.flagX) {
|
|
this.regSP = this.regR & 0xFF00 | this.regX & 0xFF;
|
|
} else {
|
|
this.regR = this.regX;
|
|
}
|
|
|
|
this.upNZX(this.regR);
|
|
break;
|
|
case 140:
|
|
this.writeX(this.readW(), this.regY);
|
|
break;
|
|
case 141:
|
|
this.writeM(this.readW(), this.regA);
|
|
break;
|
|
case 142:
|
|
this.writeX(this.readW(), this.regX);
|
|
break;
|
|
case 143:
|
|
this.regD = 0;
|
|
this.regB = 0;
|
|
break;
|
|
case 144:
|
|
this.i_brc(!this.flagC);
|
|
break;
|
|
case 145:
|
|
this.writeM(this.readBWY(), this.regA);
|
|
break;
|
|
case 146:
|
|
this.writeM(this.readBW(), this.regA);
|
|
break;
|
|
case 147:
|
|
this.writeM(this.readBSWY(), this.regA);
|
|
break;
|
|
case 148:
|
|
this.writeX(this.readBX(), this.regY);
|
|
break;
|
|
case 149:
|
|
this.writeM(this.readBX(), this.regA);
|
|
break;
|
|
case 150:
|
|
this.writeX(this.readBY(), this.regX);
|
|
break;
|
|
case 151:
|
|
this.writeM(this.readBRWY(), this.regA);
|
|
break;
|
|
case 152:
|
|
this.regA = this.regY;
|
|
if (this.flagM) {
|
|
this.regA &= 255;
|
|
}
|
|
|
|
this.upNZX(this.regY);
|
|
break;
|
|
case 153:
|
|
this.writeM(this.readWY(), this.regA);
|
|
break;
|
|
case 154:
|
|
if (this.flagX) {
|
|
this.regSP = this.regSP & 0xFF00 | this.regX & 0xFF;
|
|
} else {
|
|
this.regSP = this.regX;
|
|
}
|
|
|
|
this.upNZX(this.regX);
|
|
break;
|
|
case 155:
|
|
this.regY = this.regX;
|
|
this.upNZX(this.regY);
|
|
break;
|
|
case 156:
|
|
this.writeM(this.readW(), 0);
|
|
break;
|
|
case 157:
|
|
this.writeM(this.readWX(), this.regA);
|
|
break;
|
|
case 158:
|
|
this.writeM(this.readWX(), 0);
|
|
break;
|
|
case 159:
|
|
this.regD = (this.regA & this.negM()) > 0 ? '\uffff' : 0;
|
|
this.regB = this.regD & 0xFF;
|
|
break;
|
|
case 160:
|
|
this.regY = this.readX();
|
|
this.upNZ(this.regY);
|
|
break;
|
|
case 161:
|
|
this.regA = this.readM(this.readBXW());
|
|
this.upNZ();
|
|
break;
|
|
case 162:
|
|
this.regX = this.readX();
|
|
this.upNZ(this.regX);
|
|
break;
|
|
case 163:
|
|
this.regA = this.readM(this.readBS());
|
|
this.upNZ();
|
|
break;
|
|
case 164:
|
|
this.regY = this.readX(this.readB());
|
|
this.upNZ(this.regY);
|
|
break;
|
|
case 165:
|
|
this.regA = this.readM(this.readB());
|
|
this.upNZ();
|
|
break;
|
|
case 166:
|
|
this.regX = this.readX(this.readB());
|
|
this.upNZ(this.regX);
|
|
break;
|
|
case 167:
|
|
this.regA = this.readM(this.readBR());
|
|
this.upNZ();
|
|
break;
|
|
case 168:
|
|
this.regY = this.regA;
|
|
if (this.flagX) {
|
|
this.regY &= 255;
|
|
}
|
|
|
|
this.upNZX(this.regY);
|
|
break;
|
|
case 169:
|
|
this.regA = this.readM();
|
|
this.upNZ();
|
|
break;
|
|
case 170:
|
|
this.regX = this.regA;
|
|
if (this.flagX) {
|
|
this.regX &= 255;
|
|
}
|
|
|
|
this.upNZX(this.regX);
|
|
break;
|
|
case 171:
|
|
this.regX = this.regR;
|
|
if (this.flagX) {
|
|
this.regX &= 255;
|
|
}
|
|
|
|
this.upNZX(this.regX);
|
|
break;
|
|
case 172:
|
|
this.regY = this.readX(this.readW());
|
|
this.upNZ(this.regY);
|
|
break;
|
|
case 173:
|
|
this.regA = this.readM(this.readW());
|
|
this.upNZ();
|
|
break;
|
|
case 174:
|
|
this.regX = this.readX(this.readW());
|
|
this.upNZ(this.regX);
|
|
break;
|
|
case 175:
|
|
this.regA = this.regD;
|
|
if (this.flagM) {
|
|
this.regA &= 255;
|
|
}
|
|
|
|
this.upNZ(this.regA);
|
|
break;
|
|
case 176:
|
|
this.i_brc(this.flagC);
|
|
break;
|
|
case 177:
|
|
this.regA = this.readM(this.readBWY());
|
|
this.upNZ();
|
|
break;
|
|
case 178:
|
|
this.regA = this.readM(this.readBW());
|
|
this.upNZ();
|
|
break;
|
|
case 179:
|
|
this.regA = this.readM(this.readBSWY());
|
|
this.upNZ();
|
|
break;
|
|
case 180:
|
|
this.regY = this.readX(this.readBX());
|
|
this.upNZ(this.regY);
|
|
break;
|
|
case 181:
|
|
this.regA = this.readM(this.readBX());
|
|
this.upNZ();
|
|
break;
|
|
case 182:
|
|
this.regX = this.readX(this.readBY());
|
|
this.upNZ(this.regX);
|
|
break;
|
|
case 183:
|
|
this.regA = this.readM(this.readBRWY());
|
|
this.upNZ();
|
|
break;
|
|
case 184:
|
|
this.flagO = false;
|
|
break;
|
|
case 185:
|
|
this.regA = this.readM(this.readWY());
|
|
this.upNZ();
|
|
break;
|
|
case 186:
|
|
this.regX = this.regSP;
|
|
if (this.flagX) {
|
|
this.regX &= 255;
|
|
}
|
|
|
|
this.upNZX(this.regX);
|
|
break;
|
|
case 187:
|
|
this.regX = this.regY;
|
|
this.upNZX(this.regX);
|
|
break;
|
|
case 188:
|
|
this.regY = this.readX(this.readWX());
|
|
this.upNZ(this.regY);
|
|
break;
|
|
case 189:
|
|
this.regA = this.readM(this.readWX());
|
|
this.upNZ();
|
|
break;
|
|
case 190:
|
|
this.regX = this.readX(this.readWY());
|
|
this.upNZ(this.regX);
|
|
break;
|
|
case 191:
|
|
if (this.flagM) {
|
|
this.regD = this.regA | this.regB << 8;
|
|
} else {
|
|
this.regD = this.regA;
|
|
}
|
|
|
|
this.upNZ(this.regA);
|
|
break;
|
|
case 192:
|
|
this.i_cmpx(this.regY, this.readX());
|
|
break;
|
|
case 193:
|
|
this.i_cmp(this.regA, this.readM(this.readBXW()));
|
|
break;
|
|
case 194:
|
|
this.setFlags(this.getFlags() & ~this.readB());
|
|
break;
|
|
case 195:
|
|
this.i_cmp(this.regA, this.readM(this.readBS()));
|
|
break;
|
|
case 196:
|
|
this.i_cmpx(this.regY, this.readX(this.readB()));
|
|
break;
|
|
case 197:
|
|
this.i_cmp(this.regA, this.readM(this.readB()));
|
|
break;
|
|
case 198:
|
|
this.i_dec(this.readB());
|
|
break;
|
|
case 199:
|
|
this.i_cmp(this.regA, this.readM(this.readBR()));
|
|
break;
|
|
case 200:
|
|
this.regY = this.regY + 1 & this.maskX();
|
|
this.upNZ(this.regY);
|
|
break;
|
|
case 201:
|
|
this.i_cmp(this.regA, this.readM());
|
|
break;
|
|
case 202:
|
|
this.regX = this.regX - 1 & this.maskX();
|
|
this.upNZ(this.regX);
|
|
break;
|
|
case 203:
|
|
this.waiTimeout = true;
|
|
break;
|
|
case 204:
|
|
this.i_cmpx(this.regY, this.readX(this.readW()));
|
|
break;
|
|
case 205:
|
|
this.i_cmp(this.regA, this.readM(this.readW()));
|
|
break;
|
|
case 206:
|
|
this.i_dec(this.readW());
|
|
break;
|
|
case 207:
|
|
this.regD = this.popM();
|
|
break;
|
|
case 208:
|
|
this.i_brc(!this.flagZ);
|
|
break;
|
|
case 209:
|
|
this.i_cmp(this.regA, this.readM(this.readBWY()));
|
|
break;
|
|
case 210:
|
|
this.i_cmp(this.regA, this.readM(this.readBW()));
|
|
break;
|
|
case 211:
|
|
this.i_cmp(this.regA, this.readM(this.readBSWY()));
|
|
break;
|
|
case 212:
|
|
this.push2(this.readBW());
|
|
break;
|
|
case 213:
|
|
this.i_cmp(this.regA, this.readM(this.readBX()));
|
|
break;
|
|
case 214:
|
|
this.i_dec(this.readBX());
|
|
break;
|
|
case 215:
|
|
this.i_cmp(this.regA, this.readM(this.readBRWY()));
|
|
break;
|
|
case 216:
|
|
this.flagD = false;
|
|
break;
|
|
case 217:
|
|
this.i_cmp(this.regA, this.readM(this.readWY()));
|
|
break;
|
|
case 218:
|
|
this.pushX(this.regX);
|
|
break;
|
|
case 219:
|
|
this.sliceCycles = -1;
|
|
if (super.worldObj.isAirBlock(super.xCoord, super.yCoord + 1, super.zCoord)) {
|
|
super.worldObj
|
|
.playSoundEffect(
|
|
(double)super.xCoord + 0.5,
|
|
(double)super.yCoord + 0.5,
|
|
(double)super.zCoord + 0.5,
|
|
"fire.ignite",
|
|
1.0F,
|
|
super.worldObj.rand.nextFloat() * 0.4F + 0.8F
|
|
);
|
|
super.worldObj.setBlock(super.xCoord, super.yCoord + 1, super.zCoord, Blocks.fire, 0, 3);
|
|
}
|
|
break;
|
|
case 220:
|
|
this.regX = this.regI;
|
|
if (this.flagX) {
|
|
this.regX &= 255;
|
|
}
|
|
|
|
this.upNZX(this.regX);
|
|
break;
|
|
case 221:
|
|
this.i_cmp(this.regA, this.readM(this.readWX()));
|
|
break;
|
|
case 222:
|
|
this.i_dec(this.readWX());
|
|
break;
|
|
case 223:
|
|
this.pushM(this.regD);
|
|
break;
|
|
case 224:
|
|
this.i_cmpx(this.regX, this.readX());
|
|
break;
|
|
case 225:
|
|
this.i_sbc(this.readM(this.readBXW()));
|
|
break;
|
|
case 226:
|
|
this.setFlags(this.getFlags() | this.readB());
|
|
break;
|
|
case 227:
|
|
this.i_sbc(this.readM(this.readBS()));
|
|
break;
|
|
case 228:
|
|
this.i_cmpx(this.regX, this.readX(this.readB()));
|
|
break;
|
|
case 229:
|
|
this.i_sbc(this.readM(this.readB()));
|
|
break;
|
|
case 230:
|
|
this.i_inc(this.readB());
|
|
break;
|
|
case 231:
|
|
this.i_sbc(this.readM(this.readBR()));
|
|
break;
|
|
case 232:
|
|
this.regX = this.regX + 1 & this.maskX();
|
|
this.upNZ(this.regX);
|
|
break;
|
|
case 233:
|
|
this.i_sbc(this.readM());
|
|
case 234:
|
|
default:
|
|
break;
|
|
case 235:
|
|
if (this.flagM) {
|
|
int nx = this.regA;
|
|
this.regA = this.regB;
|
|
this.regB = nx;
|
|
} else {
|
|
this.regA = this.regA >> 8 & 0xFF | this.regA << 8 & 0xFF00;
|
|
}
|
|
break;
|
|
case 236:
|
|
this.i_cmpx(this.regX, this.readX(this.readW()));
|
|
break;
|
|
case 237:
|
|
this.i_sbc(this.readM(this.readW()));
|
|
break;
|
|
case 238:
|
|
this.i_inc(this.readW());
|
|
break;
|
|
case 239:
|
|
this.i_mmu(this.readB());
|
|
break;
|
|
case 240:
|
|
this.i_brc(this.flagZ);
|
|
break;
|
|
case 241:
|
|
this.i_sbc(this.readM(this.readBWY()));
|
|
break;
|
|
case 242:
|
|
this.i_sbc(this.readM(this.readBW()));
|
|
break;
|
|
case 243:
|
|
this.i_sbc(this.readM(this.readBSWY()));
|
|
break;
|
|
case 244:
|
|
this.push2(this.readW());
|
|
break;
|
|
case 245:
|
|
this.i_sbc(this.readM(this.readBX()));
|
|
break;
|
|
case 246:
|
|
this.i_inc(this.readBX());
|
|
break;
|
|
case 247:
|
|
this.i_sbc(this.readM(this.readBRWY()));
|
|
break;
|
|
case 248:
|
|
this.flagD = true;
|
|
break;
|
|
case 249:
|
|
this.i_sbc(this.readM(this.readWY()));
|
|
break;
|
|
case 250:
|
|
this.regX = this.popX();
|
|
this.upNZX(this.regX);
|
|
break;
|
|
case 251:
|
|
if (this.flagE != this.flagC) {
|
|
if (this.flagE) {
|
|
this.flagE = false;
|
|
this.flagC = true;
|
|
} else {
|
|
this.flagE = true;
|
|
this.flagC = false;
|
|
if (!this.flagM) {
|
|
this.regB = this.regA >> 8;
|
|
}
|
|
|
|
this.flagM = true;
|
|
this.flagX = true;
|
|
this.regA &= 255;
|
|
this.regX &= 255;
|
|
this.regY &= 255;
|
|
}
|
|
}
|
|
break;
|
|
case 252:
|
|
this.push2(this.regPC + 1);
|
|
this.regPC = this.readWXW();
|
|
break;
|
|
case 253:
|
|
this.i_sbc(this.readM(this.readWX()));
|
|
break;
|
|
case 254:
|
|
this.i_inc(this.readWX());
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public void writeFramePacket(NBTTagCompound tag) {
|
|
this.writeToPacket(tag);
|
|
}
|
|
|
|
@Override
|
|
public void readFramePacket(NBTTagCompound tag) {
|
|
this.readFromPacket(tag);
|
|
}
|
|
|
|
@Override
|
|
public void onFrameRefresh(IBlockAccess iba) {
|
|
}
|
|
|
|
@Override
|
|
public void onFramePickup(IBlockAccess iba) {
|
|
}
|
|
|
|
@Override
|
|
public void onFrameDrop() {
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound data) {
|
|
super.readFromNBT(data);
|
|
this.memory = data.getByteArray("ram");
|
|
if (this.memory.length != 8192) {
|
|
this.memory = new byte[8192];
|
|
}
|
|
|
|
this.Rotation = data.getByte("rot");
|
|
this.addrPOR = data.getShort("por");
|
|
this.addrBRK = data.getShort("brk");
|
|
byte efl = data.getByte("efl");
|
|
this.flagE = (efl & 1) > 0;
|
|
this.mmuEnRB = (efl & 2) > 0;
|
|
this.mmuEnRBW = (efl & 4) > 0;
|
|
this.setFlags(data.getByte("fl"));
|
|
this.regSP = data.getShort("rsp");
|
|
this.regPC = data.getShort("rpc");
|
|
this.regA = data.getShort("ra");
|
|
if (this.flagM) {
|
|
this.regB = this.regA >> 8;
|
|
this.regA &= 255;
|
|
}
|
|
|
|
this.regX = data.getShort("rx");
|
|
this.regY = data.getShort("ry");
|
|
this.regD = data.getShort("rd");
|
|
this.regR = data.getShort("rr");
|
|
this.regI = data.getShort("ri");
|
|
this.mmuRBB = data.getShort("mmrb");
|
|
this.mmuRBW = data.getShort("mmrbw");
|
|
this.mmuRBA = data.getByte("mmra") & 255;
|
|
this.sliceCycles = data.getInteger("cyc");
|
|
this.rtcTicks = data.getInteger("rtct");
|
|
this.diskAddr = data.getByte("diskaddr") & 255;
|
|
this.displayAddr = data.getByte("displayaddr") & 255;
|
|
this.rbaddr = data.getByte("rbaddr") & 255;
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound data) {
|
|
super.writeToNBT(data);
|
|
data.setByte("rot", (byte)this.Rotation);
|
|
data.setByteArray("ram", this.memory);
|
|
data.setShort("por", (short)this.addrPOR);
|
|
data.setShort("brk", (short)this.addrBRK);
|
|
int efl = (this.flagE ? 1 : 0) | (this.mmuEnRB ? 2 : 0) | (this.mmuEnRBW ? 4 : 0);
|
|
data.setByte("efl", (byte)efl);
|
|
data.setByte("fl", (byte)this.getFlags());
|
|
data.setShort("rsp", (short)this.regSP);
|
|
data.setShort("rpc", (short)this.regPC);
|
|
if (this.flagM) {
|
|
this.regA = this.regA & 0xFF | this.regB << 8;
|
|
}
|
|
|
|
data.setShort("ra", (short)this.regA);
|
|
if (this.flagM) {
|
|
this.regA &= 255;
|
|
}
|
|
|
|
data.setShort("rx", (short)this.regX);
|
|
data.setShort("ry", (short)this.regY);
|
|
data.setShort("rd", (short)this.regD);
|
|
data.setShort("rr", (short)this.regR);
|
|
data.setShort("ri", (short)this.regI);
|
|
data.setShort("mmrb", (short)this.mmuRBB);
|
|
data.setShort("mmrbw", (short)this.mmuRBW);
|
|
data.setByte("mmra", (byte)this.mmuRBA);
|
|
data.setInteger("cyc", this.sliceCycles);
|
|
data.setInteger("rtct", this.rtcTicks);
|
|
data.setByte("diskaddr", (byte)this.diskAddr);
|
|
data.setByte("displayaddr", (byte)this.displayAddr);
|
|
data.setByte("rbaddr", (byte)this.rbaddr);
|
|
}
|
|
|
|
@Override
|
|
protected void readFromPacket(NBTTagCompound tag) {
|
|
this.Rotation = tag.getInteger("rot");
|
|
}
|
|
|
|
@Override
|
|
protected void writeToPacket(NBTTagCompound tag) {
|
|
tag.setInteger("rot", this.Rotation);
|
|
}
|
|
}
|