public void Compile()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass");
cls.DefineInstanceVariable("x");
cls.DefineClassVariable("count");
Block block;
block = new Method(cls, "x:");
block.CompileArgument("newX");
block.CompileGet("newX");
block.CompileGet("count");
block.CompileSet("x");
Assert.AreEqual(1, block.Arity);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.IsTrue(block.ByteCodes.Length > 0);
BlockDecompiler decompiler = new BlockDecompiler(block);
var result = decompiler.Decompile();
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Count);
Assert.AreEqual("GetArgument newX", result[0]);
Assert.AreEqual("GetClassVariable count", result[1]);
Assert.AreEqual("SetInstanceVariable x", result[2]);
}
public void CompileBlock()
{
ModelParser parser = new ModelParser("nil ifFalse: [self halt]");
this.compiler.CompileExpression(parser.ParseExpression());
Assert.IsNotNull(block);
Assert.AreEqual(1, block.NoConstants);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(11, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
object constant = block.GetConstant(0);
Assert.IsNotNull(constant);
Assert.IsInstanceOfType(constant, typeof(Block));
var newblock = (Block)constant;
Assert.AreEqual(0, newblock.Arity);
Assert.AreEqual(0, newblock.NoLocals);
Assert.IsNotNull(newblock.ByteCodes);
Assert.AreEqual(4, newblock.ByteCodes.Length);
BlockDecompiler decompiler = new BlockDecompiler(block);
var result = decompiler.Decompile();
Assert.IsNotNull(result);
Assert.AreEqual("GetNil", result[0]);
Assert.AreEqual("JumpIfFalse 8", result[1]);
Assert.AreEqual("GetNil", result[2]);
Assert.AreEqual("Jump 11", result[3]);
Assert.AreEqual("GetBlock { GetSelf; Send halt 0 }", result[4]);
}
public void DecompileGetIntegerConstantAsString()
{
Block block = new Block();
block.CompileGetConstant(1);
BlockDecompiler decompiler = new BlockDecompiler(block);
var result = decompiler.DecompileAsString();
Assert.IsNotNull(result);
Assert.AreEqual("{ GetConstant 1 }", result);
}
public void DecompileGetGlobalVariable()
{
Block block = new Block();
block.CompileGet("foo");
BlockDecompiler decompiler = new BlockDecompiler(block);
var result = decompiler.Decompile();
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
Assert.AreEqual("GetGlobalVariable foo", result[0]);
}
public void ValidateBlock(Block block)
{
BlockDecompiler decompiler = new BlockDecompiler(block);
var result = decompiler.Decompile();
Assert.IsNotNull(result);
Assert.AreEqual(this.compiled.Count, result.Count, this.text);
for (int k = 0; k < this.compiled.Count; k++)
Assert.AreEqual(this.compiled[k], result[k], this.text);
}
public void DecompileGetIntegerConstant()
{
Block block = new Block();
block.CompileGetConstant(1);
BlockDecompiler decompiler = new BlockDecompiler(block);
var result = decompiler.Decompile();
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
Assert.AreEqual("GetConstant 1", result[0]);
}
public void DecompileGetConstants()
{
Block block = new Block();
block.CompileGetConstant(1);
block.CompileGetConstant("foo");
BlockDecompiler decompiler = new BlockDecompiler(block);
var result = decompiler.Decompile();
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual("GetConstant 1", result[0]);
Assert.AreEqual("GetConstant \"foo\"", result[1]);
}
public void CompileSimpleArithmeticWithParenthesis()
{
ModelParser parser = new ModelParser("1 * (2 + 3)");
IExpression expr = parser.ParseExpression();
this.compiler.CompileExpression(expr);
Assert.IsNotNull(this.block);
Assert.AreEqual(5, this.block.NoConstants);
Assert.AreEqual(0, this.block.NoLocals);
Assert.IsNotNull(this.block.ByteCodes);
Assert.AreEqual(12, this.block.ByteCodes.Length);
Assert.AreEqual(0, this.block.Arity);
BlockDecompiler decompiler = new BlockDecompiler(this.block);
var program = decompiler.Decompile();
Assert.IsNotNull(program);
Assert.AreEqual(5, program.Count);
Assert.AreEqual("GetConstant 1", program[0]);
Assert.AreEqual("GetConstant 2", program[1]);
Assert.AreEqual("GetConstant 3", program[2]);
Assert.AreEqual("Send + 1", program[3]);
Assert.AreEqual("Send * 1", program[4]);
}
public void CompileWhileTrue()
{
Block block = this.compiler.CompileBlock(":arg | [arg < 3] whileTrue: [arg := arg + 1]");
Assert.IsNotNull(block);
Assert.AreEqual(13, block.Bytecodes.Length);
var decompiler = new BlockDecompiler(block);
var steps = decompiler.Decompile();
Assert.IsNotNull(steps);
Assert.AreEqual(7, steps.Count);
Assert.AreEqual("GetBlock { GetArgument arg; GetConstant 3; Send < 1 }", steps[0]);
Assert.AreEqual("Value", steps[1]);
Assert.AreEqual("JumpIfFalse 13", steps[2]);
Assert.AreEqual("GetBlock { GetArgument arg; GetConstant 1; Send + 1; SetArgument arg }", steps[3]);
Assert.AreEqual("Value", steps[4]);
Assert.AreEqual("Pop", steps[5]);
Assert.AreEqual("Jump 0", steps[6]);
}
public void CompileSumWithNegativeNumber()
{
var result = this.compiler.CompileBlock("-1 + 0");
Assert.IsNotNull(result);
Assert.IsNotNull(result.ByteCodes);
BlockDecompiler decompiler = new BlockDecompiler(result);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual(4, ops.Count);
Assert.AreEqual("GetConstant 1", ops[0]);
Assert.AreEqual("Send minus 0", ops[1]);
Assert.AreEqual("GetConstant 0", ops[2]);
Assert.AreEqual("Send + 1", ops[3]);
}
public void CompileSimpleOr()
{
var result = this.compiler.CompileBlock("1 | 0");
Assert.IsNotNull(result);
Assert.IsNotNull(result.ByteCodes);
BlockDecompiler decompiler = new BlockDecompiler(result);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual(3, ops.Count);
Assert.AreEqual("GetConstant 1", ops[0]);
Assert.AreEqual("GetConstant 0", ops[1]);
Assert.AreEqual("Send | 1", ops[2]);
}
public void CompileSimpleExpressionInParenthesis()
{
var block = this.compiler.CompileBlock("(1+2)");
Assert.IsNotNull(block);
Assert.AreEqual(0, block.NoLocals);
Assert.AreEqual(3, block.NoConstants);
Assert.AreEqual(0, block.NoGlobalNames);
BlockDecompiler decompiler = new BlockDecompiler(block);
var result = decompiler.Decompile();
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Count);
Assert.AreEqual("GetConstant 1", result[0]);
Assert.AreEqual("GetConstant 2", result[1]);
Assert.AreEqual("Send + 1", result[2]);
}
public void CompileSymbolArray()
{
Parser parser = new Parser("#(a b c)");
var result = parser.CompileBlock();
Assert.IsNotNull(result);
Assert.IsNotNull(result.ByteCodes);
BlockDecompiler decompiler = new BlockDecompiler(result);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual(1, ops.Count);
Assert.IsTrue(ops[0].StartsWith("GetConstant "));
}
public void CompileSimpleSum()
{
Parser compiler = new Parser("1 + 2");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(7, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
BlockDecompiler decompiler = new BlockDecompiler(block);
var result = decompiler.Decompile();
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Count);
Assert.AreEqual("GetConstant 1", result[0]);
Assert.AreEqual("GetConstant 2", result[1]);
Assert.AreEqual("Send + 1", result[2]);
}
public void CompileSimpleEqual()
{
Parser parser = new Parser("1 = 2");
var result = parser.CompileBlock();
Assert.IsNotNull(result);
Assert.IsNotNull(result.ByteCodes);
BlockDecompiler decompiler = new BlockDecompiler(result);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual(3, ops.Count);
Assert.AreEqual("GetConstant 1", ops[0]);
Assert.AreEqual("GetConstant 2", ops[1]);
Assert.AreEqual("Send = 1", ops[2]);
}
public void CompileNumericPrimitive()
{
var result = this.compiler.CompileBlock("<primitive: 60>");
Assert.IsNotNull(result);
Assert.IsNotNull(result.ByteCodes);
BlockDecompiler decompiler = new BlockDecompiler(result);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual(1, ops.Count);
Assert.AreEqual("Primitive 60", ops[0]);
}
public void CompileSimpleAssingWithEqual()
{
var result = this.compiler.CompileBlock("result := value = value");
Assert.IsNotNull(result);
Assert.IsNotNull(result.ByteCodes);
BlockDecompiler decompiler = new BlockDecompiler(result);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual(4, ops.Count);
Assert.AreEqual("GetGlobalVariable value", ops[0]);
Assert.AreEqual("GetGlobalVariable value", ops[1]);
Assert.AreEqual("Send = 1", ops[2]);
Assert.AreEqual("SetGlobalVariable result", ops[3]);
}
public void CompileBlockInBrackets()
{
var result = this.compiler.CompileBlock("[a := 1]");
Assert.IsNotNull(result);
Assert.IsNotNull(result.ByteCodes);
BlockDecompiler decompiler = new BlockDecompiler(result);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual("GetBlock { GetConstant 1; SetGlobalVariable a }", ops[0]);
}
public void CompileSimpleExpressionInParenthesisUsingYourself()
{
var block = this.compiler.CompileBlock("(1+2;yourself)");
Assert.IsNotNull(block);
Assert.AreEqual(0, block.NoLocals);
Assert.AreEqual(4, block.NoConstants);
Assert.AreEqual(0, block.NoGlobalNames);
BlockDecompiler decompiler = new BlockDecompiler(block);
var result = decompiler.Decompile();
Assert.IsNotNull(result);
Assert.AreEqual(5, result.Count);
Assert.AreEqual("GetConstant 1", result[0]);
Assert.AreEqual("GetConstant 2", result[1]);
Assert.AreEqual("Send + 1", result[2]);
Assert.AreEqual("ChainedSend", result[3]);
Assert.AreEqual("Send yourself 0", result[4]);
}
public void CompileBlockWithLocalVariable()
{
var result = this.compiler.CompileBlock("|a| a := 1");
Assert.IsNotNull(result);
Assert.IsNotNull(result.ByteCodes);
BlockDecompiler decompiler = new BlockDecompiler(result);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual("SetLocal a", ops[1]);
}
public void CompileSimpleSetExpression()
{
var result = this.compiler.CompileBlock("a := 1");
Assert.IsNotNull(result);
Assert.IsNotNull(result.ByteCodes);
Assert.AreEqual(ByteCode.SetGlobalVariable, (ByteCode)result.ByteCodes[2]);
BlockDecompiler decompiler = new BlockDecompiler(result);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual("SetGlobalVariable a", ops[1]);
}
public void CompileDottedName()
{
Block block = this.compiler.CompileBlock("Smalltalk.MyPackage.MyClass");
Assert.IsNotNull(block);
Assert.IsTrue(block.NoConstants > 0);
var decompiler = new BlockDecompiler(block);
var steps = decompiler.Decompile();
Assert.IsNotNull(steps);
Assert.AreEqual(5, steps.Count);
Assert.AreEqual("GetGlobalVariable Smalltalk", steps[0]);
Assert.AreEqual("GetConstant \"MyPackage\"", steps[1]);
Assert.AreEqual("Send at: 1", steps[2]);
Assert.AreEqual("GetConstant \"MyClass\"", steps[3]);
Assert.AreEqual("Send at: 1", steps[4]);
}
public void CompileSuperNew()
{
Block block = this.compiler.CompileInstanceMethod("new super new", null);
Assert.IsNotNull(block);
var decompiler = new BlockDecompiler(block);
var steps = decompiler.Decompile();
Assert.IsNotNull(steps);
Assert.AreEqual(2, steps.Count);
Assert.AreEqual("GetSuper", steps[0]);
Assert.AreEqual("Send new 0", steps[1]);
}
public void CompileDynamicArray()
{
var result = this.compiler.CompileBlock("{a. b. 3}");
Assert.IsNotNull(result);
Assert.IsNotNull(result.ByteCodes);
BlockDecompiler decompiler = new BlockDecompiler(result);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual(4, ops.Count);
Assert.AreEqual("GetGlobalVariable a", ops[0]);
Assert.AreEqual("GetGlobalVariable b", ops[1]);
Assert.AreEqual("GetConstant 3", ops[2]);
Assert.AreEqual("MakeCollection 3", ops[3]);
}
public void CompileIntegerArray()
{
ModelParser parser = new ModelParser("#(1 2 3)");
this.compiler.CompileExpression(parser.ParseExpression());
Assert.IsNotNull(this.block.ByteCodes);
BlockDecompiler decompiler = new BlockDecompiler(this.block);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual(1, ops.Count);
Assert.AreEqual("GetConstant System.Object[]", ops[0]);
}
public void CompileGetLocalInBlock()
{
Block block = this.compiler.CompileBlock("| env | [env at: #MyGlobal] value");
Assert.IsNotNull(block);
Assert.IsTrue(block.NoConstants > 0);
var result = block.GetConstant(0);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Block));
var decompiler = new BlockDecompiler((Block)result);
var steps = decompiler.Decompile();
Assert.IsTrue(steps.Contains("GetLocal env"));
}
public void CompileSimpleSum()
{
ModelParser parser = new ModelParser("1 + 2");
IExpression expr = parser.ParseExpression();
this.compiler.CompileExpression(expr);
Assert.IsNotNull(this.block);
Assert.AreEqual(3, this.block.NoConstants);
Assert.AreEqual(0, this.block.NoLocals);
Assert.IsNotNull(this.block.ByteCodes);
Assert.AreEqual(7, this.block.ByteCodes.Length);
Assert.AreEqual(0, this.block.Arity);
BlockDecompiler decompiler = new BlockDecompiler(this.block);
var program = decompiler.Decompile();
Assert.IsNotNull(program);
Assert.AreEqual(3, program.Count);
Assert.AreEqual("GetConstant 1", program[0]);
Assert.AreEqual("GetConstant 2", program[1]);
Assert.AreEqual("Send + 1", program[2]);
}
public void CompileIntegerArray()
{
var result = this.compiler.CompileBlock("#(1 2 3)");
Assert.IsNotNull(result);
Assert.IsNotNull(result.ByteCodes);
BlockDecompiler decompiler = new BlockDecompiler(result);
var ops = decompiler.Decompile();
Assert.IsNotNull(ops);
Assert.AreEqual(1, ops.Count);
Assert.AreEqual("GetConstant System.Object[]", ops[0]);
}
public void CompileTwoSimpleCommand()
{
ModelParser parser = new ModelParser("a := 1. b := 2");
this.compiler.CompileExpressions(parser.ParseExpressions());
Assert.IsNotNull(this.block);
Assert.AreEqual(2, this.block.NoConstants);
Assert.AreEqual(0, this.block.NoLocals);
Assert.AreEqual(2, this.block.NoGlobalNames);
Assert.IsNotNull(this.block.ByteCodes);
Assert.AreEqual(8, this.block.ByteCodes.Length);
Assert.AreEqual(0, this.block.Arity);
BlockDecompiler decompiler = new BlockDecompiler(this.block);
var program = decompiler.Decompile();
Assert.IsNotNull(program);
Assert.AreEqual(4, program.Count);
Assert.AreEqual("GetConstant 1", program[0]);
Assert.AreEqual("SetGlobalVariable a", program[1]);
Assert.AreEqual("GetConstant 2", program[2]);
Assert.AreEqual("SetGlobalVariable b", program[3]);
}
public void CompileNegativeInteger()
{
Block block = this.compiler.CompileBlock("-1");
Assert.IsNotNull(block);
Assert.AreEqual(0, block.NoLocals);
Assert.AreEqual(2, block.NoConstants);
Assert.AreEqual(0, block.NoGlobalNames);
BlockDecompiler decompiler = new BlockDecompiler(block);
var result = decompiler.Decompile();
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual("GetConstant 1", result[0]);
Assert.AreEqual("Send minus 0", result[1]);
}
