public void Sync()
{
this.SetupProjectSupportedExtensions();
if (!AssetPostprocessingInternal.OnPreGeneratingCSProjectFiles())
{
ScriptEditorUtility.ScriptEditor scriptEditorFromPreferences = ScriptEditorUtility.GetScriptEditorFromPreferences();
if (scriptEditorFromPreferences == ScriptEditorUtility.ScriptEditor.SystemDefault || scriptEditorFromPreferences == ScriptEditorUtility.ScriptEditor.Other)
{
return;
}
IEnumerable <MonoIsland> islands = from i in EditorCompilationInterface.GetAllMonoIslands()
where 0 < i._files.Length && i._files.Any((string f) => this.ShouldFileBePartOfSolution(f))
select i;
Dictionary <string, string> allAssetsProjectParts = this.GenerateAllAssetProjectParts();
string[] responseFileDefinesFromFile = ScriptCompilerBase.GetResponseFileDefinesFromFile(MonoCSharpCompiler.ReponseFilename);
this.SyncSolution(islands);
List <MonoIsland> list = SolutionSynchronizer.RelevantIslandsForMode(islands, SolutionSynchronizer.ModeForCurrentExternalEditor()).ToList <MonoIsland>();
foreach (MonoIsland current in list)
{
this.SyncProject(current, allAssetsProjectParts, responseFileDefinesFromFile, list);
}
if (scriptEditorFromPreferences == ScriptEditorUtility.ScriptEditor.VisualStudioCode)
{
this.WriteVSCodeSettingsFiles();
}
}
AssetPostprocessingInternal.CallOnGeneratedCSProjectFiles();
}
private string ProjectHeader(MonoIsland island)
{
string str1 = "4.0";
string str2 = "10.0.20506";
ScriptingLanguage language = SolutionSynchronizer.ScriptingLanguageFor(island);
if (this._settings.VisualStudioVersion == 9)
{
str1 = "3.5";
str2 = "9.0.21022";
}
object[] objArray = new object[9] {
(object)str1, (object)str2, (object)this.ProjectGuid(island._output), (object)this._settings.EngineAssemblyPath, (object)this._settings.EditorAssemblyPath, (object)string.Join(";", ((IEnumerable <string>) new string[2] {
"DEBUG", "TRACE"
}).Concat <string>((IEnumerable <string>) this._settings.Defines).Concat <string>((IEnumerable <string>)island._defines).Distinct <string>().ToArray <string>()), (object)SolutionSynchronizer.MSBuildNamespaceUri, (object)Path.GetFileNameWithoutExtension(island._output), (object)EditorSettings.projectGenerationRootNamespace
};
try
{
return(string.Format(this._settings.GetProjectHeaderTemplate(language), objArray));
}
catch (Exception ex)
{
throw new NotSupportedException("Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " + (object)objArray.Length);
}
}
private string ProjectHeader(MonoIsland island, string[] additionalDefines)
{
string text = "v3.5";
string text2 = "4";
string text3 = "4.0";
string text4 = "10.0.20506";
string text5 = ".";
ScriptingLanguage language = SolutionSynchronizer.ScriptingLanguageFor(island);
if (PlayerSettingsEditor.IsLatestApiCompatibility(island._api_compatibility_level))
{
text = "v4.6";
text2 = "6";
}
else if (ScriptEditorUtility.GetScriptEditorFromPreferences() == ScriptEditorUtility.ScriptEditor.Rider)
{
text = "v4.5";
}
else if (this._settings.VisualStudioVersion == 9)
{
text3 = "3.5";
text4 = "9.0.21022";
}
object[] array = new object[]
{
text3,
text4,
this.ProjectGuid(island._output),
this._settings.EngineAssemblyPath,
this._settings.EditorAssemblyPath,
string.Join(";", new string[]
{
"DEBUG",
"TRACE"
}.Concat(this._settings.Defines).Concat(island._defines).Concat(additionalDefines).Distinct <string>().ToArray <string>()),
SolutionSynchronizer.MSBuildNamespaceUri,
Path.GetFileNameWithoutExtension(island._output),
EditorSettings.projectGenerationRootNamespace,
text,
text2,
text5
};
string result;
try
{
result = string.Format(this._settings.GetProjectHeaderTemplate(language), array);
}
catch (Exception)
{
throw new NotSupportedException("Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " + array.Length);
}
return(result);
}
private static SolutionSynchronizer.Mode ModeForCurrentExternalEditor()
{
if (SolutionSynchronizer.IsSelectedEditorVisualStudio())
{
return(SolutionSynchronizer.Mode.UntiyScriptAsPrecompiledAssembly);
}
if (SolutionSynchronizer.IsSelectedEditorInternalMonoDevelop())
{
return(SolutionSynchronizer.Mode.UnityScriptAsUnityProj);
}
return((!EditorPrefs.GetBool("kExternalEditorSupportsUnityProj", false)) ? SolutionSynchronizer.Mode.UntiyScriptAsPrecompiledAssembly : SolutionSynchronizer.Mode.UnityScriptAsUnityProj);
}
private string GenerateAllAssetProjectPart()
{
StringBuilder stringBuilder = new StringBuilder();
foreach (string allAssetPath in AssetDatabase.GetAllAssetPaths())
{
string extension = Path.GetExtension(allAssetPath);
if (this.IsSupportedExtension(extension) && SolutionSynchronizer.ScriptingLanguageFor(extension) == ScriptingLanguage.None)
{
stringBuilder.AppendFormat(" <None Include=\"{0}\" />{1}", (object)this.EscapedRelativePathFor(allAssetPath), (object)SolutionSynchronizer.WindowsNewline);
}
}
return(stringBuilder.ToString());
}
private string SolutionText(IEnumerable <MonoIsland> islands, SolutionSynchronizer.Mode mode)
{
string str1 = "11.00";
if (this._settings.VisualStudioVersion == 9)
{
str1 = "10.00";
}
IEnumerable <MonoIsland> monoIslands = SolutionSynchronizer.RelevantIslandsForMode(islands, mode);
string projectEntries = this.GetProjectEntries(monoIslands);
string str2 = string.Join(SolutionSynchronizer.WindowsNewline, monoIslands.Select <MonoIsland, string>((Func <MonoIsland, string>)(i => this.GetProjectActiveConfigurations(this.ProjectGuid(i._output)))).ToArray <string>());
return(string.Format(this._settings.SolutionTemplate, (object)str1, (object)projectEntries, (object)str2, (object)this.ReadExistingMonoDevelopSolutionProperties()));
}
private Dictionary <string, string> GenerateAllAssetProjectParts()
{
Dictionary <string, StringBuilder> dictionary = new Dictionary <string, StringBuilder>();
string[] allAssetPaths = AssetDatabase.GetAllAssetPaths();
int i = 0;
while (i < allAssetPaths.Length)
{
string text = allAssetPaths[i];
if (!AssetDatabase.IsPackagedAssetPath(text))
{
goto IL_4B;
}
string text2 = Path.GetFullPath(text).ConvertSeparatorsToUnity();
if (text2.StartsWith(this._projectDirectory))
{
goto IL_4B;
}
IL_FE:
i++;
continue;
IL_4B:
string extension = Path.GetExtension(text);
if (this.IsSupportedExtension(extension) && SolutionSynchronizer.ScriptingLanguageFor(extension) == ScriptingLanguage.None)
{
string text3 = CompilationPipeline.GetAssemblyNameFromScriptPath(text + ".cs");
text3 = (text3 ?? CompilationPipeline.GetAssemblyNameFromScriptPath(text + ".js"));
text3 = (text3 ?? CompilationPipeline.GetAssemblyNameFromScriptPath(text + ".boo"));
text3 = Path.GetFileNameWithoutExtension(text3);
StringBuilder stringBuilder = null;
if (!dictionary.TryGetValue(text3, out stringBuilder))
{
stringBuilder = new StringBuilder();
dictionary[text3] = stringBuilder;
}
stringBuilder.AppendFormat(" <None Include=\"{0}\" />{1}", this.EscapedRelativePathFor(text), SolutionSynchronizer.WindowsNewline);
}
goto IL_FE;
}
Dictionary <string, string> dictionary2 = new Dictionary <string, string>();
foreach (KeyValuePair <string, StringBuilder> current in dictionary)
{
dictionary2[current.Key] = current.Value.ToString();
}
return(dictionary2);
}
private string GenerateAllAssetProjectPart()
{
StringBuilder stringBuilder = new StringBuilder();
string[] allAssetPaths = AssetDatabase.GetAllAssetPaths();
for (int i = 0; i < allAssetPaths.Length; i++)
{
string text = allAssetPaths[i];
string extension = Path.GetExtension(text);
if (this.IsSupportedExtension(extension) && SolutionSynchronizer.ScriptingLanguageFor(extension) == ScriptingLanguage.None)
{
stringBuilder.AppendFormat(" <None Include=\"{0}\" />{1}", this.EscapedRelativePathFor(text), SolutionSynchronizer.WindowsNewline);
}
}
return(stringBuilder.ToString());
}
public void Sync()
{
this.SetupProjectSupportedExtensions();
if (!AssetPostprocessingInternal.OnPreGeneratingCSProjectFiles())
{
IEnumerable <MonoIsland> islands = from i in InternalEditorUtility.GetMonoIslands()
where 0 < i._files.Length
select i;
string otherAssetsProjectPart = this.GenerateAllAssetProjectPart();
this.SyncSolution(islands);
foreach (MonoIsland current in SolutionSynchronizer.RelevantIslandsForMode(islands, SolutionSynchronizer.ModeForCurrentExternalEditor()))
{
this.SyncProject(current, otherAssetsProjectPart);
}
}
AssetPostprocessingInternal.CallOnGeneratedCSProjectFiles();
}
public void Sync()
{
this.SetupProjectSupportedExtensions();
if (AssetPostprocessingInternal.OnPreGeneratingCSProjectFiles())
{
return;
}
IEnumerable <MonoIsland> islands = ((IEnumerable <MonoIsland>)InternalEditorUtility.GetMonoIslands()).Where <MonoIsland>((Func <MonoIsland, bool>)(i => 0 < i._files.Length));
string assetProjectPart = this.GenerateAllAssetProjectPart();
this.SyncSolution(islands);
foreach (MonoIsland island in SolutionSynchronizer.RelevantIslandsForMode(islands, SolutionSynchronizer.ModeForCurrentExternalEditor()))
{
this.SyncProject(island, assetProjectPart);
}
AssetPostprocessingInternal.CallOnGeneratedCSProjectFiles();
}
private string SolutionText(IEnumerable <MonoIsland> islands, SolutionSynchronizer.Mode mode)
{
string text = "11.00";
if (this._settings.VisualStudioVersion == 9)
{
text = "10.00";
}
IEnumerable <MonoIsland> enumerable = SolutionSynchronizer.RelevantIslandsForMode(islands, mode);
string projectEntries = this.GetProjectEntries(enumerable);
string text2 = string.Join(SolutionSynchronizer.WindowsNewline, (from i in enumerable
select this.GetProjectActiveConfigurations(this.ProjectGuid(i._output))).ToArray <string>());
return(string.Format(this._settings.SolutionTemplate, new object[]
{
text,
projectEntries,
text2,
this.ReadExistingMonoDevelopSolutionProperties()
}));
}
private string ProjectHeader(MonoIsland island)
{
string text = "4.0";
string text2 = "10.0.20506";
ScriptingLanguage language = SolutionSynchronizer.ScriptingLanguageFor(island);
if (this._settings.VisualStudioVersion == 9)
{
text = "3.5";
text2 = "9.0.21022";
}
object[] array = new object[]
{
text,
text2,
this.ProjectGuid(island._output),
this._settings.EngineAssemblyPath,
this._settings.EditorAssemblyPath,
string.Join(";", new string[]
{
"DEBUG",
"TRACE"
}.Concat(this._settings.Defines).Concat(island._defines).Distinct <string>().ToArray <string>()),
SolutionSynchronizer.MSBuildNamespaceUri,
Path.GetFileNameWithoutExtension(island._output),
EditorSettings.projectGenerationRootNamespace
};
string result;
try
{
result = string.Format(this._settings.GetProjectHeaderTemplate(language), array);
}
catch (Exception)
{
throw new NotSupportedException("Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " + array.Length);
}
return(result);
}
public void Sync()
{
this.SetupProjectSupportedExtensions();
if (!AssetPostprocessingInternal.OnPreGeneratingCSProjectFiles())
{
IEnumerable <MonoIsland> islands = from i in InternalEditorUtility.GetMonoIslands()
where 0 < i._files.Length
select i;
string otherAssetsProjectPart = this.GenerateAllAssetProjectPart();
string[] responseFileDefinesFromFile = ScriptCompilerBase.GetResponseFileDefinesFromFile(MonoCSharpCompiler.ReponseFilename);
this.SyncSolution(islands);
foreach (MonoIsland current in SolutionSynchronizer.RelevantIslandsForMode(islands, SolutionSynchronizer.ModeForCurrentExternalEditor()))
{
this.SyncProject(current, otherAssetsProjectPart, responseFileDefinesFromFile);
}
if (ScriptEditorUtility.GetScriptEditorFromPreferences() == ScriptEditorUtility.ScriptEditor.VisualStudioCode)
{
this.WriteVSCodeSettingsFiles();
}
}
AssetPostprocessingInternal.CallOnGeneratedCSProjectFiles();
}
private static IEnumerable <MonoIsland> RelevantIslandsForMode(IEnumerable <MonoIsland> islands, SolutionSynchronizer.Mode mode)
{
return(from i in islands
where mode == SolutionSynchronizer.Mode.UnityScriptAsUnityProj || ScriptingLanguage.CSharp == SolutionSynchronizer.ScriptingLanguageFor(i)
select i);
}
private string ProjectText(MonoIsland island, SolutionSynchronizer.Mode mode, string allAssetsProject)
{
StringBuilder stringBuilder = new StringBuilder(this.ProjectHeader(island));
List <string> first = new List <string>();
List <Match> matchList = new List <Match>();
bool isBuildingEditorProject = island._output.EndsWith("-Editor.dll");
foreach (string file1 in island._files)
{
string lower = Path.GetExtension(file1).ToLower();
string file2 = !Path.IsPathRooted(file1) ? Path.Combine(this._projectDirectory, file1) : file1;
if (".dll" != lower)
{
string str = "Compile";
stringBuilder.AppendFormat(" <{0} Include=\"{1}\" />{2}", (object)str, (object)this.EscapedRelativePathFor(file2), (object)SolutionSynchronizer.WindowsNewline);
}
else
{
first.Add(file2);
}
}
stringBuilder.Append(allAssetsProject);
foreach (string str1 in first.Union <string>((IEnumerable <string>)island._references))
{
if (!str1.EndsWith("/UnityEditor.dll") && !str1.EndsWith("/UnityEngine.dll") && (!str1.EndsWith("\\UnityEditor.dll") && !str1.EndsWith("\\UnityEngine.dll")))
{
Match match = SolutionSynchronizer.scriptReferenceExpression.Match(str1);
if (match.Success && (mode == SolutionSynchronizer.Mode.UnityScriptAsUnityProj || (int)Enum.Parse(typeof(ScriptingLanguage), match.Groups["language"].Value, true) == 2))
{
matchList.Add(match);
}
else
{
string str2 = !Path.IsPathRooted(str1) ? Path.Combine(this._projectDirectory, str1) : str1;
if (AssemblyHelper.IsManagedAssembly(str2) && (!AssemblyHelper.IsInternalAssembly(str2) || SolutionSynchronizer.IsInternalAssemblyThatShouldBeReferenced(isBuildingEditorProject, str2)))
{
string path = str2.Replace("\\", "/").Replace("\\\\", "/");
stringBuilder.AppendFormat(" <Reference Include=\"{0}\">{1}", (object)Path.GetFileNameWithoutExtension(path), (object)SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <HintPath>{0}</HintPath>{1}", (object)path, (object)SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" </Reference>{0}", (object)SolutionSynchronizer.WindowsNewline);
}
}
}
}
if (0 < matchList.Count)
{
stringBuilder.AppendLine(" </ItemGroup>");
stringBuilder.AppendLine(" <ItemGroup>");
using (List <Match> .Enumerator enumerator = matchList.GetEnumerator())
{
while (enumerator.MoveNext())
{
Match current = enumerator.Current;
string str = current.Groups["project"].Value;
stringBuilder.AppendFormat(" <ProjectReference Include=\"{0}{1}\">{2}", (object)str, (object)SolutionSynchronizer.GetProjectExtension((ScriptingLanguage)Enum.Parse(typeof(ScriptingLanguage), current.Groups["language"].Value, true)), (object)SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <Project>{{{0}}}</Project>", (object)this.ProjectGuid(Path.Combine("Temp", current.Groups["project"].Value + ".dll")), (object)SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <Name>{0}</Name>", (object)str, (object)SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendLine(" </ProjectReference>");
}
}
}
stringBuilder.Append(this.ProjectFooter(island));
return(stringBuilder.ToString());
}
private void SyncSolution(IEnumerable <MonoIsland> islands)
{
SolutionSynchronizer.SyncFileIfNotChanged(this.SolutionFile(), this.SolutionText(islands, SolutionSynchronizer.ModeForCurrentExternalEditor()));
}
private void SyncProject(MonoIsland island, Dictionary <string, string> allAssetsProjectParts, string[] additionalDefines, List <MonoIsland> allProjectIslands)
{
SolutionSynchronizer.SyncFileIfNotChanged(this.ProjectFile(island), this.ProjectText(island, SolutionSynchronizer.ModeForCurrentExternalEditor(), allAssetsProjectParts, additionalDefines, allProjectIslands));
}
private string SolutionText(IEnumerable<MonoIsland> islands, SolutionSynchronizer.Mode mode)
{
string str1 = "11.00";
if (this._settings.VisualStudioVersion == 9)
str1 = "10.00";
IEnumerable<MonoIsland> monoIslands = SolutionSynchronizer.RelevantIslandsForMode(islands, mode);
string projectEntries = this.GetProjectEntries(monoIslands);
string str2 = string.Join(SolutionSynchronizer.WindowsNewline, monoIslands.Select<MonoIsland, string>((Func<MonoIsland, string>) (i => this.GetProjectActiveConfigurations(this.ProjectGuid(i._output)))).ToArray<string>());
return string.Format(this._settings.SolutionTemplate, (object) str1, (object) projectEntries, (object) str2, (object) this.ReadExistingMonoDevelopSolutionProperties());
}
static SyncVS()
{
SyncVS.Synchronizer = new SolutionSynchronizer(Directory.GetParent(Application.dataPath).FullName, new SyncVS.SolutionSynchronizationSettings());
EditorUserBuildSettings.activeBuildTargetChanged = (Action)Delegate.Combine(EditorUserBuildSettings.activeBuildTargetChanged, new Action(SyncVS.SyncVisualStudioProjectIfItAlreadyExists));
try
{
SyncVS.InstalledVisualStudios = (SyncVS.GetInstalledVisualStudios() as Dictionary<VisualStudioVersion, string>);
}
catch (Exception ex)
{
Console.WriteLine("Error detecting Visual Studio installations: {0}{1}{2}", ex.Message, Environment.NewLine, ex.StackTrace);
SyncVS.InstalledVisualStudios = new Dictionary<VisualStudioVersion, string>();
}
}
private void SyncProject(MonoIsland island, string otherAssetsProjectPart)
{
SolutionSynchronizer.SyncFileIfNotChanged(this.ProjectFile(island), this.ProjectText(island, SolutionSynchronizer.ModeForCurrentExternalEditor(), otherAssetsProjectPart));
}
public static void OnGeneratedCSProjectFiles()
{
if (UnityVSSupport.IsUnityVSEnabled())
{
try
{
string currentDirectory = Directory.GetCurrentDirectory();
string[] files = Directory.GetFiles(currentDirectory, string.Format("*{0}", SolutionSynchronizer.GetProjectExtension(ScriptingLanguage.CSharp)), SearchOption.TopDirectoryOnly);
string[] array = files;
for (int i = 0; i < array.Length; i++)
{
string text = array[i];
string projectFile = text.Substring(currentDirectory.Length + 1);
SolutionPostProcessor.ReplacePathsInProjectFile(projectFile, currentDirectory);
}
}
catch (Exception ex)
{
Debug.LogWarning("Post processing of CS project files failed, reason: " + ex.Message);
}
}
}
private static ScriptingLanguage ScriptingLanguageFor(MonoIsland island)
{
return(SolutionSynchronizer.ScriptingLanguageFor(island.GetExtensionOfSourceFiles()));
}
private void SyncSolution(IEnumerable <MonoIsland> islands)
{
SolutionSynchronizer.SyncFileIfNotChanged(this.SolutionFile(false), this.SolutionText(islands, false));
SolutionSynchronizer.SyncFileIfNotChanged(this.SolutionFile(true), this.SolutionText(islands, true));
}
private void SyncProject(MonoIsland island, string otherAssetsProjectPart)
{
SolutionSynchronizer.SyncFileIfNotChanged(this.ProjectFile(island, false), this.ProjectText(island, false, otherAssetsProjectPart));
SolutionSynchronizer.SyncFileIfNotChanged(this.ProjectFile(island, true), this.ProjectText(island, true, otherAssetsProjectPart));
}
private string ProjectFooter(MonoIsland island)
{
return(string.Format(this._settings.GetProjectFooterTemplate(SolutionSynchronizer.ScriptingLanguageFor(island)), this.ReadExistingMonoDevelopProjectProperties(island)));
}
/// <summary>
/// Callback from AssetPostprocessor which is called after CSProj file(s) are generated.
/// </summary>
public static void OnGeneratedCSProjectFiles()
{
if (!UnityVSSupport.IsUnityVSEnabled())
{
return;
}
try
{
var projectDir = Directory.GetCurrentDirectory();
var projectFiles = Directory.GetFiles(projectDir, string.Format("*{0}", SolutionSynchronizer.GetProjectExtension(ScriptingLanguage.CSharp)), SearchOption.TopDirectoryOnly);
foreach (string projectFile in projectFiles)
{
var file = projectFile.Substring(projectDir.Length + 1);
ReplacePathsInProjectFile(file, projectDir);
}
}
catch (Exception e)
{
UnityEngine.Debug.LogWarning("Post processing of CS project files failed, reason: " + e.Message);
}
}
private string ProjectText(MonoIsland island, SolutionSynchronizer.Mode mode, string allAssetsProject)
{
StringBuilder stringBuilder = new StringBuilder(this.ProjectHeader(island));
List <string> list = new List <string>();
List <Match> list2 = new List <Match>();
string[] files = island._files;
for (int i = 0; i < files.Length; i++)
{
string text = files[i];
string b = Path.GetExtension(text).ToLower();
string text2 = (!Path.IsPathRooted(text)) ? Path.Combine(this._projectDirectory, text) : text;
if (".dll" != b)
{
string arg = "Compile";
stringBuilder.AppendFormat(" <{0} Include=\"{1}\" />{2}", arg, this.EscapedRelativePathFor(text2), SolutionSynchronizer.WindowsNewline);
}
else
{
list.Add(text2);
}
}
stringBuilder.Append(allAssetsProject);
foreach (string current in list.Union(island._references))
{
if (!current.EndsWith("/UnityEditor.dll") && !current.EndsWith("/UnityEngine.dll") && !current.EndsWith("\\UnityEditor.dll") && !current.EndsWith("\\UnityEngine.dll"))
{
Match match = SolutionSynchronizer.scriptReferenceExpression.Match(current);
if (match.Success && (mode == SolutionSynchronizer.Mode.UnityScriptAsUnityProj || (int)Enum.Parse(typeof(ScriptingLanguage), match.Groups["language"].Value, true) == 2))
{
list2.Add(match);
}
else
{
string text3 = (!Path.IsPathRooted(current)) ? Path.Combine(this._projectDirectory, current) : current;
if (AssemblyHelper.IsManagedAssembly(text3))
{
if (!AssemblyHelper.IsInternalAssembly(text3))
{
text3 = text3.Replace("\\", "/");
text3 = text3.Replace("\\\\", "/");
stringBuilder.AppendFormat(" <Reference Include=\"{0}\">{1}", Path.GetFileNameWithoutExtension(text3), SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <HintPath>{0}</HintPath>{1}", text3, SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" </Reference>{0}", SolutionSynchronizer.WindowsNewline);
}
}
}
}
}
if (0 < list2.Count)
{
stringBuilder.AppendLine(" </ItemGroup>");
stringBuilder.AppendLine(" <ItemGroup>");
foreach (Match current2 in list2)
{
string value = current2.Groups["project"].Value;
stringBuilder.AppendFormat(" <ProjectReference Include=\"{0}{1}\">{2}", value, SolutionSynchronizer.GetProjectExtension((ScriptingLanguage)((int)Enum.Parse(typeof(ScriptingLanguage), current2.Groups["language"].Value, true))), SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <Project>{{{0}}}</Project>", this.ProjectGuid(Path.Combine("Temp", current2.Groups["project"].Value + ".dll")), SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <Name>{0}</Name>", value, SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendLine(" </ProjectReference>");
}
}
stringBuilder.Append(this.ProjectFooter(island));
return(stringBuilder.ToString());
}
private string ProjectText(MonoIsland island, SolutionSynchronizer.Mode mode, string allAssetsProject)
{
StringBuilder stringBuilder = new StringBuilder(this.ProjectHeader(island));
List<string> first = new List<string>();
List<Match> matchList = new List<Match>();
bool isBuildingEditorProject = island._output.EndsWith("-Editor.dll");
foreach (string file1 in island._files)
{
string lower = Path.GetExtension(file1).ToLower();
string file2 = !Path.IsPathRooted(file1) ? Path.Combine(this._projectDirectory, file1) : file1;
if (".dll" != lower)
{
string str = "Compile";
stringBuilder.AppendFormat(" <{0} Include=\"{1}\" />{2}", (object) str, (object) this.EscapedRelativePathFor(file2), (object) SolutionSynchronizer.WindowsNewline);
}
else
first.Add(file2);
}
stringBuilder.Append(allAssetsProject);
foreach (string str1 in first.Union<string>((IEnumerable<string>) island._references))
{
if (!str1.EndsWith("/UnityEditor.dll") && !str1.EndsWith("/UnityEngine.dll") && (!str1.EndsWith("\\UnityEditor.dll") && !str1.EndsWith("\\UnityEngine.dll")))
{
Match match = SolutionSynchronizer.scriptReferenceExpression.Match(str1);
if (match.Success && (mode == SolutionSynchronizer.Mode.UnityScriptAsUnityProj || (int) Enum.Parse(typeof (ScriptingLanguage), match.Groups["language"].Value, true) == 2))
{
matchList.Add(match);
}
else
{
string str2 = !Path.IsPathRooted(str1) ? Path.Combine(this._projectDirectory, str1) : str1;
if (AssemblyHelper.IsManagedAssembly(str2) && (!AssemblyHelper.IsInternalAssembly(str2) || SolutionSynchronizer.IsInternalAssemblyThatShouldBeReferenced(isBuildingEditorProject, str2)))
{
string path = str2.Replace("\\", "/").Replace("\\\\", "/");
stringBuilder.AppendFormat(" <Reference Include=\"{0}\">{1}", (object) Path.GetFileNameWithoutExtension(path), (object) SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <HintPath>{0}</HintPath>{1}", (object) path, (object) SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" </Reference>{0}", (object) SolutionSynchronizer.WindowsNewline);
}
}
}
}
if (0 < matchList.Count)
{
stringBuilder.AppendLine(" </ItemGroup>");
stringBuilder.AppendLine(" <ItemGroup>");
using (List<Match>.Enumerator enumerator = matchList.GetEnumerator())
{
while (enumerator.MoveNext())
{
Match current = enumerator.Current;
string str = current.Groups["project"].Value;
stringBuilder.AppendFormat(" <ProjectReference Include=\"{0}{1}\">{2}", (object) str, (object) SolutionSynchronizer.GetProjectExtension((ScriptingLanguage) Enum.Parse(typeof (ScriptingLanguage), current.Groups["language"].Value, true)), (object) SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <Project>{{{0}}}</Project>", (object) this.ProjectGuid(Path.Combine("Temp", current.Groups["project"].Value + ".dll")), (object) SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <Name>{0}</Name>", (object) str, (object) SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendLine(" </ProjectReference>");
}
}
}
stringBuilder.Append(this.ProjectFooter(island));
return stringBuilder.ToString();
}
public string ProjectFile(MonoIsland island)
{
ScriptingLanguage key = SolutionSynchronizer.ScriptingLanguageFor(island);
return(Path.Combine(this._projectDirectory, string.Format("{0}{1}", Path.GetFileNameWithoutExtension(island._output), SolutionSynchronizer.ProjectExtensions[key])));
}
private static IEnumerable<MonoIsland> RelevantIslandsForMode(IEnumerable<MonoIsland> islands, SolutionSynchronizer.Mode mode)
{
// ISSUE: object of a compiler-generated type is created
// ISSUE: reference to a compiler-generated method
return islands.Where<MonoIsland>(new Func<MonoIsland, bool>(new SolutionSynchronizer.\u003CRelevantIslandsForMode\u003Ec__AnonStoreyC3() { mode = mode }.\u003C\u003Em__235));
}
private string ProjectText(MonoIsland island, SolutionSynchronizer.Mode mode, Dictionary <string, string> allAssetsProjectParts, string[] additionalDefines, List <MonoIsland> allProjectIslands)
{
StringBuilder stringBuilder = new StringBuilder(this.ProjectHeader(island, additionalDefines));
List <string> list = new List <string>();
List <Match> list2 = new List <Match>();
bool isBuildingEditorProject = island._output.EndsWith("-Editor.dll");
string[] files = island._files;
for (int j = 0; j < files.Length; j++)
{
string text = files[j];
if (this.ShouldFileBePartOfSolution(text))
{
string b = Path.GetExtension(text).ToLower();
string text2 = (!Path.IsPathRooted(text)) ? Path.Combine(this._projectDirectory, text) : text;
if (".dll" != b)
{
string arg = "Compile";
stringBuilder.AppendFormat(" <{0} Include=\"{1}\" />{2}", arg, this.EscapedRelativePathFor(text2), SolutionSynchronizer.WindowsNewline);
}
else
{
list.Add(text2);
}
}
}
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(island._output);
string value;
if (allAssetsProjectParts.TryGetValue(fileNameWithoutExtension, out value))
{
stringBuilder.Append(value);
}
List <string> list3 = new List <string>();
foreach (string current in list.Union(island._references))
{
if (!current.EndsWith("/UnityEditor.dll") && !current.EndsWith("/UnityEngine.dll") && !current.EndsWith("\\UnityEditor.dll") && !current.EndsWith("\\UnityEngine.dll"))
{
Match match = SolutionSynchronizer.scriptReferenceExpression.Match(current);
if (match.Success)
{
SupportedLanguage languageFromExtension = ScriptCompilers.GetLanguageFromExtension(island.GetExtensionOfSourceFiles());
ScriptingLanguage scriptingLanguage = (ScriptingLanguage)Enum.Parse(typeof(ScriptingLanguage), languageFromExtension.GetLanguageName(), true);
if (mode == SolutionSynchronizer.Mode.UnityScriptAsUnityProj || scriptingLanguage == ScriptingLanguage.CSharp)
{
string dllName = match.Groups["dllname"].Value;
if (allProjectIslands.Any((MonoIsland i) => Path.GetFileName(i._output) == dllName))
{
list2.Add(match);
continue;
}
}
}
string text3 = (!Path.IsPathRooted(current)) ? Path.Combine(this._projectDirectory, current) : current;
if (AssemblyHelper.IsManagedAssembly(text3))
{
if (AssemblyHelper.IsInternalAssembly(text3))
{
if (!SolutionSynchronizer.IsAdditionalInternalAssemblyReference(isBuildingEditorProject, text3))
{
continue;
}
string fileName = Path.GetFileName(text3);
if (list3.Contains(fileName))
{
continue;
}
list3.Add(fileName);
}
text3 = text3.Replace("\\", "/");
text3 = text3.Replace("\\\\", "/");
stringBuilder.AppendFormat(" <Reference Include=\"{0}\">{1}", Path.GetFileNameWithoutExtension(text3), SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <HintPath>{0}</HintPath>{1}", text3, SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" </Reference>{0}", SolutionSynchronizer.WindowsNewline);
}
}
}
if (0 < list2.Count)
{
stringBuilder.AppendLine(" </ItemGroup>");
stringBuilder.AppendLine(" <ItemGroup>");
foreach (Match current2 in list2)
{
EditorBuildRules.TargetAssembly targetAssemblyDetails = EditorCompilationInterface.Instance.GetTargetAssemblyDetails(current2.Groups["dllname"].Value);
ScriptingLanguage language = ScriptingLanguage.None;
if (targetAssemblyDetails != null)
{
language = (ScriptingLanguage)Enum.Parse(typeof(ScriptingLanguage), targetAssemblyDetails.Language.GetLanguageName(), true);
}
string value2 = current2.Groups["project"].Value;
stringBuilder.AppendFormat(" <ProjectReference Include=\"{0}{1}\">{2}", value2, SolutionSynchronizer.GetProjectExtension(language), SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <Project>{{{0}}}</Project>", this.ProjectGuid(Path.Combine("Temp", current2.Groups["project"].Value + ".dll")), SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendFormat(" <Name>{0}</Name>", value2, SolutionSynchronizer.WindowsNewline);
stringBuilder.AppendLine(" </ProjectReference>");
}
}
stringBuilder.Append(this.ProjectFooter(island));
return(stringBuilder.ToString());
}