protected override object Evaluate(string text, Machine machine)
{
Parser parser = new Parser(text);
Block block = parser.CompileBlock();
Process process = new Process(block, null, machine);
return process.Execute();
}
public void CompileBlock()
{
Parser compiler = new Parser("nil ifFalse: [self halt]");
Block block = compiler.CompileBlock();
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 CompileAndExecuteTwoSimpleCommand()
{
Parser compiler = new Parser("a := 1. b := 2");
Block block = compiler.CompileBlock();
Machine machine = new Machine();
block.Execute(machine, null);
Assert.AreEqual(1, machine.GetGlobalObject("a"));
Assert.AreEqual(2, machine.GetGlobalObject("b"));
}
public void CompileExpressions()
{
IList<ExpressionResult> results = ExpressionResult.LoadExpressionResults("Expressions.txt");
foreach (var result in results)
{
Parser parser = new Parser(result.Text);
var block = parser.CompileBlock();
Assert.IsNotNull(block);
result.ValidateBlock(block);
}
}
private void DoIt()
{
if (String.IsNullOrEmpty(txtInput.SelectedText))
return;
string text = txtInput.SelectedText;
Parser parser = new Parser(text);
try
{
Block block = parser.CompileBlock();
object result = block.Execute(this.machine, null);
if (result != null)
MessageBox.Show(result.ToString(), "Result");
}
catch (Exception ex)
{
MessageBox.Show(ex.StackTrace, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public object Evaluate(string command)
{
Machine current = Machine.Current;
object result = null;
try
{
this.machine.SetCurrent();
Parser parser = new Parser(command);
Block block = parser.CompileBlock();
if (block != null)
result = block.Execute(this.machine, null);
return result;
}
finally
{
Machine.SetCurrent(current);
}
}
public void CompileSubClassDefinition()
{
Parser compiler = new Parser("nil subclass: #Object");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(2, block.NoConstants);
Assert.AreEqual(0, block.NoGlobalNames);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(6, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
}
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 CompileSimpleSetExpression()
{
Parser parser = new Parser("a := 1");
var result = parser.CompileBlock();
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 CompileSimpleSendToSelf()
{
Parser compiler = new Parser("self invokeWith: 10");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(2, block.NoConstants);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(6, block.ByteCodes.Length);
Assert.AreEqual(ByteCode.GetSelf, (ByteCode)block.ByteCodes[0]);
Assert.AreEqual(0, block.Arity);
}
public void CompileSimpleAssingWithEqual()
{
Parser parser = new Parser("result := value = value");
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(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 CompileTwoCommandsUsingSemicolon()
{
Parser compiler = new Parser("nil invokeWith: 10; invokeWith: 20");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(3, block.NoConstants);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(12, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
}
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 CompileSimpleExpressionInParenthesisUsingYourself()
{
Parser compiler = new Parser("(1+2;yourself)");
Block block = compiler.CompileBlock();
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 CompileSimpleExpressionInParenthesis()
{
Parser compiler = new Parser("(1+2)");
Block block = compiler.CompileBlock();
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 CompileSimpleCommandWithParenthesisAndBangKeyword()
{
Parser compiler = new Parser("a := b with: (anObject !nativeMethod: 1)");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(3, block.NoGlobalNames);
Assert.AreEqual(3, block.NoConstants);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(14, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
}
public void CompileSimpleCommandWithParenthesis()
{
Parser compiler = new Parser("a := b with: (anObject class)");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(1, block.NoConstants);
Assert.AreEqual(3, block.NoGlobalNames);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(10, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
}
public void CompileSimpleCommand()
{
Parser compiler = new Parser("nil invokeWith: 10");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(2, block.NoConstants);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(6, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
}
public void CompileNumericPrimitiveWithError()
{
Parser parser = new Parser("<primitive: 60 error:ec>");
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.AreEqual("PrimitiveError 60 ec", ops[0]);
}
public void CompileSubClassDefinitionWithInstances()
{
Parser compiler = new Parser("nil subclass: #Object instanceVariables: 'a b c'");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(3, block.NoConstants);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(8, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
}
public void CompileSumWithNegativeNumber()
{
Parser parser = new Parser("-1 + 0");
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(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 CompileWhileTrue()
{
Parser compiler = new Parser(":arg | [arg < 3] whileTrue: [arg := arg + 1]");
Block block = compiler.CompileBlock();
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 CompileTwoCommands()
{
Parser compiler = new Parser("nil invokeWith: 10. Global := 20");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(3, block.NoConstants);
Assert.AreEqual(1, block.NoGlobalNames);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(10, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
}
public void ExecuteBasicInstSizeInRectangle()
{
Machine machine = new Machine();
IClass cls = CompileClass(
"Rectangle",
new string[] { "x", "y" },
new string[] { "x ^x", "x: newX x := newX", "y ^y", "y: newY y := newY" });
machine.SetGlobalObject("aRectangle", cls.NewObject());
Parser compiler = new Parser("^aRectangle basicInstSize");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
object result = block.Execute(machine, null);
Assert.AreEqual(2, result);
}
public void CompileTwoSimpleCommand()
{
Parser compiler = new Parser("a := 1. b := 2");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(2, block.NoConstants);
Assert.AreEqual(0, block.NoLocals);
Assert.AreEqual(2, block.NoGlobalNames);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(8, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
}
public void CompileSimpleArithmeticWithParenthesis()
{
Parser compiler = new Parser("1 * (2 + 3)");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(5, block.NoConstants);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(12, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
}
public void ExecuteBasicInstSize()
{
Machine machine = new Machine();
object nil = machine.UndefinedObjectClass;
Assert.IsNotNull(nil);
Assert.IsInstanceOfType(nil, typeof(IClass));
Parser compiler = new Parser("^UndefinedObject new basicInstSize");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
object result = block.Execute(machine, null);
Assert.AreEqual(0, result);
}
public void CompileSimpleOr()
{
Parser parser = new Parser("1 | 0");
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 0", ops[1]);
Assert.AreEqual("Send | 1", ops[2]);
}
public void ExecuteBasicInstVarAtPut()
{
Machine machine = new Machine();
IClass cls = CompileClass(
"Rectangle",
new string[] { "x", "y" },
new string[] { "x ^x", "x: newX x := newX", "y ^y", "y: newY y := newY" });
IObject iobj = (IObject)cls.NewObject();
machine.SetGlobalObject("aRectangle", iobj);
Parser compiler = new Parser("aRectangle basicInstVarAt: 1 put: 200");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
block.Execute(machine, null);
Assert.AreEqual(200, iobj[0]);
Assert.IsNull(iobj[1]);
}
public void CompileSimpleRealSum()
{
Parser compiler = new Parser("1.2 + 3.4");
Block block = compiler.CompileBlock();
Assert.IsNotNull(block);
Assert.AreEqual(3, block.NoConstants);
Assert.AreEqual(0, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.AreEqual(7, block.ByteCodes.Length);
Assert.AreEqual(0, block.Arity);
}
