| public CreateClass ( string clsname ) : IClass | ||
| clsname | string | |
| return | IClass | |
public void AvoidDuplicatedInstanceVariable()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass");
cls.DefineInstanceVariable("x");
cls.DefineInstanceVariable("x");
}
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 BeCreated()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass");
IBlock block = new Block();
Assert.IsNotNull(block);
}
public void AddInstanceVariable()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass");
cls.DefineInstanceVariable("x");
cls.DefineInstanceVariable("y");
Assert.AreEqual(0, cls.GetInstanceVariableOffset("x"));
Assert.AreEqual(1, cls.GetInstanceVariableOffset("y"));
}
public void BeCreated()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass");
IMethod mth = new Method(cls, "method1");
Assert.IsNotNull(mth);
Assert.AreEqual("method1", mth.Name);
Assert.AreEqual(cls, mth.Behavior);
Assert.AreEqual("TestClass", ((IClass)mth.Behavior).Name);
}
public void CreateClass()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass");
Assert.IsNotNull(cls);
Assert.AreEqual("TestClass", cls.Name);
Assert.AreEqual(-1, cls.GetInstanceVariableOffset("x"));
Assert.IsNull(cls.GetInstanceMethod("x"));
Assert.IsNotNull(cls.SuperClass);
Assert.IsInstanceOfType(cls.SuperClass, typeof(IClass));
Assert.AreEqual("UndefinedObject", ((IClass)cls.SuperClass).Name);
}
public void BeCreated()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("Rectangle");
Assert.IsNotNull(cls);
Assert.AreEqual("Rectangle", cls.Name);
Assert.IsNull(cls.GetInstanceMethod("x"));
Assert.IsNull(cls.GetClassMethod("x"));
Assert.IsNotNull(cls.SuperClass);
Assert.IsInstanceOfType(cls.SuperClass, typeof(IClass));
Assert.AreEqual("UndefinedObject", ((IClass)cls.SuperClass).Name);
}
public void Compile()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass");
cls.DefineClassVariable("count");
cls.DefineInstanceVariable("x");
Method mth;
mth = new Method(cls, "x:");
mth.CompileArgument("newX");
mth.CompileGet("newX");
mth.CompileSet("x");
cls.DefineInstanceMethod(mth);
Assert.AreEqual(mth, cls.GetInstanceMethod("x:"));
Assert.AreEqual("x", mth.GetInstanceVariableName(0));
}
public void CompileAndRun()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass");
cls.DefineInstanceVariable("x");
Method mth;
mth = new Method(cls, "x:");
mth.CompileArgument("newX");
mth.CompileGet("newX");
mth.CompileSet("x");
cls.DefineInstanceMethod(mth);
IObject obj = (IObject)cls.NewObject();
mth.Execute(machine, obj, new object[] { 10 });
Assert.AreEqual(10, obj[0]);
}
public void CreateClassWithInstanceAndClassVariables()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass", null, "x", "Count");
Assert.IsNotNull(cls);
Assert.AreEqual("TestClass", cls.Name);
Assert.AreEqual(0, cls.GetInstanceVariableOffset("x"));
Assert.AreEqual(-1, cls.GetInstanceVariableOffset("y"));
Assert.AreEqual(0, cls.GetClassVariableOffset("Count"));
Assert.AreEqual(-1, cls.GetClassVariableOffset("y"));
Assert.AreEqual("x", cls.GetInstanceVariableNamesAsString());
Assert.AreEqual("Count", cls.GetClassVariableNamesAsString());
Assert.AreEqual(0, cls.NoVariables);
Assert.AreEqual(1, cls.NoClassVariables);
Assert.IsNull(cls.GetInstanceMethod("x"));
Assert.IsNotNull(cls.SuperClass);
Assert.IsInstanceOfType(cls.SuperClass, typeof(IClass));
Assert.AreEqual("UndefinedObject", ((IClass)cls.SuperClass).Name);
}
public void CompileMethodWithLocals()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("Rectangle");
cls.DefineInstanceVariable("x");
Parser compiler = new Parser("x | temp | temp := x. ^temp");
var method = compiler.CompileInstanceMethod(cls);
Assert.IsNotNull(method);
Assert.AreEqual("x", method.Name);
Assert.IsNotNull(method.ByteCodes);
}
public void CompileMethodWithHorizontalBarAsName()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("Rectangle");
Parser compiler = new Parser("| aBoolean ^aBoolean");
var method = compiler.CompileInstanceMethod(cls);
Assert.IsNotNull(method);
Assert.AreEqual("|", method.Name);
Assert.IsNotNull(method.ByteCodes);
}
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)
{
Parser compiler = new Parser(method);
cls.DefineInstanceMethod(compiler.CompileInstanceMethod(cls));
}
}
if (clsmethods != null)
{
foreach (string method in clsmethods)
{
Parser compiler = new Parser(method);
cls.DefineClassMethod(compiler.CompileClassMethod(cls));
}
}
return cls;
}
public void DefineClassVariables()
{
Machine machine = new Machine();
IClass bclass = machine.CreateClass("MyClass");
bclass.DefineClassVariable("Count");
bclass.DefineClassVariable("Items");
Assert.AreEqual(0, bclass.Behavior.NoInstanceVariables);
Assert.AreEqual(0, bclass.NoVariables);
Assert.AreEqual(2, bclass.NoClassVariables);
Assert.AreEqual(0, bclass.GetClassVariableOffset("Count"));
Assert.AreEqual(1, bclass.GetClassVariableOffset("Items"));
Assert.AreEqual(-1, bclass.GetClassVariableOffset("Z"));
Assert.AreEqual(0, ((IClassDescription)bclass.Behavior).GetClassVariableOffset("Count"));
Assert.AreEqual(1, ((IClassDescription)bclass.Behavior).GetClassVariableOffset("Items"));
Assert.AreEqual(-1, ((IClassDescription)bclass.Behavior).GetClassVariableOffset("Z"));
Assert.AreEqual("Count Items", bclass.GetClassVariableNamesAsString());
Assert.AreEqual("Count Items", ((IClassDescription)bclass.Behavior).GetClassVariableNamesAsString());
Assert.AreEqual(string.Empty, bclass.GetInstanceVariableNamesAsString());
Assert.AreEqual(null, bclass.GetInstanceVariableNames());
var result = bclass.GetClassVariableNames();
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual("Count", result.ElementAt(0));
Assert.AreEqual("Items", result.ElementAt(1));
result = ((IClassDescription)bclass.Behavior).GetClassVariableNames();
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual("Count", result.ElementAt(0));
Assert.AreEqual("Items", result.ElementAt(1));
}
public void CreateObject()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass");
cls.DefineInstanceVariable("x");
cls.DefineInstanceVariable("y");
IObject obj = (IObject)cls.NewObject();
Assert.IsNotNull(obj);
Assert.IsNull(obj[0]);
Assert.IsNull(obj[1]);
}
public void CompileClassMethod()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("Rectangle");
cls.DefineClassVariable("x");
var method = this.compiler.CompileClassMethod("x ^x", cls);
Assert.IsNotNull(method);
Assert.IsNotNull(method.ByteCodes);
Assert.AreEqual("x ^x", method.SourceCode);
}
public void CompileInstanceVariableInBlockInsideAMethod()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("Rectangle");
cls.DefineInstanceVariable("x");
var method = this.compiler.CompileInstanceMethod("x ^[x] value", cls);
Assert.IsNotNull(method);
Assert.IsNotNull(method.ByteCodes);
Assert.AreEqual("x ^[x] value", method.SourceCode);
Assert.IsTrue(method.NoConstants > 0);
Assert.IsInstanceOfType(method.GetConstant(0), typeof(Block));
var block = (Block)method.GetConstant(0);
var result = (new BlockDecompiler(block)).Decompile();
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
Assert.AreEqual("GetInstanceVariable x", result[0]);
}
public void AvoidNullName()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass(null);
}
public void InheritsVariables()
{
Machine machine = new Machine();
IClass supercls = machine.CreateClass("Figure");
supercls.DefineInstanceVariable("x");
supercls.DefineInstanceVariable("y");
IClass cls = machine.CreateClass("Rectangle", supercls);
Assert.AreEqual(supercls, cls.SuperClass);
cls.DefineInstanceVariable("width");
cls.DefineInstanceVariable("height");
Assert.IsNotNull(cls);
Assert.AreEqual("Rectangle", cls.Name);
Assert.AreEqual(0, supercls.GetInstanceVariableOffset("x"));
Assert.AreEqual(1, supercls.GetInstanceVariableOffset("y"));
Assert.AreEqual(0, cls.GetInstanceVariableOffset("x"));
Assert.AreEqual(1, cls.GetInstanceVariableOffset("y"));
Assert.AreEqual(2, cls.GetInstanceVariableOffset("width"));
Assert.AreEqual(3, cls.GetInstanceVariableOffset("height"));
}
public void CompileSetMethod()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("Rectangle");
cls.DefineInstanceVariable("x");
Parser compiler = new Parser("x: newX x := newX");
var method = compiler.CompileInstanceMethod(cls);
Assert.IsNotNull(method);
Assert.AreEqual("x:", method.Name);
Assert.IsNotNull(method.ByteCodes);
}
internal 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)
cls.DefineInstanceMethod(this.compiler.CompileInstanceMethod(method, cls));
if (clsmethods != null)
foreach (string method in clsmethods)
cls.DefineClassMethod(this.compiler.CompileClassMethod(method, cls));
return cls;
}
public void CompileSetMethod()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("Rectangle");
cls.DefineInstanceVariable("x");
var method = this.compiler.CompileInstanceMethod("x: newX x := newX", cls);
Assert.IsNotNull(method);
Assert.IsNotNull(method.ByteCodes);
}
public void CompileInstanceMethod()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("Rectangle");
cls.DefineInstanceVariable("x");
var method = this.compiler.CompileInstanceMethod("x ^x", cls);
Assert.IsNotNull(method);
Assert.IsNotNull(method.ByteCodes);
Assert.AreEqual("x ^x", method.SourceCode);
var result = (new BlockDecompiler(method)).Decompile();
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual("GetInstanceVariable x", result[0]);
Assert.AreEqual("ReturnPop", result[1]);
}
static void Main(string[] args)
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("Point");
cls.DefineInstanceVariable("x");
cls.DefineInstanceVariable("y");
IObject obj = (IObject) cls.NewObject();
Console.WriteLine(obj[0]);
Console.WriteLine(obj[1]);
obj[0]=0;
obj[1]=1;
Console.WriteLine(obj[0]);
Console.WriteLine(obj[1]);
Console.ReadLine();
Method mth = new Method(cls,"set:");
mth.CompileArgument("newValue");
mth.CompileGet("newValue");
mth.CompileSet("x");
mth.CompileGet("newValue");
mth.CompileSet("y");
mth.Execute(obj.Behavior,obj,new object[] {10});
cls.DefineInstanceMethod(mth);
Console.WriteLine(obj[0]);
Console.WriteLine(obj[1]);
Console.ReadLine();
mth = new Method(cls,"x:y:");
mth.CompileArgument("newX");
mth.CompileArgument("newY");
mth.CompileGet("newX");
mth.CompileSet("x");
mth.CompileGet("newY");
mth.CompileSet("y");
mth.Execute(obj.Behavior,obj,new object[] {10,20});
cls.DefineInstanceMethod(mth);
Console.WriteLine(obj[0]);
Console.WriteLine(obj[1]);
Console.ReadLine();
mth = new Method(cls,"x:");
mth.CompileArgument("newX");
mth.CompileGet("newX");
mth.CompileSet("x");
mth.Execute(obj.Behavior,obj,new object[] {10,20});
cls.DefineInstanceMethod(mth);
mth = new Method(cls,"y:");
mth.CompileArgument("newY");
mth.CompileGet("newY");
mth.CompileSet("y");
mth.Execute(obj.Behavior,obj,new object[] {10,20});
cls.DefineInstanceMethod(mth);
Parser compiler = new Parser("set2: newValue self x: newValue self y: newValue.");
compiler.CompileInstanceMethod(cls);
compiler = new Parser("x ^x.");
compiler.CompileInstanceMethod(cls);
compiler = new Parser("y ^y.");
compiler.CompileInstanceMethod(cls);
compiler = new Parser("x1 ^x+1.");
compiler.CompileInstanceMethod(cls);
compiler = new Parser("y1 ^y+1.");
compiler.CompileInstanceMethod(cls);
obj.SendMessage("set2:", new object[] { 10 });
Console.WriteLine(obj[0]);
Console.WriteLine(obj[1]);
Console.ReadLine();
obj.SendMessage("x:", new object[] { 30 });
Console.WriteLine(obj[0]);
Console.WriteLine(obj[1]);
Console.ReadLine();
obj.SendMessage("y:", new object[] { 20 });
Console.WriteLine(obj[0]);
Console.WriteLine(obj[1]);
Console.ReadLine();
Console.WriteLine(obj.SendMessage("x", null));
Console.WriteLine(obj.SendMessage("y", null));
Console.ReadLine();
}
public void CompileMethodWithLocals()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("Rectangle");
cls.DefineInstanceVariable("x");
var method = this.compiler.CompileInstanceMethod("x | temp | temp := x. ^temp", cls);
Assert.IsNotNull(method);
Assert.IsNotNull(method.ByteCodes);
}
public void CompileWithLocals()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass");
cls.DefineInstanceVariable("x");
Block block;
block = new Block();
block.CompileArgument("newX");
block.CompileLocal("l");
block.CompileGet("newX");
block.CompileSet("l");
Assert.AreEqual(1, block.NoLocals);
Assert.IsNotNull(block.ByteCodes);
Assert.IsTrue(block.ByteCodes.Length > 0);
}
protected override object DoesNotUnderstand(Machine machine, IObject self, string msgname, object[] args)
{
if (self != null && !(self is IBehavior))
return base.DoesNotUnderstand(machine, self, msgname, args);
if (msgname.Equals("new"))
return ((IBehavior)self).NewObject();
if (msgname.StartsWith("commentStamp:"))
return new ChunkReaderProcessor((Machine mach, ICompiler compiler, string text) => { }, 1);
if (msgname == "methods" || msgname.StartsWith("methodsFor:"))
{
IBehavior behavior = (IBehavior)self;
return new ChunkReaderProcessor((Machine mach, ICompiler compiler, string text) =>
{
var method = compiler.CompileInstanceMethod(text, behavior);
if (reservedMethods.Contains(method.Name))
return;
if (reservedRedefinedMethods.Contains(method.Name) && behavior.GetInstanceMethod(method.Name) != null)
return;
behavior.DefineInstanceMethod(compiler.CompileInstanceMethod(text, behavior));
});
}
if (msgname.StartsWith("new:") && self is NativeBehavior)
return ((NativeBehavior)self).CreateObject(args);
if (msgname.Equals("subclass:") || msgname.Equals("agent:"))
{
IClass newclass = machine.CreateClass((string)args[0], (IClass)self);
machine.SetCurrentEnvironmentObject(newclass.Name, newclass);
if (msgname.Equals("agent:"))
((BaseClass)newclass).IsAgentClass = true;
return newclass;
}
if (msgname.Equals("subclass:instanceVariableNames:") ||
msgname.Equals("subclass:instanceVariableNames:classVariableNames:poolDictionaries:category:") ||
msgname.Equals("variableSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:") ||
// TODO weakSubclass because Pharo Kernel Objects defines one, WeakMessageSend
msgname.Equals("weakSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:") ||
// TODO variableWordSubclass because Pharo Kernel Number use it
msgname.Equals("variableWordSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:") ||
// TODO variableByteSubclass because Pharo Kernel Number use it
msgname.Equals("variableByteSubclass:instanceVariableNames:classVariableNames:poolDictionaries:category:") ||
msgname.Equals("agent:instanceVariableNames:") ||
msgname.Equals("agent:instanceVariableNames:classVariableNames:poolDictionaries:category:"))
{
string clsname = (string)args[0];
string instancevarnames = (string)args[1];
string classvarnames = args.Length > 2 ? (string)args[2] : string.Empty;
IClass newclass = machine.CreateClass((string)args[0], (IClass)self, instancevarnames, classvarnames);
if (msgname.StartsWith("agent:"))
((BaseClass)newclass).IsAgentClass = true;
if (msgname.StartsWith("variableSubclass:") || msgname.StartsWith("variableWordSubclass:"))
((BaseClass)newclass).IsIndexed = true;
if (args.Length >= 5)
((BaseClass)newclass).Category = (string)args[4];
machine.SetCurrentEnvironmentObject(newclass.Name, newclass);
return newclass;
}
if (msgname.Equals("subclass:nativeType:"))
{
Type type = (Type)args[1];
NativeBehavior newbehavior = machine.GetNativeBehavior(type);
if (newbehavior == null)
{
newbehavior = (NativeBehavior)machine.CreateNativeBehavior((IClassDescription)self, type);
machine.RegisterNativeBehavior(newbehavior.NativeType, newbehavior);
}
else if (newbehavior.SuperClass != self)
newbehavior.SetSuperClass((IBehavior)self);
machine.SetCurrentEnvironmentObject((string)args[0], newbehavior);
return newbehavior;
}
if (msgname.Equals("instanceVariableNames:"))
{
string names = (string)args[0];
if (!string.IsNullOrEmpty(names))
throw new NotSupportedException();
return self;
}
return base.DoesNotUnderstand(machine, self, msgname, args);
}
public void GetInstanceVariableOffsetWithOuter()
{
Machine machine = new Machine();
IClass cls = machine.CreateClass("TestClass");
cls.DefineInstanceVariable("x");
Method method = new Method(cls, "mymethod");
Block block = new Block("x", method);
Assert.AreEqual(0, block.GetInstanceVariableOffset("x"));
}