public BitShift(int lnum, uint tabs, string ins, char size, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.ins = ins; this.size = size; this.parts = parts; anum = (uint)Window.getArgNum(parts); if (anum != 1 && anum != 2) { Window.ShowParseError(lnum, ins.ToUpper() + " instruction requires 1 or 2 arguments, but " + anum + " were found!\nParsing will now terminate.", "Error!"); return; } if (anum == 1 && (size != 'w' && size != '2' && size != '\0')) { Window.ShowParseError(lnum, "Instruction size can only be word when bit count is not specified!", "Error!"); } if (anum == 2 && ArgEnum.get(parts[1]).Type != typeof(ArgDataDirect)) { Window.ShowParseError(lnum, "Argument 2 can only be data register when bitcount is specified!", "Error!"); } if (anum == 2 && ArgEnum.get(parts[1]).Type == typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument 2 can not be immediate value!", "Error!"); } isdn = ArgEnum.get(parts[anum - 1]).Type == typeof(ArgDataDirect); }
public Xor(int lnum, uint tabs, char size, string ins, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.ins = ins; this.size = size; if (!checkArgNums()) { return; } if (ins.EndsWith("i") && ArgEnum.get(parts[0]).Type != typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument 1 must be a immediate value, but was '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } else if (ArgEnum.get(parts[0]).Type != typeof(ArgImmediateValue) && ArgEnum.get(parts[0]).Type != typeof(ArgDataDirect)) { Window.ShowParseError(lnum, "Argument 1 must be a data register or immediate value, but was '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[1]).Type == typeof(ArgImmediateValue) || ArgEnum.get(parts[1]).Type == typeof(ArgAddressDirect)) { Window.ShowParseError(lnum, "Argument 2 can not be immediate value or address direct!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[0]).Type == typeof(ArgImmediateValue)) { ((ArgImmediateValue)parts[0]).block(true); if (ArgEnum.get(parts[1]).Type == typeof(ArgDataDirect)) { cycles = 4; read = 1; write = 0; overwrite = true; } else { cycles = 8; read = 1; write = 1; } } else { if (ArgEnum.get(parts[1]).Type == typeof(ArgDataDirect)) { cycles = 8; read = 2; write = 0; overwrite = true; } else { cycles = 12; read = 2; write = 1; } } }
public Stop(int lnum, uint tabs, ArgumentPart[] parts) : base(lnum, tabs, parts) { checkArgNums(); if (ArgEnum.get(parts[0]).Type != typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument must be immediate value, but is '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } }
public Bit(int lnum, uint tabs, string ins, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.ins = ins; if (!checkArgNums()) { return; } if (ArgEnum.get(parts[1]).Type == typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument 2 can not be immediate value!", "Error!"); } if (ArgEnum.get(parts[0]).Type != typeof(ArgImmediateValue) && ArgEnum.get(parts[0]).Type != typeof(ArgDataDirect)) { Window.ShowParseError(lnum, "Argument 2 must be a data register or immediate value, but is '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } bool isdn = ArgEnum.get(parts[0]).Type == typeof(ArgDataDirect); if (ins.Equals("bchg") || ins.Equals("bset")) { cycles = isdn ? 8 : 12; read = isdn ? 1 : 2; write = ArgEnum.get(parts[1]).Type == typeof(ArgDataDirect) ? 0 : 1; } else if (ins.Equals("bclr")) { read = isdn ? 1 : 2; if (ArgEnum.get(parts[1]).Type == typeof(ArgDataDirect)) { write = 0; cycles = isdn ? 8 : 12; } else { cycles = isdn ? 10 : 14; write = 1; } } else if (ins.Equals("btst")) { read = isdn ? 1 : 2; write = 0; if (ArgEnum.get(parts[1]).Type == typeof(ArgDataDirect)) { cycles = isdn ? 4 : 8; } else { cycles = isdn ? 6 : 10; } } }
public Unlink(int lnum, uint tabs, ArgumentPart[] parts) : base(lnum, tabs, parts) { if (!checkArgNums()) { return; } if (ArgEnum.get(parts[0]).Type != typeof(ArgAddressDirect)) { Window.ShowParseError(lnum, "Argument must be a address register, but is '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } }
public Cmp(int lnum, uint tabs, char size, string ins, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.ins = ins; this.size = size; if (!checkArgNums()) { return; } if (ins.EndsWith("i") && ArgEnum.get(parts[0]).Type != typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument 1 must be a immediate value, but was '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } else if (ins.EndsWith("a") && ArgEnum.get(parts[1]).Type != typeof(ArgAddressDirect)) { Window.ShowParseError(lnum, "Argument 2 must be a address register direct, but was '" + parts[1] + "' instead!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[1]).Type == typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument 2 can not be immediate value!\nParsing will now terminate.", "Error!"); } if ((ArgEnum.get(parts[1]).Type == typeof(ArgAddressDirect) || ArgEnum.get(parts[0]).Type == typeof(ArgAddressDirect)) && (size == 'b' || size == '1')) { Window.ShowParseError(lnum, "Instruction size needs to be word or long when either argument is address register direct!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[0]).Type == typeof(ArgImmediateValue) && ArgEnum.get(parts[1]).Type == typeof(ArgDataDirect)) { ((ArgImmediateValue)parts[0]).block(true); cycles = (size == 'l' || size == '4') ? 14 : 8; read = (size == 'l' || size == '4') ? 3 : 2; write = 0; overwrite = true; } else { if (ArgEnum.get(parts[1]).Type == typeof(ArgAddressDirect)) { cycles = 6; read = 1; write = 0; } else { cycles = (size == 'l' || size == '4') ? 6 : 4; read = 1; write = 0; } } }
public Tas(int lnum, uint tabs, ArgumentPart[] parts) : base(lnum, tabs, parts) { if (!checkArgNums()) { return; } isdn = ArgEnum.get(parts[0]).Type == typeof(ArgDataDirect); if (!isdn && ArgEnum.get(parts[0]).Type == typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument can not be immediate value!", "Error!"); } }
public Ext(int lnum, uint tabs, char size, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.size = size; if (!checkArgNums()) { return; } if (ArgEnum.get(parts[0]).Type != typeof(ArgDataDirect)) { Window.ShowParseError(lnum, "Argument must be a data register, but is '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } }
public Tst(int lnum, uint tabs, char size, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.size = size; if (!checkArgNums()) { return; } if (ArgEnum.get(parts[0]).Type == typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument can not be immediate value!", "Error!"); } }
public MulDiv(int lnum, uint tabs, string ins, char size, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.ins = ins; this.size = size; if (!checkArgNums()) { return; } if (size != '\0' && size != 'w' && size != '2') { Window.ShowParseError(lnum, "Intruction size must be word!\nParsing will now terminate.", "Error!"); return; } if (ArgEnum.get(parts[1]).Type != typeof(ArgDataDirect)) { Window.ShowParseError(lnum, "Argument 2 must be an data register, but was '" + parts[1] + "' instead!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[0]).Type == typeof(ArgImmediateValue)) { bytes = 4; } else { bytes = 2 + parts[0].getByteCount(); } if (ins.Equals("divs")) { cycles = 158 + parts[0].getCycles(); read = 1 + parts[0].getReadCycles(); write = 0 + parts[0].getWriteCycles(); } else if (ins.Equals("divu")) { cycles = 140 + parts[0].getCycles(); read = 1 + parts[0].getReadCycles(); write = 0 + parts[0].getWriteCycles(); } else { cycles = 70 + parts[0].getCycles(); read = 1 + parts[0].getReadCycles(); write = 0 + parts[0].getWriteCycles(); } }
public Clr(int lnum, uint tabs, char size, string ins, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.size = size; this.ins = ins; if (!checkArgNums()) { return; } isdn = ArgEnum.get(parts[0]).Type == typeof(ArgDataDirect); if (!isdn && ArgEnum.get(parts[0]).Type == typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument can not be immediate value!", "Error!"); } }
public SAddq(int lnum, uint tabs, char size, string ins, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.size = size; this.ins = ins; if (!checkArgNums()) { return; } if (ArgEnum.get(parts[1]).Type == typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument 2 can not be immediate value!", "Error!"); } if (ArgEnum.get(parts[0]).Type != typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument 1 must be an immediate value, but was '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } bytes = 2 + parts[1].getByteCount(); if (ArgEnum.get(parts[1]).Type == typeof(ArgDataDirect)) { cycles = (size == 'l' || size == '4') ? 8 : 4; read = 1; write = 0; } else if (ArgEnum.get(parts[1]).Type == typeof(ArgAddressDirect)) { if (size != 'w' && size != '2') { Window.ShowParseError(lnum, "Instructions size must be word when in address direct mode!\nParsing will now terminate.", "Error!"); } else { cycles = 8; read = 1; write = 0; } } else { cycles = ((size == 'l' || size == '4') ? 12 : 8) + (int)parts[1].getCycles(); read = 1 + (int)parts[1].getReadCycles(); write = ((size == 'l' || size == '4') ? 2 : 1) + (int)parts[1].getWriteCycles(); } }
public Lea(int lnum, uint tabs, ArgumentPart[] parts) : base(lnum, tabs, parts) { if (!checkArgNums()) { return; } if (ArgEnum.get(parts[1]).Type != typeof(ArgAddressDirect)) { Window.ShowParseError(lnum, "Argument 2 must be a address register, but is '" + parts[1] + "' instead!\nParsing will now terminate.", "Error!"); } switch (ArgEnum.get(parts[0]).Index) { case 2: cycles = 4; read = 1; write = 0; break; case 5: case 7: case 10: cycles = 8; read = 2; write = 0; break; case 9: cycles = 12; read = 3; write = 0; break; case 6: case 8: cycles = 12; read = 2; write = 0; break; default: Window.ShowParseError(lnum, "Illegal argument '" + parts[0] + "'!\nParsing will now terminate.", "Error!"); return; } }
public Moveq(int lnum, uint tabs, ArgumentPart[] parts) : base(lnum, tabs, parts) { if (!checkArgNums()) { return; } if (ArgEnum.get(parts[0]).Type != typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument 2 must be an immediate value, but was '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[1]).Type != typeof(ArgDataDirect)) { Window.ShowParseError(lnum, "Argument 2 must be an data register, but was '" + parts[1] + "' instead!\nParsing will now terminate.", "Error!"); } }
public Cmpm(int lnum, uint tabs, char size, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.size = size; if (!checkArgNums()) { return; } if (ArgEnum.get(parts[0]).Index != ArgEnum.get(parts[1]).Index) { Window.ShowParseError(lnum, "Both arguments need to be of same type!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[1]).Type != typeof(ArgAddressIndirectWithPostIncrement)) { Window.ShowParseError(lnum, "Excpected arguments to be ddress register with post-increment!", "Error!"); } }
public Scc(int lnum, uint tabs, string ins, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.ins = ins; if (!checkArgNums()) { return; } isdn = ArgEnum.get(parts[0]).Type == typeof(ArgDataDirect); if (!isdn && ArgEnum.get(parts[0]).Type == typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument can not be immediate value!", "Error!"); } cycles = (isdn ? 6 : 8 + parts[0].getCycles()); read = 1 + parts[0].getReadCycles(); write = (isdn ? 0 : 1 + parts[0].getWriteCycles()); }
public Dbcc(int lnum, uint tabs, string ins, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.ins = ins; if (!checkArgNums()) { return; } if (ArgEnum.get(parts[0]).Type != typeof(ArgDataDirect)) { Window.ShowParseError(lnum, "Argument 1 must be a data register, but was '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[1]).Type != typeof(ArgAbsoluteLong) && ArgEnum.get(parts[1]).Type != typeof(ArgLable)) { Window.ShowParseError(lnum, "Argument 2 must be a lable, but was '" + parts[1] + "' instead!\nParsing will now terminate.", "Error!"); } }
public AndOrEorCCRorSR(int lnum, uint tabs, char size, string ins, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.ins = ins; this.size = size; if (!checkArgNums()) { return; } if (ArgEnum.get(parts[0]).Type != typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument 1 must be immediate value!\nParsing will now terminate.", "Error!"); return; } if (ArgEnum.get(parts[1]).Type == typeof(ArgCCR)) { if (size != 'b' && size != '1' && size != '\0') { Window.ShowParseError(lnum, "Illegal instruction size! " + ins.ToUpper() + " to CCR expects byte operation!\nParsing will now terminate.", "Error!"); return; } cycles = 20; read = 3; write = 0; } else if (ArgEnum.get(parts[1]).Type == typeof(ArgSR)) { if (size != 'w' && size != '2' && size != '\0') { Window.ShowParseError(lnum, "Illegal instruction size! " + ins.ToUpper() + " to SR expects word operation!\nParsing will now terminate.", "Error!"); return; } cycles = 20; read = 3; write = 0; } else { Window.ShowParseError(lnum, "Unknown error with AndOrEorCCRorSR in line " + lnum + "\nParsing will now terminate.", "Error!"); } }
public Bcc(int lnum, uint tabs, string ins, char size, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.size = size; this.ins = ins; if (!checkArgNums()) { return; } if (size != 's' && size != 'b' && size != 'w' && size != '1' && size != '2') { Window.ShowParseError(lnum, ins.ToUpper() + " can only be byte or word size in M68000!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[0]).Type != typeof(ArgAbsoluteLong) && ArgEnum.get(parts[0]).Type != typeof(ArgLable)) { Window.ShowParseError(lnum, "Argument must be a lable, but was '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } }
public MoveP(int lnum, uint tabs, char size, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.size = size; bool datafirst = false; if (!checkArgNums()) { return; } for (int i = 0; i < 2; i++) { if (ArgEnum.get(parts[i]).Type != typeof(ArgDataDirect) && ArgEnum.get(parts[i]).Type != typeof(ArgAddressIndirectWithIndex) && ArgEnum.get(parts[i]).Type != typeof(ArgAddressIndirect)) { Window.ShowParseError(lnum, "Argument " + i + " must be a data register or address register with offset, but is '" + parts[i] + "' instead!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[i]).Type == typeof(ArgDataDirect)) { datafirst = i == 0; } } if (size == 'w' || size == '\0') { cycles = 16; read = datafirst ? 2 : 4; write = datafirst ? 2 : 0; } else if (size == 'l') { cycles = 24; read = datafirst ? 2 : 6; write = datafirst ? 4 : 0; } else { Window.ShowParseError(lnum, "Instruction size was expected to be word or long, but was '" + size + "' instead!\nParsing will now terminate.", "Error!"); } }
public Pea(int lnum, uint tabs, ArgumentPart[] parts) : base(lnum, tabs, parts) { if (!checkArgNums()) { return; } switch (ArgEnum.get(parts[0]).Index) { case 2: cycles = 12; read = 1; write = 2; break; case 5: case 7: case 10: cycles = 16; read = 2; write = 2; break; case 9: cycles = 20; read = 3; write = 2; break; case 6: case 8: cycles = 20; read = 2; write = 2; break; default: Window.ShowParseError(lnum, "Illegal argument '" + parts[0] + "'!\nParsing will now terminate.", "Error!"); return; } }
public ASbcd(int lnum, uint tabs, string ins, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.ins = ins; if (!checkArgNums()) { return; } if (ArgEnum.get(parts[0]).Index != ArgEnum.get(parts[1]).Index) { Window.ShowParseError(lnum, "Both arguments need to be of same type!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[0]).Type != typeof(ArgDataDirect) && ArgEnum.get(parts[1]).Type != typeof(ArgAddressIndirectWithPreDecrement)) { Window.ShowParseError(lnum, "Excpected arguments to be either data registers or address registers with pre-decrement!", "Error!"); } if (ArgEnum.get(parts[0]).Type == typeof(ArgDataDirect)) { isdn = true; } }
public AndOr(int lnum, uint tabs, char size, string ins, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.ins = ins; this.size = size; if (!checkArgNums()) { return; } if (ins.EndsWith("i") && ArgEnum.get(parts[0]).Type != typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument 1 must be a immediate value, but was '" + parts[0] + "' instead!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[1]).Type == typeof(ArgImmediateValue)) { Window.ShowParseError(lnum, "Argument 2 can not be immediate value!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[1]).Type == typeof(ArgAddressDirect) || ArgEnum.get(parts[0]).Type == typeof(ArgAddressDirect)) { Window.ShowParseError(lnum, "Either argument must not be address register direct!\nParsing will now terminate.", "Error!"); } if (ArgEnum.get(parts[0]).Type == typeof(ArgImmediateValue)) { ((ArgImmediateValue)parts[0]).block(true); if (ArgEnum.get(parts[1]).Type == typeof(ArgDataDirect)) { // #,Dn cycles = (size == 'l' || size == '4') ? 16 : 8; read = (size == 'l' || size == '4') ? 3 : 2; write = 0; overwrite = true; } else { cycles = (size == 'l' || size == '4') ? 20 : 12; read = (size == 'l' || size == '4') ? 3 : 2; write = (size == 'l' || size == '4') ? 2 : 1; } } else { if (ArgEnum.get(parts[1]).Type == typeof(ArgDataDirect)) { if (ArgEnum.get(parts[0]).Type == typeof(ArgDataDirect)) { // Dn,Dn cycles = (size == 'l' || size == '4') ? 8 : 4; read = 1; write = 0; overwrite = true; } else { // <ea>,Dn cycles = (size == 'l' || size == '4') ? 6 : 4; read = 1; write = 0; } } else { // Dn,<M> cycles = (size == 'l' || size == '4') ? 12 : 8; read = 1; write = (size == 'l' || size == '4') ? 2 : 1; } } }
public override uint getBytesCount() { return(ArgEnum.get(parts[0]).Type == typeof(ArgImmediateValue) ? (uint)0 : 2); }
public MoveToCCRSRUSP(int lnum, uint tabs, char size, ArgumentPart[] parts) : base(lnum, tabs, parts) { this.size = size; if (!checkArgNums()) { return; } if (ArgEnum.get(parts[1]).Type == typeof(ArgCCR)) { if (size != 'b' && size != '1' && size != '\0') { Window.ShowParseError(lnum, "Illegal instruction size! MOVE to CCR expects byte operation!\nParsing will now terminate.", "Error!"); return; } if (ArgEnum.get(parts[0]).Type == typeof(ArgAddressDirect) || ArgEnum.get(parts[1]).Type == typeof(ArgAddressDirect)) { Window.ShowParseError(lnum, "Either argument must not be address register direct!\nParsing will now terminate.", "Error!"); return; } cycles = 12; read = 1; write = 0; } else if (ArgEnum.get(parts[0]).Type == typeof(ArgSR) || ArgEnum.get(parts[1]).Type == typeof(ArgSR)) { if (size != 'w' && size != '2' && size != '\0') { Window.ShowParseError(lnum, "Illegal instruction size! MOVE to SR expects word operation!\nParsing will now terminate.", "Error!"); return; } if (ArgEnum.get(parts[0]).Type == typeof(ArgAddressDirect) || ArgEnum.get(parts[1]).Type == typeof(ArgAddressDirect)) { Window.ShowParseError(lnum, "Either argument must not be address register direct!\nParsing will now terminate.", "Error!"); return; } if (ArgEnum.get(parts[0]).Type == typeof(ArgSR)) { if (ArgEnum.get(parts[1]).Type == typeof(ArgDataDirect)) { // Dn,SR cycles = 6; read = 1; write = 0; } else { // <ae>,SR cycles = 8; read = 1; write = 1; } } else { // to SR cycles = 12; read = 1; write = 0; } } else if (ArgEnum.get(parts[0]).Type == typeof(ArgUSP) || ArgEnum.get(parts[1]).Type == typeof(ArgUSP)) { if (ArgEnum.get(parts[0]).Type != typeof(ArgAddressDirect) && ArgEnum.get(parts[1]).Type != typeof(ArgAddressDirect)) { Window.ShowParseError(lnum, "Either argument must be address register direct!\nParsing will now terminate.", "Error!"); } cycles = 4; read = 1; write = 0; } else { Window.ShowParseError(lnum, "Unknown error with MoveToCCRSRUSP in line " + lnum + "\nParsing will now terminate.", "Error!"); } }