public static void CrossCompileAOTDirectory(BuildTarget buildTarget, CrossCompileOptions crossCompileOptions, string sourceAssembliesFolder, string targetCrossCompiledASMFolder, string pathExtension, string additionalOptions)
{
string text = BuildPipeline.GetBuildToolsDirectory(buildTarget);
if (Application.platform == RuntimePlatform.OSXEditor)
{
text = Path.Combine(Path.Combine(text, pathExtension), "mono-xcompiler");
}
else
{
text = Path.Combine(Path.Combine(text, pathExtension), "mono-xcompiler.exe");
}
sourceAssembliesFolder = Path.Combine(Directory.GetCurrentDirectory(), sourceAssembliesFolder);
targetCrossCompiledASMFolder = Path.Combine(Directory.GetCurrentDirectory(), targetCrossCompiledASMFolder);
string[] files = Directory.GetFiles(sourceAssembliesFolder);
for (int i = 0; i < files.Length; i++)
{
string path = files[i];
if (!(Path.GetExtension(path) != ".dll"))
{
string fileName = Path.GetFileName(path);
string output = Path.Combine(targetCrossCompiledASMFolder, fileName + ".s");
if (EditorUtility.DisplayCancelableProgressBar("Building Player", "AOT cross compile " + fileName, 0.95f))
{
throw new OperationCanceledException();
}
MonoCrossCompile.CrossCompileAOT(buildTarget, text, sourceAssembliesFolder, crossCompileOptions, fileName, output, additionalOptions);
}
}
}
public void ThreadPoolCallback(object threadContext)
{
try
{
MonoCrossCompile.CrossCompileAOT(this.m_target, this.m_crossCompilerAbsolutePath, this.m_assembliesAbsoluteDirectory, this.m_crossCompileOptions, this.m_input, this.m_output, this.m_additionalOptions);
}
catch (Exception exception)
{
this.m_Exception = exception;
}
this.m_doneEvent.Set();
}
public static bool CrossCompileAOTDirectoryParallel(BuildTarget buildTarget, CrossCompileOptions crossCompileOptions, string sourceAssembliesFolder, string targetCrossCompiledASMFolder, string pathExtension, string additionalOptions)
{
string text = BuildPipeline.GetBuildToolsDirectory(buildTarget);
if (Application.platform == RuntimePlatform.OSXEditor)
{
text = Path.Combine(Path.Combine(text, pathExtension), "mono-xcompiler");
}
else
{
text = Path.Combine(Path.Combine(text, pathExtension), "mono-xcompiler.exe");
}
return(MonoCrossCompile.CrossCompileAOTDirectoryParallel(text, buildTarget, crossCompileOptions, sourceAssembliesFolder, targetCrossCompiledASMFolder, additionalOptions));
}
public void ThreadPoolCallback(System.Object threadContext)
{
try
{
MonoCrossCompile.CrossCompileAOT(m_target, m_crossCompilerAbsolutePath,
m_assembliesAbsoluteDirectory, m_crossCompileOptions,
m_input, m_output, m_additionalOptions);
}
catch (Exception ex)
{
m_Exception = ex;
}
m_doneEvent.Set();
}
public static void CrossCompileAOTDirectory(BuildTarget buildTarget, CrossCompileOptions crossCompileOptions, string sourceAssembliesFolder, string targetCrossCompiledASMFolder, string pathExtension, string additionalOptions)
{
string buildToolsDirectory = BuildPipeline.GetBuildToolsDirectory(buildTarget);
string crossCompilerAbsolutePath = Application.platform != RuntimePlatform.OSXEditor ? Path.Combine(Path.Combine(buildToolsDirectory, pathExtension), "mono-xcompiler.exe") : Path.Combine(Path.Combine(buildToolsDirectory, pathExtension), "mono-xcompiler");
sourceAssembliesFolder = Path.Combine(Directory.GetCurrentDirectory(), sourceAssembliesFolder);
targetCrossCompiledASMFolder = Path.Combine(Directory.GetCurrentDirectory(), targetCrossCompiledASMFolder);
foreach (string file in Directory.GetFiles(sourceAssembliesFolder))
{
if (!(Path.GetExtension(file) != ".dll"))
{
string fileName = Path.GetFileName(file);
string output = Path.Combine(targetCrossCompiledASMFolder, fileName + ".s");
if (EditorUtility.DisplayCancelableProgressBar("Building Player", "AOT cross compile " + fileName, 0.95f))
{
throw new OperationCanceledException();
}
MonoCrossCompile.CrossCompileAOT(buildTarget, crossCompilerAbsolutePath, sourceAssembliesFolder, crossCompileOptions, fileName, output, additionalOptions);
}
}
}
public static bool CrossCompileAOTDirectoryParallel(BuildTarget buildTarget, CrossCompileOptions crossCompileOptions, string sourceAssembliesFolder, string targetCrossCompiledASMFolder, string additionalOptions)
{
return(MonoCrossCompile.CrossCompileAOTDirectoryParallel(buildTarget, crossCompileOptions, sourceAssembliesFolder, targetCrossCompiledASMFolder, string.Empty, additionalOptions));
}
public static void CrossCompileAOTDirectory(BuildTarget buildTarget, CrossCompileOptions crossCompileOptions, string sourceAssembliesFolder, string targetCrossCompiledASMFolder, string additionalOptions)
{
MonoCrossCompile.CrossCompileAOTDirectory(buildTarget, crossCompileOptions, sourceAssembliesFolder, targetCrossCompiledASMFolder, string.Empty, additionalOptions);
}
private static void CrossCompileAOT(BuildTarget target, string crossCompilerAbsolutePath, string assembliesAbsoluteDirectory, CrossCompileOptions crossCompileOptions, string input, string output, string additionalOptions)
{
string text = string.Empty;
if (!MonoCrossCompile.IsDebugableAssembly(input))
{
crossCompileOptions &= ~CrossCompileOptions.Debugging;
crossCompileOptions &= ~CrossCompileOptions.LoadSymbols;
}
bool flag = (crossCompileOptions & CrossCompileOptions.Debugging) != CrossCompileOptions.Dynamic;
bool flag2 = (crossCompileOptions & CrossCompileOptions.LoadSymbols) != CrossCompileOptions.Dynamic;
bool flag3 = flag || flag2;
if (flag3)
{
text += "--debug ";
}
if (flag)
{
text += "--optimize=-linears ";
}
text += "--aot=full,asmonly,";
if (flag3)
{
text += "write-symbols,";
}
if ((crossCompileOptions & CrossCompileOptions.Debugging) != CrossCompileOptions.Dynamic)
{
text += "soft-debug,";
}
else
{
if (!flag3)
{
text += "nodebug,";
}
}
if (target != BuildTarget.iOS)
{
text += "print-skipped,";
}
if (additionalOptions != null & additionalOptions.Trim().Length > 0)
{
text = text + additionalOptions.Trim() + ",";
}
string fileName = Path.GetFileName(output);
string text2 = Path.Combine(assembliesAbsoluteDirectory, fileName);
if ((crossCompileOptions & CrossCompileOptions.FastICall) != CrossCompileOptions.Dynamic)
{
text += "ficall,";
}
if ((crossCompileOptions & CrossCompileOptions.Static) != CrossCompileOptions.Dynamic)
{
text += "static,";
}
string text3 = text;
text = string.Concat(new string[]
{
text3,
"outfile=\"",
fileName,
"\" \"",
input,
"\" "
});
Process process = new Process();
process.StartInfo.FileName = crossCompilerAbsolutePath;
process.StartInfo.Arguments = text;
process.StartInfo.EnvironmentVariables["MONO_PATH"] = assembliesAbsoluteDirectory;
process.StartInfo.EnvironmentVariables["GAC_PATH"] = assembliesAbsoluteDirectory;
process.StartInfo.EnvironmentVariables["GC_DONT_GC"] = "yes please";
if ((crossCompileOptions & CrossCompileOptions.ExplicitNullChecks) != CrossCompileOptions.Dynamic)
{
process.StartInfo.EnvironmentVariables["MONO_DEBUG"] = "explicit-null-checks";
}
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.RedirectStandardOutput = true;
if (MonoCrossCompile.ArtifactsPath != null)
{
if (!Directory.Exists(MonoCrossCompile.ArtifactsPath))
{
Directory.CreateDirectory(MonoCrossCompile.ArtifactsPath);
}
File.AppendAllText(MonoCrossCompile.ArtifactsPath + "output.txt", process.StartInfo.FileName + "\n");
File.AppendAllText(MonoCrossCompile.ArtifactsPath + "output.txt", process.StartInfo.Arguments + "\n");
File.AppendAllText(MonoCrossCompile.ArtifactsPath + "output.txt", assembliesAbsoluteDirectory + "\n");
File.AppendAllText(MonoCrossCompile.ArtifactsPath + "output.txt", text2 + "\n");
File.AppendAllText(MonoCrossCompile.ArtifactsPath + "output.txt", input + "\n");
File.AppendAllText(MonoCrossCompile.ArtifactsPath + "houtput.txt", fileName + "\n\n");
File.Copy(assembliesAbsoluteDirectory + "\\" + input, MonoCrossCompile.ArtifactsPath + "\\" + input, true);
}
process.StartInfo.WorkingDirectory = assembliesAbsoluteDirectory;
MonoProcessUtility.RunMonoProcess(process, "AOT cross compiler", text2);
File.Move(text2, output);
if ((crossCompileOptions & CrossCompileOptions.Static) == CrossCompileOptions.Dynamic)
{
string text4 = Path.Combine(assembliesAbsoluteDirectory, fileName + ".def");
if (File.Exists(text4))
{
File.Move(text4, output + ".def");
}
}
}
public static bool CrossCompileAOTDirectoryParallel(string crossCompilerPath, BuildTarget buildTarget, CrossCompileOptions crossCompileOptions, string sourceAssembliesFolder, string targetCrossCompiledASMFolder, string additionalOptions)
{
sourceAssembliesFolder = Path.Combine(Directory.GetCurrentDirectory(), sourceAssembliesFolder);
targetCrossCompiledASMFolder = Path.Combine(Directory.GetCurrentDirectory(), targetCrossCompiledASMFolder);
int num = 1;
int num2 = 1;
ThreadPool.GetMaxThreads(out num, out num2);
List <MonoCrossCompile.JobCompileAOT> list = new List <MonoCrossCompile.JobCompileAOT>();
List <ManualResetEvent> list2 = new List <ManualResetEvent>();
bool flag = true;
List <string> list3 = new List <string>(
from path in Directory.GetFiles(sourceAssembliesFolder)
where Path.GetExtension(path) == ".dll"
select path);
int count = list3.Count;
int num3 = 0;
MonoCrossCompile.DisplayAOTProgressBar(count, num3);
long num4 = (long)Math.Min(1800000, (count + 3) * 1000 * 30);
foreach (string current in list3)
{
string fileName = Path.GetFileName(current);
string output = Path.Combine(targetCrossCompiledASMFolder, fileName + ".s");
MonoCrossCompile.JobCompileAOT jobCompileAOT = new MonoCrossCompile.JobCompileAOT(buildTarget, crossCompilerPath, sourceAssembliesFolder, crossCompileOptions, fileName, output, additionalOptions);
list.Add(jobCompileAOT);
list2.Add(jobCompileAOT.m_doneEvent);
ThreadPool.QueueUserWorkItem(new WaitCallback(jobCompileAOT.ThreadPoolCallback));
if (list2.Count >= Environment.ProcessorCount)
{
flag = MonoCrossCompile.WaitForBuildOfFile(list2, ref num4);
MonoCrossCompile.DisplayAOTProgressBar(count, num3);
num3++;
if (!flag)
{
break;
}
}
}
while (list2.Count > 0)
{
flag = MonoCrossCompile.WaitForBuildOfFile(list2, ref num4);
MonoCrossCompile.DisplayAOTProgressBar(count, num3);
num3++;
if (!flag)
{
break;
}
}
foreach (MonoCrossCompile.JobCompileAOT current2 in list)
{
if (current2.m_Exception != null)
{
UnityEngine.Debug.LogErrorFormat("Cross compilation job {0} failed.\n{1}", new object[]
{
current2.m_input,
current2.m_Exception
});
flag = false;
}
}
return(flag);
}
public static bool CrossCompileAOTDirectoryParallel(string crossCompilerPath, BuildTarget buildTarget, CrossCompileOptions crossCompileOptions, string sourceAssembliesFolder, string targetCrossCompiledASMFolder, string additionalOptions)
{
sourceAssembliesFolder = Path.Combine(Directory.GetCurrentDirectory(), sourceAssembliesFolder);
targetCrossCompiledASMFolder = Path.Combine(Directory.GetCurrentDirectory(), targetCrossCompiledASMFolder);
int workerThreads = 1;
int completionPortThreads = 1;
ThreadPool.GetMaxThreads(out workerThreads, out completionPortThreads);
List <MonoCrossCompile.JobCompileAOT> jobCompileAotList = new List <MonoCrossCompile.JobCompileAOT>();
List <ManualResetEvent> events = new List <ManualResetEvent>();
bool flag = true;
List <string> stringList = new List <string>(((IEnumerable <string>)Directory.GetFiles(sourceAssembliesFolder)).Where <string>((Func <string, bool>)(path => Path.GetExtension(path) == ".dll")));
int count = stringList.Count;
int filesFinished = 0;
MonoCrossCompile.DisplayAOTProgressBar(count, filesFinished);
long timeout = (long)Math.Min(1800000, (count + 3) * 1000 * 30);
using (List <string> .Enumerator enumerator = stringList.GetEnumerator())
{
while (enumerator.MoveNext())
{
string fileName = Path.GetFileName(enumerator.Current);
string output = Path.Combine(targetCrossCompiledASMFolder, fileName + ".s");
MonoCrossCompile.JobCompileAOT jobCompileAot = new MonoCrossCompile.JobCompileAOT(buildTarget, crossCompilerPath, sourceAssembliesFolder, crossCompileOptions, fileName, output, additionalOptions);
jobCompileAotList.Add(jobCompileAot);
events.Add(jobCompileAot.m_doneEvent);
ThreadPool.QueueUserWorkItem(new WaitCallback(jobCompileAot.ThreadPoolCallback));
if (events.Count >= Environment.ProcessorCount)
{
flag = MonoCrossCompile.WaitForBuildOfFile(events, ref timeout);
MonoCrossCompile.DisplayAOTProgressBar(count, filesFinished);
++filesFinished;
if (!flag)
{
break;
}
}
}
}
while (events.Count > 0)
{
flag = MonoCrossCompile.WaitForBuildOfFile(events, ref timeout);
MonoCrossCompile.DisplayAOTProgressBar(count, filesFinished);
++filesFinished;
if (!flag)
{
break;
}
}
using (List <MonoCrossCompile.JobCompileAOT> .Enumerator enumerator = jobCompileAotList.GetEnumerator())
{
while (enumerator.MoveNext())
{
MonoCrossCompile.JobCompileAOT current = enumerator.Current;
if (current.m_Exception != null)
{
UnityEngine.Debug.LogErrorFormat("Cross compilation job {0} failed.\n{1}", new object[2]
{
(object)current.m_input,
(object)current.m_Exception
});
flag = false;
}
}
}
return(flag);
}
