public void CompileBlockWithParameter()
{
ModelParser parser = new ModelParser("[ :a | a doSomething ]");
this.compiler.CompileExpression(parser.ParseExpression());
Assert.IsNotNull(this.block);
Assert.AreEqual(0, this.block.NoGlobalNames);
Assert.AreEqual(0, this.block.NoLocals);
Assert.AreEqual(1, this.block.NoConstants);
Assert.IsNotNull(this.block.ByteCodes);
Assert.AreEqual(2, this.block.ByteCodes.Length);
Assert.AreEqual(0, this.block.Arity);
object constant = this.block.GetConstant(0);
Assert.IsNotNull(constant);
Assert.IsInstanceOfType(constant, typeof(Block));
var newblock = (Block)constant;
Assert.AreEqual(0, newblock.NoGlobalNames);
Assert.AreEqual(0, newblock.NoLocals);
Assert.AreEqual(1, newblock.NoConstants);
Assert.IsNotNull(newblock.ByteCodes);
Assert.AreEqual(5, newblock.ByteCodes.Length);
Assert.AreEqual(1, newblock.Arity);
}
public void Process(CodeModel model)
{
for (string chunk = this.reader.GetChunk(); chunk != null; chunk = this.reader.GetChunk())
{
bool isreader = false;
if (chunk.StartsWith("!"))
{
chunk = chunk.Substring(1);
isreader = true;
}
ModelParser parser = new ModelParser(chunk);
IExpression expression = parser.ParseExpression();
if (isreader)
{
if (expression is MessageExpression && ((MessageExpression)expression).Selector.Contains("methodsFor:"))
this.ProcessMethods(model, (MessageExpression)expression);
else if (expression is MessageExpression && ((MessageExpression)expression).Selector.Contains("commentStamp:"))
this.ProcessComment(model, (MessageExpression)expression);
else
this.ProcessReader();
}
else
{
if (expression is MessageExpression)
this.ProcessMessageExpression(model, (MessageExpression)expression);
}
}
}
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 CompileBlockWithDot()
{
Lexer lexer = new Lexer("[. 1. 2]");
ModelParser parser = new ModelParser(lexer);
var result = parser.ParseBlock();
Assert.IsNotNull(result);
}
public void CompileAndExecuteTwoSimpleCommand()
{
ModelParser parser = new ModelParser("a := 1. b := 2");
this.compiler.CompileExpressions(parser.ParseExpressions());
Machine machine = new Machine();
this.block.Execute(machine, null);
Assert.AreEqual(1, machine.GetGlobalObject("a"));
Assert.AreEqual(2, machine.GetGlobalObject("b"));
}
public Block CompileBlock(string text)
{
ModelParser parser = new ModelParser(text);
var expr = parser.ParseBlock();
Block block = new Block(text);
BytecodeCompiler compiler = new BytecodeCompiler(block);
compiler.CompileExpression(expr);
return block;
}
public Method CompileInstanceMethod(string text, IBehavior cls)
{
ModelParser parser = new ModelParser(text);
var methodmodel = parser.ParseMethod();
Method method = new Method(cls, methodmodel.Selector, text);
BytecodeCompiler compiler = new BytecodeCompiler(method);
compiler.CompileMethod(methodmodel);
return method;
}
public void CompileExpressions()
{
IList<ExpressionResult> results = ExpressionResult.LoadExpressionResults("Expressions.txt");
foreach (var result in results)
{
ModelParser parser = new ModelParser(result.Text);
Block block = new Block();
BytecodeCompiler compiler = new BytecodeCompiler(block);
compiler.CompileExpression(parser.ParseExpression());
result.ValidateBlock(block);
}
}
public void ParseArrayOfArrays()
{
ModelParser parser = new ModelParser("#((1 2 3) (1 2 3) (1 2 3))");
IExpression expression = parser.ParseExpression();
Assert.IsNotNull(expression);
Assert.IsInstanceOfType(expression, typeof(ArrayExpression));
ArrayExpression cexpression = (ArrayExpression)expression;
Assert.AreEqual(3, cexpression.Expressions.Count());
foreach (IExpression item in cexpression.Expressions)
Assert.IsInstanceOfType(item, typeof(ArrayExpression));
Assert.AreEqual("#((1 2 3) (1 2 3) (1 2 3))", expression.AsString());
}
public void ParseBlockWithLocalVariables()
{
ModelParser parser = new ModelParser("[ | x y | ^a + b]");
IExpression expression = parser.ParseExpression();
Assert.IsNotNull(expression);
Assert.IsInstanceOfType(expression, typeof(BlockExpression));
BlockExpression bexpression = (BlockExpression)expression;
Assert.IsNotNull(bexpression.Body);
Assert.IsInstanceOfType(bexpression.Body.First(), typeof(ReturnExpression));
Assert.AreEqual(0, bexpression.ParameterNames.Count);
Assert.AreEqual(2, bexpression.LocalVariables.Count);
Assert.AreEqual("x", bexpression.LocalVariables[0]);
Assert.AreEqual("y", bexpression.LocalVariables[1]);
Assert.AreEqual("[ | x y | ^a + b]", expression.AsString());
}
public void ParseAddMessage()
{
ModelParser parser = new ModelParser("10 + 20");
IExpression expression = parser.ParseExpression();
Assert.IsNotNull(expression);
Assert.IsInstanceOfType(expression, typeof(MessageExpression));
MessageExpression mexpression = (MessageExpression)expression;
Assert.IsInstanceOfType(mexpression.Target, typeof(ConstantExpression));
ConstantExpression cleftexpression = (ConstantExpression)mexpression.Target;
Assert.AreEqual(10, cleftexpression.Value);
Assert.AreEqual("+", mexpression.Selector);
Assert.AreEqual(1, mexpression.Arguments.Count());
Assert.IsInstanceOfType(mexpression.Arguments.First(), typeof(ConstantExpression));
ConstantExpression crightexpression = (ConstantExpression)mexpression.Arguments.First();
Assert.AreEqual(20, crightexpression.Value);
Assert.AreEqual("10 + 20", expression.AsString());
}
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);
ModelParser parser = new ModelParser("aRectangle basicInstVarAt: 1 put: 200");
this.compiler.CompileExpression(parser.ParseExpression());
this.block.Execute(machine, null);
Assert.AreEqual(200, iobj[0]);
Assert.IsNull(iobj[1]);
}
public void ExecuteBlock()
{
Machine machine = new Machine();
object nil = machine.UndefinedObjectClass;
Assert.IsNotNull(nil);
Assert.IsInstanceOfType(nil, typeof(IClass));
ModelParser parser = new ModelParser("nil ifNil: [GlobalName := 'foo']");
this.compiler.CompileExpression(parser.ParseExpression());
this.block.Execute(machine, null);
Assert.IsNotNull(machine.GetGlobalObject("GlobalName"));
}
public void ExecuteBasicInstSize()
{
Machine machine = new Machine();
object nil = machine.UndefinedObjectClass;
Assert.IsNotNull(nil);
Assert.IsInstanceOfType(nil, typeof(IClass));
ModelParser parser = new ModelParser("^UndefinedObject new basicInstSize");
this.compiler.CompileExpression(parser.ParseExpression());
object result = this.block.Execute(machine, null);
Assert.AreEqual(0, result);
}
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());
ModelParser parser = new ModelParser("^aRectangle basicInstSize");
this.compiler.CompileExpression(parser.ParseExpression());
object result = this.block.Execute(machine, null);
Assert.AreEqual(2, result);
}
public void CompileTwoCommandsUsingSemicolon()
{
ModelParser parser = new ModelParser("nil invokeWith: 10; invokeWith: 20");
this.compiler.CompileExpressions(parser.ParseExpressions());
Assert.IsNotNull(this.block);
Assert.AreEqual(3, 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);
}
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 CompileSubClassDefinitionWithInstances()
{
ModelParser parser = new ModelParser("nil subclass: #Object instanceVariables: 'a b c'");
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(8, this.block.ByteCodes.Length);
Assert.AreEqual(0, this.block.Arity);
}
public void CompileTwoCommands()
{
ModelParser parser = new ModelParser("nil invokeWith: 10. Global := 20");
this.compiler.CompileExpressions(parser.ParseExpressions());
Assert.IsNotNull(this.block);
Assert.AreEqual(3, this.block.NoConstants);
Assert.AreEqual(1, this.block.NoGlobalNames);
Assert.AreEqual(0, this.block.NoLocals);
Assert.IsNotNull(this.block.ByteCodes);
Assert.AreEqual(10, this.block.ByteCodes.Length);
Assert.AreEqual(0, this.block.Arity);
}
public void CompileSubClassDefinition()
{
ModelParser parser = new ModelParser("nil subclass: #Object");
IExpression expr = parser.ParseExpression();
this.compiler.CompileExpression(expr);
Assert.IsNotNull(this.block);
Assert.AreEqual(2, this.block.NoConstants);
Assert.AreEqual(0, this.block.NoGlobalNames);
Assert.AreEqual(0, this.block.NoLocals);
Assert.IsNotNull(this.block.ByteCodes);
Assert.AreEqual(6, this.block.ByteCodes.Length);
Assert.AreEqual(0, this.block.Arity);
}
private static MethodModel ParseMethod(string text)
{
ModelParser parser = new ModelParser(text);
ClassModel classModel = new ClassModel("MyClass", (ClassModel)null, null, null, false, null, null);
return parser.ParseMethod(classModel, false);
}
public void CompileGlobalVariable()
{
ModelParser parser = new ModelParser("AClass");
IExpression expr = parser.ParseExpression();
this.compiler.CompileExpression(expr);
Assert.IsNotNull(this.block);
Assert.AreEqual(1, this.block.NoGlobalNames);
Assert.AreEqual(0, this.block.NoLocals);
Assert.IsNotNull(this.block.ByteCodes);
Assert.AreEqual(2, this.block.ByteCodes.Length);
Assert.AreEqual(0, this.block.Arity);
}
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 ExecuteTrueIfTrueIfFalse()
{
Machine machine = new Machine();
ModelParser parser = new ModelParser("true ifTrue: [GlobalName := 'bar'] ifFalse: [GlobalName := 'foo']");
this.compiler.CompileExpression(parser.ParseExpression());
this.block.Execute(machine, null);
Assert.AreEqual("bar", machine.GetGlobalObject("GlobalName"));
}
public void CompileSimpleCommand()
{
ModelParser parser = new ModelParser("nil invokeWith: 10");
IExpression expr = parser.ParseExpression();
this.compiler.CompileExpression(expr);
Assert.IsNotNull(this.block);
Assert.AreEqual(2, this.block.NoConstants);
Assert.AreEqual(0, this.block.NoLocals);
Assert.IsNotNull(this.block.ByteCodes);
Assert.AreEqual(6, this.block.ByteCodes.Length);
Assert.AreEqual(0, this.block.Arity);
}
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]);
}
internal static IClass CompileClass(string clsname, string[] varnames, string[] methods, string[] clsmethods)
{
Machine machine = new Machine();
IClass cls = machine.CreateClass(clsname);
if (varnames != null)
{
foreach (string varname in varnames)
{
cls.DefineInstanceVariable(varname);
}
}
if (methods != null)
{
foreach (string method in methods)
{
ModelParser parser = new ModelParser(method);
MethodModel model = parser.ParseMethod();
Method newmethod = new Method(cls, model.Selector, method);
BytecodeCompiler compiler = new BytecodeCompiler(newmethod);
compiler.CompileMethod(model);
cls.DefineInstanceMethod(newmethod);
}
}
if (clsmethods != null)
{
foreach (string method in clsmethods)
{
ModelParser parser = new ModelParser(method);
MethodModel model = parser.ParseMethod();
Method newmethod = new Method(cls, model.Selector, method);
BytecodeCompiler compiler = new BytecodeCompiler(newmethod);
compiler.CompileMethod(model);
cls.DefineClassMethod(newmethod);
}
}
return cls;
}
public void CompileSimpleCommandWithParenthesisAndBangKeyword()
{
ModelParser parser = new ModelParser("a := b with: (anObject !nativeMethod: 1)");
IExpression expr = parser.ParseExpression();
this.compiler.CompileExpression(expr);
Assert.IsNotNull(this.block);
Assert.AreEqual(3, this.block.NoGlobalNames);
Assert.AreEqual(3, this.block.NoConstants);
Assert.AreEqual(0, this.block.NoLocals);
Assert.IsNotNull(this.block.ByteCodes);
Assert.AreEqual(14, this.block.ByteCodes.Length);
Assert.AreEqual(0, this.block.Arity);
}
private static IExpression ParseExpression(string text)
{
ModelParser parser = new ModelParser(text);
return parser.ParseExpression();
}
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]);
}