private void ProcessClassMethod(XmlElement parent, ClassMethod method)
{
XmlElement savedElement = currentElement;
XmlElement tmpElement = document.CreateElement("ClassMethod");
tmpElement.SetAttribute("Name", method.Name);
tmpElement.SetAttribute("Scope", method.Scope.ToString());
if (method.Modifier != Modifier.Default)
{
tmpElement.SetAttribute("Modifier", method.Modifier.ToString());
}
currentElement = document.CreateElement("Parameters");
ProcessParameters(currentElement, method.Function.Parameters);
tmpElement.AppendChild(currentElement);
if (method.Function.Body != null)
{
currentElement = document.CreateElement("Body");
method.Function.Body.AcceptCompiler(this);
tmpElement.AppendChild(currentElement);
}
parent.AppendChild(tmpElement);
currentElement = savedElement;
}
private void DumpMethod(ClassMethod method)
{
textWriter.Write(method.Scope.ToString().ToLower());
if (method.Modifier != Modifier.Default)
{
textWriter.Write(" {0}", method.Modifier.ToString().ToLower());
}
if (ClassMethod.GetUnaryOperator(method.Name) != UnaryOperator.None)
{
var _operator = ClassMethod.GetUnaryOperator(method.Name);
textWriter.Write(" operator {0}", UnaryOperatorToString(_operator));
}
else if (ClassMethod.GetBinaryOperator(method.Name) != BinaryOperator.None)
{
var _operator = ClassMethod.GetBinaryOperator(method.Name);
textWriter.Write(" operator {0}", BinaryOperatorToString(_operator));
}
else
{
textWriter.Write(" function {0}", SafeName(method.Name));
}
if (method.Modifier == Modifier.Abstract)
{
DumpParametersList(method.Function.Parameters);
textWriter.WriteLine(";");
}
else
{
DumpFunction(method.Function);
}
textWriter.WriteLine();
}
public SemanticAtom Visit(MainClass n)
{
var method = new ClassMethod("main", null, n.MainMethodBody.Location);
CurrentMethod = method;
_localPosition = 0;
var argsType = new UtilizedType(Primitive.StringArray.Name, n.Location);
var argsArg = new MethodArgument(n.ArgsName, argsType, method.DeclarationLocation);
AddToGlobalUtilization(argsType, s => { argsArg.RealizedType = s; });
method.Arguments.Add(argsArg.Name, argsArg);
method.RealizedReturnType = Primitive.Void;
method.AstReturnType = null;
BlockStack = new Stack <ClassMethodBlock>();
method.MethodBody = n.MainMethodBody.Accept(this) as ClassMethodBlock;
var c = new Class(n.Name, null, n.Location)
{
IsMainClass = true
};
c.Methods.Add("main", method);
AddToTypeTable(c);
return(c);
}
public Class(ClassViewModel model)
{
Assignments = new List <Assignment.Assignment>();
StudentsEnrolled = new List <StudentClass>();
this.Name = model.Name;
this.ClassKey = ClassMethod.GenerateUniqueKey();
this.InstructorId = model.InstructorId;
}
public static ClassMethodViewModel FromModel(ClassMethod model)
{
return(new ClassMethodViewModel
{
Name = model.Name,
Visibility = model.Visibility,
ReturnType = model.ReturnType,
ClassMethodParameters = model.ClassMethodParameters.Select(ParameterViewModel.FromModel)
});
}
public void GetMember_ClassMethod()
{
var val = new ClassMethod <string>();
val.SetValue("Test text");
var member = ExpressionHelper.GetMember <ClassMethod <string>, string>(x => x.GetValue());
Assert.NotNull(member);
Assert.IsInstanceOf <MethodInfo>(member);
Assert.AreEqual("Test text", (member as MethodInfo).Invoke(val, new object[0]));
}
public ReadOnlyClassMethod(ClassMethod method)
{
this.method = method;
if (method.Body.Count != 0)
{
body = new ReadOnlyMethodBody(method.Body);
}
genericParameters = ReadOnlyGenericParameterDeclaration.Create(method.GenericParameters);
parameters = method.Parameters.ToArray(parameter => new ReadOnlyMethodParameter(parameter));
returnType = new ReadOnlyTypeReference(method.ReturnType);
}
public void AddingClassMethodWithIncorrectRelationship()
{
Class someClass = new Class("SomeClass");
Class anotherClass = new Class("AnotherClass");
ClassMethod method = new ClassMethod(anotherClass, "DoSomething");
TestDelegate test = delegate()
{
someClass.AddClassMethod(method);
};
Assert.Throws<ArgumentException>(test);
}
/// <summary>
/// Initializes a new instance of ClassDefinition
/// </summary>
/// <param name="className">The name of the class to be created</param>
/// <param name="superClassName">The name of an eventual super class</param>
/// <param name="modifier">Determines how the class supports inheritance and member access</param>
/// <param name="constructor">The constructor of the new class</param>
/// <param name="fields">The fields of the new class</param>
/// <param name="properties">The properties of the new class</param>
/// <param name="methods">The methods of the new class</param>
/// <param name="events">The events of the new class</param>
public ClassDefinition(string className, string superClassName, Modifier modifier,
ClassMethod constructor, ClassField[] fields,
ClassProperty[] properties, ClassMethod[] methods,
ClassEvent[] events)
{
ClassName = className;
SuperClassName = superClassName;
Modifier = modifier;
Constructor = constructor;
Fields = fields;
Properties = properties;
Methods = methods;
Events = events;
}
public void Map_MethodToProperty()
{
var typeMap = new ClassMethodClassPropertyMap();
this.safeMapService.Configuration.SetTypeMapping(typeMap.GetTypeMapping());
var input = new ClassMethod <int>();
input.SetValue(1337);
var result = this.safeMapService.Convert <ClassMethod <int>, ClassProperty <string> >(input);
Assert.AreEqual("1337", result.Value);
}
private MethodItem FromModel(ClassMethod model)
{
return(new MethodItem
{
ClassMethodParameters = model.ClassMethodParameters.Select(p => new ParameterItem
{
Name = p.Name,
Type = p.Type
}),
Name = model.Name,
ReturnType = model.ReturnType,
Visibility = model.Visibility
});
}
public void MethodOverriding()
{
Class entity = new Class("Entity");
Class actor = new Class("Actor", entity);
Class scriptActor = new Class("ScriptActor", actor);
ClassMethod entityMethod = new ClassMethod(entity, "DoSomething");
ClassMethod actorMethod = new ClassMethod(actor, "DoSomething");
ClassMethod scriptActorMethod = new ClassMethod(scriptActor, "DoSomething");
Assert.IsNull(entityMethod.Overrides);
Assert.AreEqual(entityMethod, actorMethod.Overrides);
Assert.AreEqual(entityMethod, scriptActorMethod.Overrides);
}
private void DumpConstructor(ClassMethod constructor)
{
textWriter.Write(constructor.Scope.ToString().ToLower());
textWriter.Write(" constructor");
Function function = constructor.Function;
DumpParametersList(function.Parameters);
if (function.Body.Statements.Length > 0 &&
function.Body.Statements[0] is ParentConstructorCall)
{
function.Body.Statements[0].AcceptCompiler(this);
}
textWriter.WriteLine();
DumpFunctionBody(function.Body);
textWriter.WriteLine();
}
public SemanticAtom Visit(Method n)
{
ClassMethod method;
if (n.ReturnAstType != null)
{
var returnUtilizedType = n.ReturnAstType.Accept(this) as UtilizedType;
method = new ClassMethod(n.Name, returnUtilizedType, n.Location);
AddToGlobalUtilization(returnUtilizedType, s => { method.RealizedReturnType = s; });
}
else
{
method = new ClassMethod(n.Name, null, n.Location)
{
RealizedReturnType = Primitive.Void
}
};
method.AstReturnType = n.ReturnAstType;
foreach (var a in n.ArgumentList)
{
var arg = (MethodArgument)a.Accept(this);
if (method.Arguments.ContainsKey(arg.Name))
{
Globals.Errors.Add($"[{arg.DeclarationLocation.StartLine}, {arg.DeclarationLocation.StartColumn}] Argument ({arg.Name}) is already defined in {method.Name}.");
}
else
{
method.Arguments.Add(arg.Name, arg);
}
}
CurrentMethod = method;
_localPosition = 0;
BlockStack = new Stack <ClassMethodBlock>();
method.MethodBody = n.Statement.Accept(this) as ClassMethodBlock;
return(method);
}
private void PersistMethod(Class classEntity, MethodItem methodData)
{
var method = new ClassMethod();
method.Id = Guid.NewGuid();
method.Name = methodData.Name;
method.Visibility = methodData.Visibility.Value;
method.ReturnType = methodData.ReturnType;
foreach (var parameterData in methodData.ClassMethodParameters)
{
var parameter = new ClassMethodParameter();
parameter.Id = Guid.NewGuid();
parameter.Name = parameterData.Name;
parameter.Type = parameterData.Type;
method.ClassMethodParameters.Add(parameter);
_classMethodParameterRepository.Add(parameter);
}
classEntity.ClassMethods.Add(method);
_classMethodRepository.Add(method);
}
public void DisposingAClassMethodRemovesItFromTheClassMethods()
{
ClassMethod method = new ClassMethod(luaClass, "DoSomething");
method.Dispose();
Assert.IsEmpty(luaClass.GetClassMethods());
}
public override ZingMethod Clone(Z.StateImpl myState, Z.Process myProcess, bool shallowCopy)
{
ClassMethod clone = new ClassMethod((Application) myState);
clone.locals = new LocalVars(clone);
clone.locals.CopyContents(locals);
clone.inputs = new InputVars(clone);
clone.inputs.CopyContents(inputs);
clone.outputs = new OutputVars(clone);
clone.outputs.CopyContents(outputs);
clone.nextBlock = this.nextBlock;
clone.handlerBlock = this.handlerBlock;
// clone.application = (Application) myState;
clone.SavedAtomicityLevel = this.SavedAtomicityLevel;
clone.privThis = this.privThis;
if (this.Caller != null)
{
if(shallowCopy)
{
clone.Caller = null;
}
else
{
// Recursively clone the next frame in the stack
clone.Caller = this.Caller.Clone(myState, myProcess, false);
}
}
else
{
// When we reach the entry point, patch our process appropriately
if (myProcess != null)
myProcess.EntryPoint = this;
}
return clone;
}
public void CppFilesParsingTest()
{
string folder = "tmp";
Dictionary <string, string> files = new Dictionary <string, string>
{
["class1.cpp"] =
"#include \"class1.h\";\n"
+ "/// <summary>\n/// Constructor of Class1</summary>"
+ "/// <param name=\"name\">The object's name</param>\n"
+ "Class1::Class1(string name){m_name= name;}\n"
+ "/// <summary>\n/// Description of the method Foo()</summary>"
+ "/// <param name=\"input\">Input argument</param>"
+ "/// <returns>Return code</returns>\n"
+ "void Class1::Foo(int input){return 1;}}\n}",
["class2.cpp"] =
"#include <stdlib>;\n#include <stdio.h>\n"
+ "/// <summary>\n/// Method Class2.Foo(int)\n/// </summary>\n"
+ "/// <param name=\"input\">Just a number</param>"
+ "/// <returns>Return code</returns>\n"
+ "int Class2::Foo(int input){return 2;}\n"
+ "/// <summary>\n/// Method Class2.Foo2(int)\n/// </summary>\n"
+ "/// <param name=\"input2\">Just a number</param>\n"
+ "void Class2::Foo2(int input2){ // Do nothing, return nothing}\n"
+ "}\n}"
};
CppSourceParser parser = new CppSourceParser();
CreateFileStructure(folder, files);
parser.ParseSourceFilesInDir(folder);
List <ObjectClass> parsedClasses = parser.GetObjectClasses();
Assert.Equal(2, parsedClasses.Count);
ObjectClass objClass = parsedClasses[0];
Assert.Single(objClass.Methods);
ClassMethod method = objClass.Methods[0];
Assert.Equal("Class1", objClass.Name);
Assert.Equal("Foo", method.Name);
Assert.Equal("Description of the method Foo()", method.MethodSummary);
Assert.Equal("void", method.ReturnType);
Assert.Equal("int input", method.Arguments);
Assert.Equal("Input argument", method.ArgumentDescriptions["input"]);
Assert.Equal("Return code", method.ReturnValueDescription);
Assert.Single(objClass.Constructors);
method = objClass.Constructors[0];
Assert.Equal("Class1", objClass.Name);
Assert.Equal(objClass.Name, method.Name);
Assert.Equal("Constructor of Class1", method.MethodSummary);
Assert.Null(method.ReturnType);
Assert.Equal("string name", method.Arguments);
Assert.Equal("The object's name", method.ArgumentDescriptions["name"]);
Assert.Null(method.ReturnValueDescription);
objClass = parsedClasses[1];
method = objClass.Methods[0];
Assert.Equal("Class2", objClass.Name);
Assert.Equal(2, objClass.Methods.Count);
Assert.Equal("Foo", method.Name);
Assert.Equal("Method Class2.Foo(int)", method.MethodSummary);
Assert.Equal("int", method.ReturnType);
Assert.Equal("int input", method.Arguments);
Assert.Equal("Just a number", method.ArgumentDescriptions["input"]);
Assert.Equal("Return code", method.ReturnValueDescription);
method = objClass.Methods[1];
Assert.Equal("Foo2", method.Name);
Assert.Equal("Method Class2.Foo2(int)", method.MethodSummary);
Assert.Equal("void", method.ReturnType);
Assert.Equal("int input2", method.Arguments);
Assert.Equal("Just a number", method.ArgumentDescriptions["input2"]);
Assert.Null(method.ReturnValueDescription);
DeleteFileStructure(folder);
}
public void TestQualifiedName()
{
ClassMethod method = new ClassMethod(luaClass, "DoSomething");
Assert.AreEqual("Actor.DoSomething", method.QualifiedName);
}
public void CSharpFilesParsingTest()
{
string folder = "tmp";
Dictionary <string, string> files = new Dictionary <string, string>
{
["Class1File.cs"] =
"using System.IO;\nnamespace MyProject\n{\npublic class Class1\n{\r\n"
+ "/// <summary>\n/// Constructor of Class1</summary>\n"
+ "/// <param name=\"name\">The object's name</param>\n"
+ "public Class1(string \n"
+ "name){m_name= name;}\n"
+ "/// <summary>\n/// Description of the method Foo()</summary>\n"
+ "/// <param name=\"input\">Input argument</param>\n"
+ "/// <returns>Return code</returns>\n"
+ "public static void Foo(int input){return 1;}}\n}",
["Class2File.cs"] =
"using System.IO;\nnamespace MyProject\n{\npublic class Class2\n{\npublic Class2(){}\n\r"
+ "/// <summary>\n/// Method Class2.Foo(int)\n/// </summary>\n"
+ "/// <param name=\"input\">Just a number</param>\n"
+ "/// <returns>Return code</returns>\n"
+ "public int Foo(int input){return 2;}\n"
+ "/// <summary>\n/// Method Class2.Foo2(int)\n/// </summary>\n"
+ "/// <param name=\"input2\">Just a number</param>\n"
+ "public async static void Foo2(int input2){ // Do nothing, return nothing}\n"
+ "}\n}"
};
CSharpSourceParser parser = new CSharpSourceParser();
CreateFileStructure(folder, files);
parser.ParseSourceFilesInDir(folder);
List <ObjectClass> parsedClasses = parser.GetObjectClasses();
Assert.Equal(2, parsedClasses.Count);
ObjectClass objClass = parsedClasses[0];
Assert.Single(objClass.Methods);
ClassMethod method = objClass.Methods[0];
Assert.Equal("Class1", objClass.Name);
Assert.Equal("Foo", method.Name);
Assert.Equal("Description of the method Foo()", method.MethodSummary);
Assert.Equal("void", method.ReturnType);
Assert.Equal("int input", method.Arguments);
Assert.Equal("Input argument", method.ArgumentDescriptions["input"]);
Assert.Equal("Return code", method.ReturnValueDescription);
Assert.Single(objClass.Constructors);
method = objClass.Constructors[0];
Assert.Equal("Class1", objClass.Name);
Assert.Equal(objClass.Name, method.Name);
Assert.Equal("Constructor of Class1", method.MethodSummary);
Assert.Null(method.ReturnType);
Assert.Equal("string name", method.Arguments);
Assert.Equal("The object's name", method.ArgumentDescriptions["name"]);
Assert.Null(method.ReturnValueDescription);
objClass = parsedClasses[1];
method = objClass.Methods[0];
Assert.Equal("Class2", objClass.Name);
Assert.Equal(2, objClass.Methods.Count);
Assert.Equal("Foo", method.Name);
Assert.Equal("Method Class2.Foo(int)", method.MethodSummary);
Assert.Equal("int", method.ReturnType);
Assert.Equal("int input", method.Arguments);
Assert.Equal("Just a number", method.ArgumentDescriptions["input"]);
Assert.Equal("Return code", method.ReturnValueDescription);
method = objClass.Methods[1];
Assert.Equal("Foo2", method.Name);
Assert.Equal("Method Class2.Foo2(int)", method.MethodSummary);
Assert.Equal("void", method.ReturnType);
Assert.Equal("int input2", method.Arguments);
Assert.Equal("Just a number", method.ArgumentDescriptions["input2"]);
Assert.Null(method.ReturnValueDescription);
DeleteFileStructure(folder);
}
public void AutomaticallyBuildsBiDirectionalRelationshipWithClass()
{
ClassMethod method = new ClassMethod(luaClass, "DoSomething");
Assert.IsNotEmpty(luaClass.GetClassMethods());
}
