public static void Run(string commaSeparatedListOfAssemblies)
{
string[] array = commaSeparatedListOfAssemblies.Split(new char[]
{
','
}, StringSplitOptions.RemoveEmptyEntries);
APIUpdaterLogger.WriteToFile("Started to update {0} assemblie(s)", new object[]
{
array.Count <string>()
});
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
string[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
string text = array2[i];
if (AssemblyHelper.IsManagedAssembly(text))
{
string text2 = APIUpdaterHelper.ResolveAssemblyPath(text);
string text3;
string text4;
int num = APIUpdaterHelper.RunUpdatingProgram("AssemblyUpdater.exe", string.Concat(new string[]
{
"-u -a ",
text2,
APIUpdaterHelper.APIVersionArgument(),
APIUpdaterHelper.AssemblySearchPathArgument(),
APIUpdaterHelper.ConfigurationProviderAssembliesPathArgument()
}), out text3, out text4);
if (text3.Length > 0)
{
APIUpdaterLogger.WriteToFile("Assembly update output ({0})\r\n{1}", new object[]
{
text2,
text3
});
}
if (APIUpdaterHelper.IsError(num))
{
APIUpdaterLogger.WriteErrorToConsole("Error {0} running AssemblyUpdater. Its output is: `{1}`", new object[]
{
num,
text4
});
}
}
}
APIUpdaterLogger.WriteToFile("Update finished in {0}s", new object[]
{
stopwatch.Elapsed.TotalSeconds
});
}
public static bool DoesAssemblyRequireUpgrade(string assemblyFullPath)
{
bool result;
if (!File.Exists(assemblyFullPath))
{
result = false;
}
else if (!AssemblyHelper.IsManagedAssembly(assemblyFullPath))
{
result = false;
}
else if (!APIUpdaterHelper.MayContainUpdatableReferences(assemblyFullPath))
{
result = false;
}
else
{
string text;
string text2;
int num = APIUpdaterHelper.RunUpdatingProgram("AssemblyUpdater.exe", string.Concat(new string[]
{
APIUpdaterHelper.TimeStampArgument(),
APIUpdaterHelper.APIVersionArgument(),
"--check-update-required -a ",
CommandLineFormatter.PrepareFileName(assemblyFullPath),
APIUpdaterHelper.AssemblySearchPathArgument(),
APIUpdaterHelper.ConfigurationProviderAssembliesPathArgument()
}), out text, out text2);
Console.WriteLine("{0}{1}", text, text2);
switch (num)
{
case 0:
case 1:
result = false;
break;
case 2:
result = true;
break;
default:
UnityEngine.Debug.LogError(text + Environment.NewLine + text2);
result = false;
break;
}
}
return(result);
}
public static void Run(string commaSeparatedListOfAssemblies)
{
var assemblies = commaSeparatedListOfAssemblies.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
APIUpdaterHelper.HandleFilesInPackagesVirtualFolder(assemblies);
foreach (var assemblyPath in assemblies)
{
if ((File.GetAttributes(assemblyPath) & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
{
APIUpdaterLogger.WriteErrorToConsole("Error can't update assembly {0} the file is read-only", assemblyPath);
return;
}
}
APIUpdaterLogger.WriteToFile("Started to update {0} assemblie(s)", assemblies.Count());
var sw = new Stopwatch();
sw.Start();
foreach (var assemblyPath in assemblies)
{
if (!AssemblyHelper.IsManagedAssembly(assemblyPath))
{
continue;
}
string stdOut, stdErr;
var assemblyFullPath = ResolveAssemblyPath(assemblyPath);
var exitCode = RunUpdatingProgram("AssemblyUpdater.exe", "-u -a " + assemblyFullPath + APIVersionArgument() + AssemblySearchPathArgument() + ConfigurationProviderAssembliesPathArgument() + NuGetArgument(), out stdOut, out stdErr);
if (stdOut.Length > 0)
{
APIUpdaterLogger.WriteToFile("Assembly update output ({0})\r\n{1}", assemblyFullPath, stdOut);
}
if (IsWarning(exitCode))
{
APIUpdaterLogger.WriteWarningToConsole(stdOut);
}
if (IsError(exitCode))
{
APIUpdaterLogger.WriteErrorToConsole("Error {0} running AssemblyUpdater. Its output is: `{1}`", exitCode, stdErr);
}
}
APIUpdaterLogger.WriteToFile("Update finished in {0}s", sw.Elapsed.TotalSeconds);
}
public static bool IsReferenceToMissingObsoleteMember(string namespaceName, string className)
{
bool result;
try
{
Type type = APIUpdaterHelper.FindTypeInLoadedAssemblies((Type t) => t.Name == className && t.Namespace == namespaceName && APIUpdaterHelper.IsUpdateable(t));
result = (type != null);
}
catch (ReflectionTypeLoadException ex)
{
throw new Exception(ex.Message + ex.LoaderExceptions.Aggregate("", (string acc, Exception curr) => acc + "\r\n\t" + curr.Message));
}
return(result);
}
internal static bool MayContainUpdatableReferences(string assemblyPath)
{
using (FileStream fileStream = File.Open(assemblyPath, System.IO.FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly((Stream)fileStream);
if (((AssemblyNameReference)assembly.get_Name()).get_IsWindowsRuntime())
{
return(false);
}
if (!APIUpdaterHelper.IsTargetFrameworkValidOnCurrentOS(assembly))
{
return(false);
}
}
return(true);
}
private static Type FindExactTypeMatchingMovedType(string simpleOrQualifiedName)
{
Match match = Regex.Match(simpleOrQualifiedName, "^(?:(?<namespace>.*)(?=\\.)\\.)?(?<typename>[a-zA-Z_0-9]+)$");
Type result;
if (!match.Success)
{
result = null;
}
else
{
string typename = match.Groups["typename"].Value;
string namespaceName = match.Groups["namespace"].Value;
result = APIUpdaterHelper.FindTypeInLoadedAssemblies((Type t) => t.Name == typename && APIUpdaterHelper.NamespaceHasChanged(t, namespaceName));
}
return(result);
}
internal static bool MayContainUpdatableReferences(string assemblyPath)
{
using (FileStream fileStream = File.Open(assemblyPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
AssemblyDefinition assemblyDefinition = AssemblyDefinition.ReadAssembly(fileStream);
if (assemblyDefinition.Name.IsWindowsRuntime)
{
bool result = false;
return(result);
}
if (!APIUpdaterHelper.IsTargetFrameworkValidOnCurrentOS(assemblyDefinition))
{
bool result = false;
return(result);
}
}
return(true);
}
public static bool IsReferenceToTypeWithChangedNamespace(string normalizedErrorMessage)
{
bool result;
try
{
string[] lines = normalizedErrorMessage.Split(new char[]
{
'\n'
});
string valueFromNormalizedMessage = APIUpdaterHelper.GetValueFromNormalizedMessage(lines, "EntityName=");
Type type = APIUpdaterHelper.FindExactTypeMatchingMovedType(valueFromNormalizedMessage) ?? APIUpdaterHelper.FindTypeMatchingMovedTypeBasedOnNamespaceFromError(lines);
result = (type != null);
}
catch (ReflectionTypeLoadException ex)
{
throw new Exception(ex.Message + ex.LoaderExceptions.Aggregate("", (string acc, Exception curr) => acc + "\r\n\t" + curr.Message));
}
return(result);
}
internal static bool MayContainUpdatableReferences(string assemblyPath)
{
bool result;
using (AssemblyDefinition assemblyDefinition = AssemblyDefinition.ReadAssembly(assemblyPath))
{
if (assemblyDefinition.Name.IsWindowsRuntime)
{
result = false;
return(result);
}
if (!APIUpdaterHelper.IsTargetFrameworkValidOnCurrentOS(assemblyDefinition))
{
result = false;
return(result);
}
}
result = true;
return(result);
}
private static string ConfigurationProviderAssembliesPathArgument()
{
StringBuilder stringBuilder = new StringBuilder();
foreach (Unity.DataContract.PackageInfo current in ModuleManager.packageManager.unityExtensions)
{
foreach (string current2 in from f in current.files
where f.Value.type == PackageFileType.Dll
select f into pi
select pi.Key)
{
stringBuilder.AppendFormat(" {0}", CommandLineFormatter.PrepareFileName(Path.Combine(current.basePath, current2)));
}
}
string unityEditorManagedPath = APIUpdaterHelper.GetUnityEditorManagedPath();
stringBuilder.AppendFormat(" {0}", CommandLineFormatter.PrepareFileName(Path.Combine(unityEditorManagedPath, "UnityEngine.dll")));
stringBuilder.AppendFormat(" {0}", CommandLineFormatter.PrepareFileName(Path.Combine(unityEditorManagedPath, "UnityEditor.dll")));
return(stringBuilder.ToString());
}
private static Type FindTypeMatchingMovedTypeBasedOnNamespaceFromError(IEnumerable <string> lines)
{
string valueFromNormalizedMessage = APIUpdaterHelper.GetValueFromNormalizedMessage(lines, "Line=");
int num = (valueFromNormalizedMessage == null) ? -1 : int.Parse(valueFromNormalizedMessage);
valueFromNormalizedMessage = APIUpdaterHelper.GetValueFromNormalizedMessage(lines, "Column=");
int num2 = (valueFromNormalizedMessage == null) ? -1 : int.Parse(valueFromNormalizedMessage);
string valueFromNormalizedMessage2 = APIUpdaterHelper.GetValueFromNormalizedMessage(lines, "Script=");
Type result;
if (num == -1 || num2 == -1 || valueFromNormalizedMessage2 == null)
{
result = null;
}
else
{
try
{
using (FileStream fileStream = File.Open(valueFromNormalizedMessage2, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
IParser parser = ParserFactory.CreateParser(ICSharpCode.NRefactory.SupportedLanguage.CSharp, new StreamReader(fileStream));
parser.Lexer.EvaluateConditionalCompilation = false;
parser.Parse();
string text = InvalidTypeOrNamespaceErrorTypeMapper.IsTypeMovedToNamespaceError(parser.CompilationUnit, num, num2);
if (text == null)
{
result = null;
}
else
{
result = APIUpdaterHelper.FindExactTypeMatchingMovedType(text);
}
}
}
catch (FileNotFoundException)
{
result = null;
}
}
return(result);
}
private static string ConfigurationProviderAssembliesPathArgument()
{
StringBuilder stringBuilder = new StringBuilder();
using (IEnumerator <PackageInfo> enumerator = ModuleManager.packageManager.get_unityExtensions().GetEnumerator())
{
while (((IEnumerator)enumerator).MoveNext())
{
PackageInfo current = enumerator.Current;
foreach (string path2 in ((IEnumerable <KeyValuePair <string, PackageFileData> >)current.get_files()).Where <KeyValuePair <string, PackageFileData> >((Func <KeyValuePair <string, PackageFileData>, bool>)(f => f.Value.type == 3)).Select <KeyValuePair <string, PackageFileData>, string>((Func <KeyValuePair <string, PackageFileData>, string>)(pi => pi.Key)))
{
stringBuilder.AppendFormat(" {0}", (object)CommandLineFormatter.PrepareFileName(Path.Combine((string)current.basePath, path2)));
}
}
}
string editorManagedPath = APIUpdaterHelper.GetUnityEditorManagedPath();
stringBuilder.AppendFormat(" {0}", (object)CommandLineFormatter.PrepareFileName(Path.Combine(editorManagedPath, "UnityEngine.dll")));
stringBuilder.AppendFormat(" {0}", (object)CommandLineFormatter.PrepareFileName(Path.Combine(editorManagedPath, "UnityEditor.dll")));
return(stringBuilder.ToString());
}
public static bool DoesAssemblyRequireUpgrade(string assetFullPath)
{
if (!File.Exists(assetFullPath))
{
return(false);
}
if (!InternalEditorUtility.DetectDotNetDll(assetFullPath))
{
return(false);
}
string text;
string text2;
int num = APIUpdaterHelper.RunUpdatingProgram("AssemblyUpdater.exe", string.Concat(new string[]
{
APIUpdaterHelper.TimeStampArgument(),
APIUpdaterHelper.APIVersionArgument(),
"--check-update-required -a ",
CommandLineFormatter.PrepareFileName(assetFullPath),
APIUpdaterHelper.AssemblySearchPathArgument()
}), out text, out text2);
Console.WriteLine("{0}{1}", text, text2);
switch (num)
{
case 0:
case 1:
return(false);
case 2:
return(true);
default:
UnityEngine.Debug.LogError(text + Environment.NewLine + text2);
return(false);
}
}
public static bool IsReferenceToMissingObsoleteMember(string namespaceName, string className)
{
Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany((Assembly a) => a.GetTypes()).FirstOrDefault((Type t) => t.Name == className && t.Namespace == namespaceName && APIUpdaterHelper.IsUpdateable(t));
return(type != null);
}
public static bool IsReferenceToMissingObsoleteMember(string namespaceName, string className)
{
bool result;
try
{
Type type = AppDomain.CurrentDomain.GetAssemblies().SelectMany((Assembly a) => a.GetTypes()).FirstOrDefault((Type t) => t.Name == className && t.Namespace == namespaceName && APIUpdaterHelper.IsUpdateable(t));
result = (type != null);
}
catch (ReflectionTypeLoadException ex)
{
throw new Exception(ex.Message + ex.LoaderExceptions.Aggregate(string.Empty, (string acc, Exception curr) => acc + "\r\n\t" + curr.Message));
}
return(result);
}
private static bool IsTargetFrameworkValidOnCurrentOS(AssemblyDefinition assembly)
{
if (Environment.OSVersion.Platform != PlatformID.Win32NT)
{
return((!assembly.get_HasCustomAttributes() ? 0 : (((IEnumerable <CustomAttribute>)assembly.get_CustomAttributes()).Any <CustomAttribute>((Func <CustomAttribute, bool>)(attr => APIUpdaterHelper.TargetsWindowsSpecificFramework(attr))) ? 1 : 0)) == 0);
}
return(true);
}
private static string AssemblySearchPathArgument()
{
return(" -s " + CommandLineFormatter.PrepareFileName(APIUpdaterHelper.GetUnityEngineDLLPath()) + ",+" + CommandLineFormatter.PrepareFileName(Application.dataPath));
}
public static bool IsReferenceToTypeWithChangedNamespace(string simpleOrQualifiedName)
{
bool result;
try
{
Match match = Regex.Match(simpleOrQualifiedName, "^(?:(?<namespace>.*)(?=\\.)\\.)?(?<typename>[a-zA-Z_0-9]+)$");
if (!match.Success)
{
result = false;
}
else
{
string typename = match.Groups["typename"].Value;
string namespaceName = match.Groups["namespace"].Value;
Type type = APIUpdaterHelper.FindTypeInLoadedAssemblies((Type t) => t.Name == typename && APIUpdaterHelper.NamespaceHasChanged(t, namespaceName));
result = (type != null);
}
}
catch (ReflectionTypeLoadException ex)
{
throw new Exception(ex.Message + ex.LoaderExceptions.Aggregate("", (string acc, Exception curr) => acc + "\r\n\t" + curr.Message));
}
return(result);
}
private static bool IsTargetFrameworkValidOnCurrentOS(AssemblyDefinition assembly)
{
bool arg_4D_0;
if (Environment.OSVersion.Platform != PlatformID.Win32NT)
{
int arg_48_0;
if (assembly.HasCustomAttributes)
{
arg_48_0 = (assembly.CustomAttributes.Any((CustomAttribute attr) => APIUpdaterHelper.TargetsWindowsSpecificFramework(attr)) ? 1 : 0);
}
else
{
arg_48_0 = 0;
}
arg_4D_0 = (arg_48_0 == 0);
}
else
{
arg_4D_0 = true;
}
return(arg_4D_0);
}
private static Type FindTypeInLoadedAssemblies(Func <Type, bool> predicate)
{
return((from assembly in AppDomain.CurrentDomain.GetAssemblies()
where !APIUpdaterHelper.IsIgnoredAssembly(assembly.GetName())
select assembly).SelectMany((Assembly a) => a.GetTypes()).FirstOrDefault(predicate));
}
public static void Run(string commaSeparatedListOfAssemblies)
{
string[] strArray = commaSeparatedListOfAssemblies.Split(new char[1] {
','
}, StringSplitOptions.RemoveEmptyEntries);
APIUpdaterLogger.WriteToFile("Started to update {0} assemblie(s)", (object)((IEnumerable <string>)strArray).Count <string>());
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
foreach (string str1 in strArray)
{
if (AssemblyHelper.IsManagedAssembly(str1))
{
string str2 = APIUpdaterHelper.ResolveAssemblyPath(str1);
string stdOut;
string stdErr;
int num = APIUpdaterHelper.RunUpdatingProgram("AssemblyUpdater.exe", "-u -a " + str2 + APIUpdaterHelper.APIVersionArgument() + APIUpdaterHelper.AssemblySearchPathArgument() + APIUpdaterHelper.ConfigurationProviderAssembliesPathArgument(), out stdOut, out stdErr);
if (stdOut.Length > 0)
{
APIUpdaterLogger.WriteToFile("Assembly update output ({0})\r\n{1}", (object)str2, (object)stdOut);
}
if (num < 0)
{
APIUpdaterLogger.WriteErrorToConsole("Error {0} running AssemblyUpdater. Its output is: `{1}`", (object)num, (object)stdErr);
}
}
}
APIUpdaterLogger.WriteToFile("Update finished in {0}s", (object)stopwatch.Elapsed.TotalSeconds);
}
public static bool DoesAssemblyRequireUpgrade(string assemblyFullPath)
{
if (!File.Exists(assemblyFullPath) || !AssemblyHelper.IsManagedAssembly(assemblyFullPath) || !APIUpdaterHelper.MayContainUpdatableReferences(assemblyFullPath))
{
return(false);
}
string stdOut;
string stdErr;
int num = APIUpdaterHelper.RunUpdatingProgram("AssemblyUpdater.exe", APIUpdaterHelper.TimeStampArgument() + APIUpdaterHelper.APIVersionArgument() + "--check-update-required -a " + CommandLineFormatter.PrepareFileName(assemblyFullPath) + APIUpdaterHelper.AssemblySearchPathArgument() + APIUpdaterHelper.ConfigurationProviderAssembliesPathArgument(), out stdOut, out stdErr);
Console.WriteLine("{0}{1}", (object)stdOut, (object)stdErr);
switch (num)
{
case 0:
case 1:
return(false);
case 2:
return(true);
default:
UnityEngine.Debug.LogError((object)(stdOut + Environment.NewLine + stdErr));
return(false);
}
}
