public static Boolean init; //Check if code is complied, so that it doesn't have to do it everytime
#endregion Fields
#region Methods
/*
Compiles the files in the AI sub-dirctory
*/
public static void initAI()
{
if (!init)
{
AIPrograms = new Dictionary<string, AIBase>();//Create the hashmap
CSharpCodeCompiler provider = new CSharpCodeCompiler(); //Get the complier
CompilerParameters parameters = new CompilerParameters();
foreach (string file in Directory.GetFiles("AI"))
{
//For every file in the AI directory
Debug.Log ("file: " + file);
parameters = new CompilerParameters();//Generate new parametes
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
parameters.ReferencedAssemblies.Add(asm.Location);//Link all the assmeblies to this new file that we are compiling
}
Debug.Log(Path.GetFileNameWithoutExtension(file));
//Read file
StreamReader theReader = new StreamReader(file, Encoding.Default);
string code = theReader.ReadToEnd();
//Actually compile
CompilerResults results = provider.CompileAssemblyFromSource(parameters, code);
//Check for errors and print them. It would be good to display these later.
if (results.Errors.Count > 0)
{
foreach (CompilerError CompErr in results.Errors)
{
Debug.Log("Line number " + CompErr.Line +
", Error Number: " + CompErr.ErrorNumber +
", '" + CompErr.ErrorText + ";");
}
}
//Create results. Note this will cause a crash if there are errors in scripts. Should change
Assembly assembly = results.CompiledAssembly;
Debug.Log("Assembly "+assembly);
//Get the name of the C# script assembly.
Type program = assembly.GetType(Path.GetFileNameWithoutExtension(file));
//Get the constructor for that script to generate a new class
ConstructorInfo main = program.GetConstructor(new Type[0]);
//Convert it to an AI script
AIBase ai = (AIBase)main.Invoke(new System.Object[0]);
//Add to hashmap under its name.
AIPrograms.Add(Path.GetFileNameWithoutExtension(file), ai);
}
}
}
public void Compile(ICompilationJob job)
{
job.Output.WriteInfo($"----------------------------------------");
job.Output.WriteInfo($"Parsing ..");
// Run parser on every input file
PParser.ProgramContext[] trees = job.InputFiles.Select(file =>
{
PParser.ProgramContext tree = Parse(job, file);
job.LocationResolver.RegisterRoot(tree, file);
return(tree);
}).ToArray();
job.Output.WriteInfo($"Type checking ...");
// Run typechecker and produce AST
Scope scope = Analyzer.AnalyzeCompilationUnit(job.Handler, trees);
// Convert functions to lowered SSA form with explicit cloning
foreach (TypeChecker.AST.Declarations.Function fun in scope.GetAllMethods())
{
IRTransformer.SimplifyMethod(fun);
}
job.Output.WriteInfo($"Code generation ....");
// Run the selected backend on the project and write the files.
System.Collections.Generic.IEnumerable <CompiledFile> compiledFiles = job.Backend.GenerateCode(job, scope);
foreach (CompiledFile file in compiledFiles)
{
job.Output.WriteInfo($"Generated {file.FileName}");
job.Output.WriteFile(file);
}
job.Output.WriteInfo($"----------------------------------------");
// Compiling the generated C# code
// TODO: This is a special case right now but needs to be factored in after the Java code path is available
if (job.OutputLanguage == CompilerOutput.CSharp)
{
job.Output.WriteInfo($"Compiling {job.ProjectName}.csproj ..\n");
CSharpCodeCompiler.Compile(job);
job.Output.WriteInfo($"----------------------------------------");
}
}
public static void initAI()
{
if (!init)
{
AIPrograms = new Dictionary <string, AIBase>();
CSharpCodeCompiler provider = new CSharpCodeCompiler();
CompilerParameters parameters = new CompilerParameters();
foreach (string file in Directory.GetFiles("AI"))
{
parameters = new CompilerParameters();
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
parameters.ReferencedAssemblies.Add(asm.Location);
}
Debug.Log(Path.GetFileNameWithoutExtension(file));
StreamReader theReader = new StreamReader(file, Encoding.Default);
string code = theReader.ReadToEnd();
CompilerResults results = provider.CompileAssemblyFromSource(parameters, code);
if (results.Errors.Count > 0)
{
foreach (CompilerError CompErr in results.Errors)
{
Debug.Log("Line number " + CompErr.Line +
", Error Number: " + CompErr.ErrorNumber +
", '" + CompErr.ErrorText + ";");
}
}
Assembly assembly = results.CompiledAssembly;
Debug.Log("Assembly " + assembly);
Type program = assembly.GetType(Path.GetFileNameWithoutExtension(file));
ConstructorInfo main = program.GetConstructor(new Type[0]);
AIBase ai = (AIBase)main.Invoke(new System.Object[0]);
AIPrograms.Add(Path.GetFileNameWithoutExtension(file), ai);
}
}
}
public static void initAI()
{
if (!init)
{
AIPrograms = new Dictionary<string, AIBase>();
CSharpCodeCompiler provider = new CSharpCodeCompiler();
CompilerParameters parameters = new CompilerParameters();
foreach (string file in Directory.GetFiles("AI"))
{
parameters = new CompilerParameters();
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
parameters.ReferencedAssemblies.Add(asm.Location);
}
Debug.Log(Path.GetFileNameWithoutExtension(file));
StreamReader theReader = new StreamReader(file, Encoding.Default);
string code = theReader.ReadToEnd();
CompilerResults results = provider.CompileAssemblyFromSource(parameters, code);
if (results.Errors.Count > 0)
{
foreach (CompilerError CompErr in results.Errors)
{
Debug.Log("Line number " + CompErr.Line +
", Error Number: " + CompErr.ErrorNumber +
", '" + CompErr.ErrorText + ";");
}
}
Assembly assembly = results.CompiledAssembly;
Debug.Log("Assembly "+assembly);
Type program = assembly.GetType(Path.GetFileNameWithoutExtension(file));
ConstructorInfo main = program.GetConstructor(new Type[0]);
AIBase ai = (AIBase)main.Invoke(new System.Object[0]);
AIPrograms.Add(Path.GetFileNameWithoutExtension(file), ai);
}
}
}
public void ShouldReturnAssemblyWhenCompiled()
{
var sheetBuilder = new SheetBuilder();
var workbookBuilder = new WorkbookBuilder(sheetBuilder);
var assemblyCodeBuilder = new AssemblyCodeBuilder(workbookBuilder);
const string assemblyName = "UnitTest";
var assemblyCode = assemblyCodeBuilder.Build(assemblyName, workbook);
var assemblyBytes = CSharpCodeCompiler.GetAssemblyBytes(assemblyName, assemblyCode).ToArray();
Assert.NotEmpty(assemblyBytes);
var assembly = Assembly.Load(assemblyBytes);
var compiledWorkbook = assembly.CreateInstance($"{assemblyName}.Workbook") as IWorkbook;
Assert.NotNull(compiledWorkbook);
var sheet = compiledWorkbook.GetSheet(SheetName);
sheet.Evaluate();
var value = sheet.GetNumeric("A1");
Assert.Equal(84, value);
}
// Constructor.
public CSharpCodeProvider()
{
csharpCodeCompiler = new CSharpCodeCompiler();
}
public static Type CompileType(string code, ref bool errorInCode, ref List <CompilerError> errors)
{
var cSharpCodeCompiler = new CSharpCodeCompiler();
CompilerParameters parameters = new CompilerParameters
{
GenerateInMemory = true,
GenerateExecutable = false
};
foreach (var assembli in AssembliesDic)
{
foreach (var loadDll in _assemblyList)
{
if (assembli.Key != loadDll)
{
continue;
}
try
{
if (!parameters.ReferencedAssemblies.Contains(assembli.Value))
{
parameters.ReferencedAssemblies.Add(assembli.Value);
}
}
catch
{
//
}
}
}
foreach (string path in GameStateData.GetAssembliesPathes())
{
try
{
if (!parameters.ReferencedAssemblies.Contains(path))
{
parameters.ReferencedAssemblies.Add(path);
}
}
catch
{
// ignored
}
}
var result = cSharpCodeCompiler.CompileAssemblyFromSource(parameters, code);
var assembly = result.CompiledAssembly;
if (!result.Errors.HasErrors)
{
return(assembly.ExportedTypes.FirstOrDefault());
}
foreach (CompilerError error in result.Errors)
{
errorInCode = true;
errors.Add(error);
}
return(null);
}
