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;
}
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;
}
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 CompileSimpleClassWithSimpleSetMethod()
{
ClassModel @class = new ClassModel("AClass", (ClassModel)null, new List<string>() { "x", "y" }, new List<string>(), false, null, null);
ModelParser parser = new ModelParser("x: newX x := newX");
MethodModel method = parser.ParseMethod(@class, false);
@class.InstanceMethods.Add(method);
this.compiler.CompileClass(@class);
this.writer.Close();
string output = this.writer.ToString();
Assert.IsTrue(ContainsLine(output, "function AClass()"));
Assert.IsTrue(ContainsLine(output, "{"));
Assert.IsTrue(ContainsLine(output, "}"));
Assert.IsTrue(ContainsLine(output, "AClass.prototype.$x = null;"));
Assert.IsTrue(ContainsLine(output, "AClass.prototype.$y = null;"));
Assert.IsTrue(ContainsLine(output, "AClass.prototype['x_'] = function(newX)"));
Assert.IsTrue(ContainsLine(output, "{"));
Assert.IsTrue(ContainsLine(output, "var self = this;"));
Assert.IsTrue(ContainsLine(output, "self.$x = newX;"));
Assert.IsTrue(ContainsLine(output, "};"));
}
private void ProcessMethods(CodeModel model, MessageExpression expression)
{
string className = expression.Target.AsString();
ClassModel @class = model.GetClass(className);
for (string chunk = this.reader.GetChunk(); chunk != null; chunk = this.reader.GetChunk())
{
if (string.IsNullOrEmpty(chunk.Trim()))
break;
ModelParser parser = new ModelParser(chunk);
MethodModel method = parser.ParseMethod(@class, false);
model.AddElement(method);
}
}
public void ParseSimpleReturnMethod()
{
ModelParser parser = new ModelParser("x ^x");
MethodModel method = parser.ParseMethod();
Assert.IsNotNull(method);
Assert.AreEqual("x", method.Selector);
Assert.AreEqual(0, method.ParameterNames.Count);
Assert.AreEqual(0, method.LocalVariables.Count);
}
public void ParseSimpleMethod()
{
ModelParser parser = new ModelParser("width: aWidth height: aHeight width do. heigth do");
MethodModel method = parser.ParseMethod();
Assert.IsNotNull(method);
Assert.AreEqual("width:height:", method.Selector);
Assert.AreEqual(2, method.ParameterNames.Count);
Assert.AreEqual("aWidth", method.ParameterNames[0]);
Assert.AreEqual("aHeight", method.ParameterNames[1]);
Assert.AreEqual(0, method.LocalVariables.Count);
}
public void ParseMethodWithLocalVariables()
{
ModelParser parser = new ModelParser("doSomething | a b c | ^10");
MethodModel method = parser.ParseMethod();
Assert.IsNotNull(method);
Assert.AreEqual("doSomething", method.Selector);
Assert.AreEqual(0, method.ParameterNames.Count);
Assert.AreEqual(3, method.LocalVariables.Count);
Assert.AreEqual("a", method.LocalVariables[0]);
Assert.AreEqual("b", method.LocalVariables[1]);
Assert.AreEqual("c", method.LocalVariables[2]);
Assert.IsInstanceOfType(method.Body.First(), typeof(ReturnExpression));
}
public void ParseMethodWithBinaryOperator()
{
ModelParser parser = new ModelParser("+ aNumber aNumber do. ^aNumber");
MethodModel method = parser.ParseMethod();
Assert.IsNotNull(method);
Assert.AreEqual("+", method.Selector);
Assert.AreEqual(1, method.ParameterNames.Count);
Assert.AreEqual("aNumber", method.ParameterNames[0]);
Assert.AreEqual(0, method.LocalVariables.Count);
Assert.IsNotNull(method.Body);
Assert.AreEqual(2, method.Body.Count());
}
public void ParseInstanceMethodReturningInstanceVariable()
{
ClassModel @class = new ClassModel("AClass", (ClassModel)null, new List<string>() { "x", "y" }, new List<string>(), false, null, null);
ModelParser parser = new ModelParser("x ^x");
MethodModel method = parser.ParseMethod(@class, false);
Assert.IsNotNull(method);
Assert.AreEqual("x", method.Selector);
Assert.AreEqual(0, method.ParameterNames.Count);
Assert.AreEqual(0, method.LocalVariables.Count);
Assert.IsInstanceOfType(method.Body.First(), typeof(ReturnExpression));
ReturnExpression rexpression = (ReturnExpression)method.Body.First();
Assert.IsInstanceOfType(rexpression.Expression, typeof(InstanceVariableExpression));
}
