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!");
}
}
