public void GetEmptyNamesFromNull() { ClassModel @class = new ClassModel("AClass", string.Empty, null, null, false, null, null); Assert.AreEqual(string.Empty, @class.ClassVariableNamesAsString); Assert.AreEqual(string.Empty, @class.InstanceVariableNamesAsString); }
public override void Visit(ClassModel @class) { // TODO review if (@class.SuperClassName == null) return; string instanceVariableNames = string.Empty; string classVariableNames = string.Empty; if (@class.InstanceVariableNames != null && @class.InstanceVariableNames.Count > 0) { instanceVariableNames = @class.InstanceVariableNames.First(); foreach (var name in @class.InstanceVariableNames.Skip(1)) instanceVariableNames += " " + name; } if (@class.ClassVariableNames != null && @class.ClassVariableNames.Count > 0) { classVariableNames = @class.ClassVariableNames.First(); foreach (var name in @class.ClassVariableNames.Skip(1)) classVariableNames += " " + name; } this.WriteLine(string.Format( "Smalltalk.{0}.subclass_instanceVariableNames_classVariableNames_('{1}', '{2}', '{3}');", @class.SuperClassName, @class.Name, instanceVariableNames, classVariableNames)); foreach (MethodModel method in @class.InstanceMethods) method.Visit(this); }
public MethodModel(string selector, IList<string> parameterNames, IList<string> localVariables, IEnumerable<IExpression> body, ClassModel @class, bool isClassMethod) { this.selector = selector; this.parameterNames = parameterNames; this.localVariables = localVariables; this.body = body; this.@class = @class; this.isClassMethod = isClassMethod; }
public void GetNames() { ClassModel @class = new ClassModel("AClass", string.Empty, new List<string>() { "x", "y" }, new List<string>() { "count" }, false, null, null); Assert.AreEqual("count", @class.ClassVariableNamesAsString); Assert.AreEqual("x y", @class.InstanceVariableNamesAsString); Assert.AreEqual(string.Empty, @class.Category); Assert.AreEqual(string.Empty, @class.PoolDictionariesAsString); }
public ClassModel(string name, IList<string> instanceVariableNames, IList<string> classVariableNames, bool isvariable, IList<string> poolDictionaries, string category) { this.name = name; this.instanceVariableNames = instanceVariableNames ?? new List<string>(); this.classVariableNames = classVariableNames ?? new List<string>(); this.classMethods = new List<MethodModel>(); this.instanceMethods = new List<MethodModel>(); if (!name.EndsWith(" class")) this.metaclass = new ClassModel(name + " class", this.superclassname == null ? null : this.superclassname + " class", null, null, isvariable, null, null); this.isvariable = isvariable; this.poolDictionaries = poolDictionaries ?? new List<string>(); this.category = category ?? string.Empty; }
public override void Visit(ClassModel @class) { string selector = @class.IsVariable ? "variableSubclass:" : "subclass:"; selector += "instanceVariableNames:classVariableNames:poolDictionaries:category:"; this.block.CompileGet(@class.SuperClassName); this.block.CompileConstant(@class.Name); this.block.CompileGetConstant(@class.InstanceVariableNamesAsString); this.block.CompileGetConstant(@class.ClassVariableNamesAsString); this.block.CompileGetConstant(@class.PoolDictionariesAsString); this.block.CompileGetConstant(@class.Category); this.block.CompileSend(selector); }
public override void Visit(ClassModel @class) { this.writer.WriteLine(string.Format("function {0}Class()", @class.Name)); this.writer.WriteLineStart("{"); this.writer.WriteLineEnd("}"); this.writer.WriteLine(string.Format("function {0}()", @class.Name)); this.writer.WriteLineStart("{"); this.writer.WriteLineEnd("}"); this.writer.WriteLine(string.Format("{0}.prototype.__class = {0}Class.prototype;", @class.Name)); this.writer.WriteLine(string.Format("{0}.classPrototype = {0}Class.prototype;", @class.Name)); this.writer.WriteLine(string.Format("{0}Class.prototype['_basicNew'] = function() {{ return new {0}(); }};", @class.Name)); if (@class.SuperClassName != null && @class.SuperClassName != @class.Name) { this.writer.WriteLine(string.Format("{0}Class.prototype.__proto__ = {1}Class.prototype;", @class.Name, @class.SuperClassName)); this.writer.WriteLine(string.Format("{0}.prototype.__proto__ = {1}.prototype;", @class.Name, @class.SuperClassName)); } foreach (string name in @class.InstanceVariableNames) this.writer.WriteLine(string.Format("{0}.prototype.${1} = null;", @class.Name, name)); if (@class.SuperClassName != null && @class.SuperClassName != @class.Name) { this.writer.WriteLine(string.Format("{0}Class.__super = {1}Class;", @class.Name, @class.SuperClassName)); this.writer.WriteLine(string.Format("{0}.__super = {1};", @class.Name, @class.SuperClassName)); } // TODO Review class variables. Where? at Class? at Class.prototype? foreach (string name in @class.ClassVariableNames) this.writer.WriteLine(string.Format("{0}Class.${1} = null;", @class.Name, name)); foreach (MethodModel method in @class.InstanceMethods) method.Visit(this); }
public ClassModel(string name, ClassModel superclass, IList<string> instanceVariableNames, IList<string> classVariableNames, bool isvariable, IList<string> poolDictionaries, string category) : this(name, instanceVariableNames, classVariableNames, isvariable, poolDictionaries, category) { this.superclass = superclass; }
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, "};")); }
public void CompileSimpleClassWithInstanceVariables() { ClassModel @class = new ClassModel("AClass", (ClassModel)null, new List<string>() { "x", "y" }, new List<string>(), false, null, null); 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;")); }
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)); }
private void ProcessMessageExpression(CodeModel model, MessageExpression expression) { // TODO implements weakSubclass if (expression.Selector.StartsWith("subclass:") || expression.Selector.StartsWith("weakSubclass:") || expression.Selector.StartsWith("variableSubclass:")) { bool isvariable = expression.Selector.StartsWith("variableSubclass:"); SymbolExpression symbol = (SymbolExpression)expression.Arguments.First(); VariableExpression variable = (VariableExpression)expression.Target; ClassModel super = null; if (variable.Name != null && variable.Name != symbol.Symbol) //// TODO review quick hack if class is not defined yet if (model.HasClass(variable.Name)) super = model.GetClass(variable.Name); ClassModel @class; if (super != null || variable.Name == null) @class = new ClassModel(symbol.Symbol, super, GetInstanceVariableNames(expression), GetClassVariableNames(expression), isvariable, GetPoolDictionariesNames(expression), GetCategory(expression)); else @class = new ClassModel(symbol.Symbol, variable.Name, GetInstanceVariableNames(expression), GetClassVariableNames(expression), isvariable, GetPoolDictionariesNames(expression), GetCategory(expression)); model.AddElement(@class); } }
public ClassVariableExpression(string name, ClassModel @class) { this.name = name; this.@class = @class; }
public void CompileClass(ClassModel @class) { @class.Visit(this); }
public void CompileSimpleClass() { ClassModel @class = new ClassModel("AClass", (ClassModel)null, null, null, false, null, null); this.compiler.CompileClass(@class); this.writer.Close(); string output = this.writer.ToString(); Assert.IsTrue(ContainsLine(output, "function AClassClass()")); Assert.IsTrue(ContainsLine(output, "function AClass()")); Assert.IsTrue(ContainsLine(output, "{")); Assert.IsTrue(ContainsLine(output, "}")); Assert.IsTrue(ContainsLine(output, "AClass.prototype.__class = AClassClass.prototype;")); Assert.IsTrue(ContainsLine(output, "AClass.classPrototype = AClassClass.prototype;")); Assert.IsTrue(ContainsLine(output, "AClassClass.prototype['_basicNew'] = function() { return new AClass(); };")); }
public abstract void Visit(ClassModel @class);
public MethodModel ParseMethod(ClassModel @class, bool isClassMethod) { this.@class = @class; this.isClassMethod = isClassMethod; return this.ParseMethod(); }