private async Task <TestRunResult> RunAsync(ExecutionData executionData, string environmentPath,
string binariesFolder, ExecutableCode testingCode)
{
var testRunEnvironment = Path.Combine(environmentPath, Guid.NewGuid().ToString());
binariesFolder.CopyFolderTo(testRunEnvironment);
string inputFilePath = Path.Combine(testRunEnvironment, _configuration.InputFileName);
File.WriteAllText(inputFilePath, executionData.InputData);
var executionCommand = testingCode.GetExecutionCommand(testRunEnvironment);
executionCommand.StdinFilename = _configuration.InputFileName;
var containerExecutionResult =
await _executor.ExecuteAsync(executionCommand);
var outputFile = Path.Combine(testRunEnvironment, _configuration.OutputFileName);
return(new TestRunResult
{
ExecutionResult = containerExecutionResult.Result,
ExpectedOutput = executionData.OutputData,
UserOutput = await GetUserOutput(outputFile, containerExecutionResult)
});
}
public async Task <CodeExecutionResult> ExecuteAsync(ExecutableCode testingCode)
{
//Create Environment
var environmentPath = await CreateEnvironment(testingCode);
//Compile
if (testingCode is CompilableCode compilableCode)
{
var compilationResult = await _compiler.CompileCodeAsync(compilableCode);
if (!compilationResult.WasSuccessful)
{
return new CodeExecutionResult
{
CompilationErrors = compilationResult.Errors
}
}
;
}
//Create Execution Environment
var executionResults = await RunAsync(testingCode, environmentPath);
return(new CodeExecutionResult
{
Results = executionResults
});
}
public IObject CreateFunction(ExecutableCode executableCode, ReadOnlyList <string> formalParameters, ILexicalEnvironment scope)
{
// 13.2 Creating Function Objects
var f = new NFunction(this);
{
f.Class = "Function";
f.Extensible = true;
f.Prototype = FunctionPrototype;
f.ExecutableCode = executableCode;
f.FormalParameters = formalParameters;
f.Scope = scope;
f.DefineOwnProperty("length", CreateDataDescriptor(CreateNumber(f.FormalParameters.Count), false, false, false), false);
f.DefineOwnProperty("constructor", CreateDataDescriptor(f, true, false, true), false);
f.DefineOwnProperty("prototype", CreateDataDescriptor(ObjectConstructor.Op_Construct(EmptyArgs), true, false, false), false);
if (executableCode.Strict)
{
var desc = CreateAccessorDescriptor(ThrowTypeErrorFunction, ThrowTypeErrorFunction, false, false);
f.DefineOwnProperty("caller", desc, false);
f.DefineOwnProperty("arguments", desc, false);
}
}
return(f);
}
public async Task <CodeAnalysisResult> Analyse(TestingCode code)
{
var tempFolder = Path.Combine(Configuration.TempFolderPath, Guid.NewGuid().ToString());
await CreateDirectoryForAnalysis(code, tempFolder);
ExecutableCode executableCode = _codeFactory.GetExecutableCode(code);
Command executionCommand = GetCompilationCommand(executableCode, tempFolder);
Command analysisCommand = ModifyCommandForAnalysis(executionCommand);
ContainerExecutionResult containerExecutionResult = await _executor.ExecuteAsync(analysisCommand);
CodeAnalysisResult codeAnalysis = new CodeAnalysisResult();
if (containerExecutionResult.Result == ExecutionResult.Success)
{
codeAnalysis = AnalyseOutput(containerExecutionResult);
}
Directory.Delete(tempFolder, true);
return(codeAnalysis);
}
private Command GetCompilationCommand(ExecutableCode executableCode, string tempFolder)
{
if (executableCode is CompilableCode compilableCode)
{
return(compilableCode.GetCompilationCommand(tempFolder));
}
return(executableCode.GetExecutionCommand(tempFolder));
}
public StudyPage()
{
InitializeComponent();
#region AnimationsInit
Task.WhenAll(
CSharpDef.FadeTo(0, 1),
definitions.FadeTo(0, 1),
progLang.FadeTo(0, 1),
OOP.FadeTo(0, 1),
DotNETFramework.FadeTo(0, 1),
clr.FadeTo(0, 1),
cls.FadeTo(0, 1),
cts.FadeTo(0, 1),
MSIL.FadeTo(0, 1),
JIT.FadeTo(0, 1),
Compiler.FadeTo(0, 1),
SourceCode.FadeTo(0, 1),
ExecutableCode.FadeTo(0, 1),
boxview1.FadeTo(0, 1),
generalProgTerms.FadeTo(0, 1),
Variables.FadeTo(0, 1),
DataType.FadeTo(0, 1),
Keywords.FadeTo(0, 1),
Operators.FadeTo(0, 1),
Expression.FadeTo(0, 1),
TypeCasting.FadeTo(0, 1),
Arrays.FadeTo(0, 1),
Function.FadeTo(0, 1),
Class.FadeTo(0, 1),
Object.FadeTo(0, 1),
Constructor.FadeTo(0, 1),
Destructor.FadeTo(0, 1),
Namespaces.FadeTo(0, 1),
Exceptions.FadeTo(0, 1),
ExceptionHandling.FadeTo(0, 1),
boxview2.FadeTo(0, 1),
oopProgTerms.FadeTo(0, 1),
Inheritance.FadeTo(0, 1),
BaseClass.FadeTo(0, 1),
DerivedClass.FadeTo(0, 1),
AbstractClass.FadeTo(0, 1),
MultilevelInheritance.FadeTo(0, 1),
HierarchicalInheritance.FadeTo(0, 1),
SingleInheritance.FadeTo(0, 1),
Interface.FadeTo(0, 1),
Polymorphism.FadeTo(0, 1),
Overriding.FadeTo(0, 1),
Encapsulation.FadeTo(0, 1),
Abstraction.FadeTo(0, 1),
Overloading.FadeTo(0, 1));
#endregion
// App.adCounter = 0;
}
protected async override void OnAppearing()
{
#region AnimationsFadeIn
await Task.WhenAll(
CSharpDef.FadeTo(1, 500),
definitions.FadeTo(1, 500),
progLang.FadeTo(1, 500),
OOP.FadeTo(1, 500),
DotNETFramework.FadeTo(1, 500),
clr.FadeTo(1, 500),
cls.FadeTo(1, 500),
cts.FadeTo(1, 500),
MSIL.FadeTo(1, 500),
JIT.FadeTo(1, 500),
Compiler.FadeTo(1, 500),
SourceCode.FadeTo(1, 500),
ExecutableCode.FadeTo(1, 500),
boxview1.FadeTo(1, 500),
generalProgTerms.FadeTo(1, 500),
Variables.FadeTo(1, 500),
DataType.FadeTo(1, 500),
Keywords.FadeTo(1, 500),
Operators.FadeTo(1, 500),
Expression.FadeTo(1, 500),
TypeCasting.FadeTo(1, 500),
Arrays.FadeTo(1, 500),
Function.FadeTo(1, 500),
Class.FadeTo(1, 500),
Object.FadeTo(1, 500),
Constructor.FadeTo(1, 500),
Destructor.FadeTo(1, 500),
Namespaces.FadeTo(1, 500),
Exceptions.FadeTo(1, 500),
ExceptionHandling.FadeTo(1, 500),
boxview2.FadeTo(1, 500),
oopProgTerms.FadeTo(1, 500),
Inheritance.FadeTo(1, 500),
BaseClass.FadeTo(1, 500),
DerivedClass.FadeTo(1, 500),
AbstractClass.FadeTo(1, 500),
MultilevelInheritance.FadeTo(1, 500),
HierarchicalInheritance.FadeTo(1, 500),
SingleInheritance.FadeTo(1, 500),
Interface.FadeTo(1, 500),
Polymorphism.FadeTo(1, 500),
Overriding.FadeTo(1, 500),
Encapsulation.FadeTo(1, 500),
Abstraction.FadeTo(1, 500),
Overloading.FadeTo(1, 500));
#endregion
}
public override AbstractSyntaxTreeNode applyToExecutableCode(ExecutableCode operand)
{
Context.setRootScopeIfNone();
var executableCode = Context.newExecutableCodeNode();
operand.variablesDo(
variable => Context.Scope.declareLocalVariable(variable.Name,
(existingDeclaration) => {
Context.markAsUncompilable();
compiler.handleVariableNameCollision(existingDeclaration.NameString, variable.Span);
return(existingDeclaration.IsVariable ? (StackResidentVariableDeclaration)existingDeclaration : Context.Scope.declareLocalVariable("variable$" + variable.Name, null));
}));
operand.statementsDo(statement => executableCode.add((StatementNode)statement.valueBy(this)));
return(executableCode);
}
private async Task <TestRunResult[]> RunAsync(ExecutableCode testingCode, string environmentPath)
{
var binariesFolder = Path.Combine(environmentPath, "bin");
environmentPath.CopyFolderTo(binariesFolder);
var codeExecutionResultsTasks =
testingCode.ExecutionData.Select(executionData =>
RunAsync(executionData, environmentPath, binariesFolder, testingCode));
var executionResults = await Task.WhenAll(codeExecutionResultsTasks);
Directory.Delete(environmentPath, true);
return(executionResults);
}
private async Task <string> CreateEnvironment(ExecutableCode testingCode)
{
var executingCodeFolder = Path.Combine(_configuration.TempFolderPath, Guid.NewGuid().ToString());
var codePath = Path.Combine(executingCodeFolder,
$"{_configuration.CodeName}{testingCode.Language.GetExtension()}");
testingCode.WorkingDirectory = executingCodeFolder;
Directory.CreateDirectory(testingCode.WorkingDirectory);
await File.WriteAllTextAsync(codePath, testingCode.Text);
return(executingCodeFolder);
}
public IDynamic Execute(ExecutableCode executableCode)
{
_stopWatch.Restart();
using (var context = EnterContext())
{
context.ThisBinding = GlobalObject;
context.VariableEnviroment = GlobalEnvironment;
context.LexicalEnviroment = GlobalEnvironment;
context.Strict = executableCode.Strict;
BindFunctionDeclarations(executableCode.FunctionDeclarations, executableCode.Strict, true);
BindVariableDeclarations(executableCode.VariableDeclarations, executableCode.Strict, true);
var result = executableCode.Code(this, EmptyArgs);
Output.Write("Execution Time: " + _stopWatch.Elapsed);
return(result);
}
}
public virtual IDynamic Call(IEnvironment environment, IDynamic thisBinding, IArgs args)
{
var oldContext = environment.Context;
var newEnvironment = Scope.NewDeclarativeEnvironment();
using (var newContext = environment.EnterContext())
{
newContext.LexicalEnviroment = newEnvironment;
newContext.VariableEnviroment = newEnvironment;
newContext.Strict = ExecutableCode.Strict;
if (ExecutableCode.Strict)
{
newContext.ThisBinding = thisBinding;
}
else
{
switch (thisBinding.TypeCode)
{
case LanguageTypeCode.Undefined:
case LanguageTypeCode.Null:
newContext.ThisBinding = Environment.GlobalObject;
break;
default:
newContext.ThisBinding = thisBinding.ConvertToObject();
break;
}
}
BindFormalParameters(args);
Environment.BindFunctionDeclarations(ExecutableCode.FunctionDeclarations, ExecutableCode.Strict, true);
BindArgumentsObject(args);
Environment.BindVariableDeclarations(ExecutableCode.VariableDeclarations, ExecutableCode.Strict, true);
return(ExecutableCode.Code(environment, args));
}
}
public virtual T applyToExecutableCode(ExecutableCode operand)
{
return(applyToParseTreeNode(operand));
}
public override void PrepareForExecution()
{
if (DLLModelType == DLLModelTypes.C)
{
}
else if (DLLModelType == DLLModelTypes.CPP)
{
}
else if (DLLModelType == DLLModelTypes.CS)
{
ExecutableCode = "";
ExecutableCode += "\t\tpublic object " + Name + "(";
foreach (Data inputData in ModelDataInputs)
{
if (inputData is IntegerData)
{
ExecutableCode += "int " + inputData.Name + ", ";
}
else if (inputData is DoubleData)
{
ExecutableCode += "double " + inputData.Name + ", ";
}
else if (inputData is IntegerVectorData)
{
ExecutableCode += "int[] " + inputData.Name + ", ";
}
else if (inputData is DoubleVectorData)
{
ExecutableCode += "double[] " + inputData.Name + ", ";
}
}
ExecutableCode = ExecutableCode.TrimEnd(',', ' ');
ExecutableCode += ")\n\t\t";
ExecutableCode += "{\n";
//DElMethis.DLLFilePath = "IRW1_RNG_RMP\\AircadiaCSLib\\AircadiaCSLib\\bin\\Debug\\AircadiaCSLib.dll";
// Get type from the "aircadia project dll" (aircadia project dll assembly contains only one type, i.e. only one class) and then create object of that type
AircadiaProject Project = AircadiaProject.Instance;
ExecutableCode += "\t\t\tAssembly assembly = Assembly.LoadFile(@\"" + System.IO.Path.Combine(Project.ProjectPath, DLLFilePath) + "\");\n";
ExecutableCode += "\t\t\tType[] aircadiaProjDLLTypes = assembly.GetTypes();\n";
ExecutableCode += "\t\t\tobject aircadiaProjDLLObject = Activator.CreateInstance(aircadiaProjDLLTypes[0]);\n";
// Get method object to be executed in "aircadia project dll"
ExecutableCode += "\t\t\tMethodInfo methodInfo = aircadiaProjDLLTypes[0].GetMethod(\"" + Name + "\");\n";
ExecutableCode += "\t\t\tMethodInfo[] methodInfoA = aircadiaProjDLLTypes[0].GetMethods();\n";
// initialise input arguments for the method (arguments also contain outputs of the model)
ExecutableCode += "\t\t\tobject[] inputArgs = new object[" + (ModelDataInputs.Count + ModelDataOutputs.Count) + "];\n";
int ncount = 0;
foreach (Data data in ModelDataInputs)
{
if (data is IntegerData)
{
ExecutableCode += "\t\t\tinputArgs[" + ncount + "] = " + ((IntegerData)data).Name + ";\n";
}
else if (data is DoubleData)
{
ExecutableCode += "\t\t\tinputArgs[" + ncount + "] = " + ((DoubleData)data).Name + ";\n";
}
else if (data is IntegerVectorData)
{
ExecutableCode += "\t\t\tinputArgs[" + ncount + "] = " + ((IntegerVectorData)data).Name + ";\n";
}
else if (data is DoubleVectorData)
{
ExecutableCode += "\t\t\tinputArgs[" + ncount + "] = " + ((DoubleVectorData)data).Name + ";\n";
}
ncount++;
}
// Execute the model (call method of the Aircadia project dll)
ExecutableCode += "\t\t\ttry\n";
ExecutableCode += "\t\t\t{\n";
ExecutableCode += "\t\t\t\tmethodInfo.Invoke(aircadiaProjDLLObject, inputArgs);\n";
ExecutableCode += "\t\t\t}\n";
ExecutableCode += "\t\t\tcatch (Exception e)\n";
ExecutableCode += "\t\t\t{\n";
ExecutableCode += "\t\t\t\tSystem.Console.WriteLine(e.Source);\n";
ExecutableCode += "\t\t\t\tSystem.Console.WriteLine(e.StackTrace);\n";
//this.ExecutableCode += "\t\t\t\tConsole.WriteLine(\"Execution of model (" + this.Name + ") failed in C# dll file " + Path.GetDirectoryName(this.DLLFilePath) + "\\" + this.dllFileName + ".dll\", \"DLL Model Execution Failed\", MessageBoxButton.OK, MessageBoxImage.Information);\n";
//status = false;
ExecutableCode += "\t\t\t}\n";
// Output
ExecutableCode += "\t\t\tobject modelResultObject = null;\n";
ExecutableCode += "\t\t\tobject[] outputs = new object[" + ModelDataOutputs.Count + "];\n";
ExecutableCode += "\t\t\tfor (int i = 0; i < " + ModelDataOutputs.Count + "; i++)\n";
ExecutableCode += "\t\t\t{\n";
ExecutableCode += "\t\t\t\toutputs[i] = inputArgs[" + ModelDataInputs.Count + " + i];\n";
ExecutableCode += "\t\t\t}\n";
ExecutableCode += "\t\t\tmodelResultObject = outputs;\n";
ExecutableCode += "\t\t\treturn modelResultObject;\n";
ExecutableCode += "\t\t}\n";
}
else if (DLLModelType == DLLModelTypes.FORTRAN)
{
}
else if (DLLModelType == DLLModelTypes.MATLAB)
{
}
}
