/// <summary>
/// Traverses the necessary Visual Studio structures to retrieve any and all
/// C++ Preprocessor definitions currently defined.
/// </summary>
/// <returns></returns>
private Defines GetPreprocessorDefines()
{
Defines definesHandler = new Defines();
RegisterAnsiCompliantPredefinedMacros(definesHandler);
// Extract defines from property sheets
foreach (VCPropertySheet sheet in this.PropertySheets)
{
VCCLCompilerTool tool = GetVCppCompilerOptions(sheet.Tools);
if (tool != null)
{
GetPreprocessorDefines(tool, definesHandler);
}
}
// Avoid registering the Microsoft defines if the /u option is specified
if (!this._compiler.UndefineAllPreprocessorDefinitions)
{
RegisterMicrosoftPreDefinedCompilerMacros(definesHandler);
}
// Extract defines from compiler options
GetPreprocessorDefines(this._compiler, definesHandler);
return definesHandler;
}
/**
* Gets value stored at key
* @param key
* @return
*/
public static Object Get(String key)
{
#if NETFX_CORE
StorageSettings iss = Defines.GetStorageSettings();
#else
IsolatedStorageSettings iss = IsolatedStorageSettings.ApplicationSettings;
#endif
String value = "";
if (iss.TryGetValue <String>(key, out value))
{
return(value);
}
else
{
if (iss.Contains(key))
{
return(Convert.ToDouble(iss[key]));
}
else
{
return(null);
}
}
}
public Il2CppOutputProgram(string name) : base(name)
{
Libraries.Add(LibIL2Cpp);
Libraries.Add(BoehmGCProgram);
Sources.Add(Distribution.Path.Combine("external").Combine("xxHash/xxhash.c"));
this.DynamicLinkerSettingsForMsvc()
.Add(l => l.WithSubSystemType(SubSystemType.Console).WithEntryPoint("wWinMainCRTStartup"));
Libraries.Add(c => c.ToolChain.Platform is WindowsPlatform, new SystemLibrary("kernel32.lib"));
Defines.Add(c => c.Platform is WebGLPlatform, "IL2CPP_DISABLE_GC=1");
this.DynamicLinkerSettingsForMsvc().Add(l => l
.WithSubSystemType(SubSystemType.Console)
.WithEntryPoint("wWinMainCRTStartup")
);
Defines.Add(c => c.ToolChain.DynamicLibraryFormat == null, "FORCE_PINVOKE_INTERNAL=1");
this.DynamicLinkerSettingsForEmscripten().Add(c =>
c.WithShellFile(BuildProgram.BeeRoot.Combine("shell.html")));
Libraries.Add(c => c.Platform is WebGLPlatform, new PreJsLibrary(BuildProgram.BeeRoot.Combine("tiny_runtime.js")));
}
/// <summary>
/// Registers the Microsoft specific PreDefined compiler defines
/// </summary>
private static Defines RegisterMicrosoftPreDefinedCompilerMacros(Defines definesHandler)
{
/*
* taken off https://msdn.microsoft.com/en-us/library/b0084kay(v=vs.110).aspx
*
* Only a limited number of pre defined macros is taken off the list present on Microsoft's website. The general philosophy used
* is that the ones selected are those which are always present. i.e. that their presence is not dependent on the compiler settings, processor
* architecture used.
*
*/
definesHandler.Define("__COUNTER__", "");
definesHandler.Define("__cplusplus", "");
definesHandler.Define("__FUNCDNAME__", "");
definesHandler.Define("__FUNCSIG__", "");
definesHandler.Define("__FUNCTION__", "");
definesHandler.Define("_INTEGRAL_MAX_BITS", "");
definesHandler.Define("_MSC_BUILD", "");
definesHandler.Define("_MSC_FULL_VER", "");
definesHandler.Define("_MSC_VER", "");
definesHandler.Define("_WIN32", "");
return(definesHandler);
}
protected IList <string> GenerateReferencedDefines()
{
var result = new List <string>();
foreach (var reference in References)
{
var loadedReference = reference as CPlusPlusProject;
if (loadedReference == null)
{
// What to do in this situation?
throw new NotImplementedException();
}
result.AddRange(loadedReference.GenerateReferencedDefines());
}
foreach (var define in Defines.Where(i => i.Exported && !i.Global))
{
result.Add(define.Value);
}
return(result);
}
/// <summary>
/// Evaluates an expression
/// </summary>
/// <param name="expression">expression to be evaluated</param>
/// <param name="definesHandler">reference to the defines handler </param>
/// <returns></returns>
public EvaluationResult EvaluateExpression(string expression, Defines definesHandler)
{
this._definesHandler = definesHandler;
Expression e = new Expression(expression, EvaluateOptions.NoCache);
e.EvaluateParameter += EvaluateParam;
e.EvaluateFunction += EvaluateFunction;
EvaluationResult evaluationResult = EvaluationResult.UnDetermined;
try
{
object result = e.Evaluate();
evaluationResult = Convert.ToBoolean(result, CultureInfo.InvariantCulture) ? EvaluationResult.IsTrue : EvaluationResult.IsFalse;
}
catch
{
evaluationResult = EvaluationResult.UnDetermined;
}
return(evaluationResult);
}
public Boolean TestWhetherProjectFileBelongs(ProjectFile pf)
{
// TODO: allow relax if some defines are absent in one of sets
if (!CompilerPossiblyRelativePathComparer.Instance.Equals(CompilerInstance.BaseCompiler,
pf.CompilerOfFile.BaseCompiler))
{
return(false);
}
if (OwnerSolution.config.RelaxIncludeDirsOrder)
{
if (!IncludeDirectories.ListIdenticalRelaxOrder(pf.IncludeDirectories))
{
return(false);
}
}
else
{
if (!IncludeDirectories.ListIdentical(pf.IncludeDirectories))
{
return(false);
}
}
if (!Defines.SetEquals(pf.SetOfDefines))
{
return(false);
}
if (!ForcedIncludes.SetEquals(pf.ForceIncludes))
{
return(false);
}
return(true);
}
public void Initialize(Lua.lua_State L)
{
DrawableParser = LGDrawableParser.Instance;
DimensionParser = LGDimensionParser.Instance;
ColorParser = LGColorParser.Instance;
StringParser = LGStringParser.Instance;
List <String> lst = new List <String>();
lst.Add("ld");
MatchStringsStart.Add(lst);
lst = new List <String>();
lst.Add("sw");
MatchStringsStart.Add(lst);
lst = new List <String>();
lst.Add("w");
MatchStringsStart.Add(lst);
lst = new List <String>();
lst.Add("h");
MatchStringsStart.Add(lst);
lst = new List <String>();
lst.Add("small");
lst.Add("normal");
lst.Add("large");
lst.Add("xlarge");
MatchStringsStart.Add(lst);
lst = new List <String>();
lst.Add("port");
lst.Add("land");
MatchStringsStart.Add(lst);
lst = new List <String>();
lst.Add("ldpi");
lst.Add("mdpi");
lst.Add("hdpi");
lst.Add("xhdpi");
lst.Add("nodpi");
MatchStringsStart.Add(lst);
lst = new List <String>();
lst.Add("v");
MatchStringsStart.Add(lst);
lst = new List <String>();
MatchStringsEnd.Add(lst);
lst = new List <String>();
lst.Add("dp");
MatchStringsEnd.Add(lst);
lst = new List <String>();
lst.Add("dp");
MatchStringsEnd.Add(lst);
lst = new List <String>();
lst.Add("dp");
MatchStringsEnd.Add(lst);
lst = new List <String>();
MatchStringsEnd.Add(lst);
lst = new List <String>();
MatchStringsEnd.Add(lst);
lst = new List <String>();
MatchStringsEnd.Add(lst);
lst = new List <String>();
switch (LuaEngine.Instance.GetPrimaryLoad())
{
case LuaEngine.EXTERNAL_DATA:
{
#if NETFX_CORE
StorageFolder internalScriptsFolder = null;
/*String[] scriptRootArr = scriptsRoot.Split('/');
* foreach (String scriptRootPart in scriptRootArr)*/
String uiRoot = LuaEngine.Instance.GetUIRoot().Replace("/", "\\");
internalScriptsFolder = Package.Current.InstalledLocation.GetFolderAsync(uiRoot).AsTask().Synchronize();
IReadOnlyList <StorageFile> files = internalScriptsFolder.GetFilesAsync().AsTask().Synchronize();
String rootPath = ApplicationData.Current.LocalFolder.Path;
StorageFolder rootFolder = ApplicationData.Current.LocalFolder;
StorageFolder scriptsFolder = null;
if (LuaEngine.Instance.GetForceLoad() > 0)
{
try
{
StorageFolder sf = rootFolder.GetFolderAsync(uiRoot).AsTask().Synchronize();
sf.DeleteAsync().AsTask().Synchronize();
}
catch
{
}
scriptsFolder = rootFolder.CreateFolderAsync(uiRoot, CreationCollisionOption.ReplaceExisting).AsTask().Synchronize();
}
else
{
scriptsFolder = rootFolder.CreateFolderAsync(uiRoot, CreationCollisionOption.OpenIfExists).AsTask().Synchronize();
}
foreach (StorageFile fileSF in files)
{
String file = fileSF.Name;
Stream sr = Defines.GetResourceAsset(uiRoot + "/", file);
StorageFile toWrite = scriptsFolder.CreateFileAsync(file, CreationCollisionOption.ReplaceExisting).AsTask().Synchronize();
var toWriteStream = toWrite.OpenTransactedWriteAsync().AsTask().Synchronize();
byte[] buffer = new byte[1024];
int length = 0;
while ((length = sr.Read(buffer, 0, buffer.Length)) > 0)
{
toWriteStream.Stream.WriteAsync(buffer.AsBuffer()).AsTask().Synchronize();
}
toWriteStream.CommitAsync().AsTask().Synchronize();
toWriteStream.Dispose();
}
#endif
} break;
case LuaEngine.INTERNAL_DATA:
case LuaEngine.RESOURCE_DATA:
{
} break;
}
ParseValues(L);
DrawableParser.Initialize(L);
}
/// <summary>
/// Registers the ANSI-Compliant Predefined Macros
/// </summary>
private static void RegisterAnsiCompliantPredefinedMacros(Defines definesHandler)
{
definesHandler.Define("__DATE__", "");
definesHandler.Define("__FILE__", "");
definesHandler.Define("__LINE__", "");
definesHandler.Define("__TIME__", "");
definesHandler.Define("__TIMESTAMP__", "");
}
private void AddRegistrationCode(List <TypeMemo> memos)
{
var autoClassName = $"__UnmanagedPostProcessorOutput__{(uint)AssemblyDefinition.FullName.GetHashCode()}";
var mod = AssemblyDefinition.MainModule;
var classDef = new TypeDefinition("", autoClassName, TypeAttributes.Class, AssemblyDefinition.MainModule.ImportReference(typeof(object)));
classDef.IsBeforeFieldInit = false;
mod.Types.Add(classDef);
var funcDef = new MethodDefinition(".cctor", MethodAttributes.Static | MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, AssemblyDefinition.MainModule.ImportReference(typeof(void)));
funcDef.Body.InitLocals = false;
#if !UNITY_DOTSPLAYER // This will need a different solution
if (!Defines.Contains("UNITY_DOTSPLAYER"))
{
// Needs to run automatically in the player.
var attributeCtor = AssemblyDefinition.MainModule.ImportReference(typeof(UnityEngine.RuntimeInitializeOnLoadMethodAttribute).GetConstructor(Type.EmptyTypes));
funcDef.CustomAttributes.Add(new CustomAttribute(attributeCtor));
}
if (Defines.Contains("UNITY_EDITOR"))
{
// Needs to run automatically in the editor.
var attributeCtor2 = AssemblyDefinition.MainModule.ImportReference(typeof(UnityEditor.InitializeOnLoadMethodAttribute).GetConstructor(Type.EmptyTypes));
funcDef.CustomAttributes.Add(new CustomAttribute(attributeCtor2));
}
#endif
classDef.Methods.Add(funcDef);
var processor = funcDef.Body.GetILProcessor();
var registryType = mod.ImportReference(typeof(SystemBaseRegistry)).Resolve();
var addMethod = mod.ImportReference(registryType.Methods.FirstOrDefault((x) => x.Name == nameof(SystemBaseRegistry.AddUnmanagedSystemType)));
var delegateCtor = mod.ImportReference(registryType.NestedTypes.FirstOrDefault((x) => x.Name == nameof(SystemBaseRegistry.ForwardingFunc)).GetConstructors().FirstOrDefault((x) => x.Parameters.Count == 2));
var genericHashFunc = mod.ImportReference(typeof(BurstRuntime)).Resolve().Methods.FirstOrDefault((x) => x.Name == nameof(BurstRuntime.GetHashCode64) && x.HasGenericParameters);
var typeType = mod.ImportReference(typeof(Type)).Resolve();
var getTypeFromHandle = mod.ImportReference(typeType.Methods.FirstOrDefault((x) => x.Name == "GetTypeFromHandle"));
foreach (var memo in memos)
{
// This craziness is equivalent to typeof(n)
processor.Emit(OpCodes.Ldtoken, memo.m_SystemType);
processor.Emit(OpCodes.Call, getTypeFromHandle);
processor.Emit(OpCodes.Call, mod.ImportReference(genericHashFunc.MakeGenericInstanceMethod(memo.m_SystemType)));
for (int i = 0; i < memo.m_Wrappers.Length; ++i)
{
processor.Emit(OpCodes.Ldnull);
processor.Emit(OpCodes.Ldftn, memo.m_Wrappers[i]);
processor.Emit(OpCodes.Newobj, delegateCtor);
}
processor.Emit(OpCodes.Ldstr, memo.m_SystemType.Name);
processor.Emit(OpCodes.Ldc_I4, memo.m_BurstCompileBits);
processor.Emit(OpCodes.Call, addMethod);
}
processor.Emit(OpCodes.Ret);
}
private void RemoveDefine(object param)
{
Defines.Remove(SelectedDefine);
UpdateCompileString();
}
public void AddDefines(string value)
{
Defines.Add(value);
}
public void FillProjectSpecificMissingInfo(Project project, CppCliMode cliMode, LocalFileSystemDirectory targetDir)
{
if (targetDir != null)
{
PDBFileName = string.Format("{0}{3}{1}.{2}.pdb",
targetDir.AbsolutePath,
project.Module.Name, project.Name,
Path.DirectorySeparatorChar);
}
if (cliMode != CppCliMode.Disabled)
{
// Fixing some settings to support C++/CLI mode
switch (cliMode)
{
case CppCliMode.Enabled:
CompileAsManaged = ManagedCppType.Managed;
break;
case CppCliMode.Pure:
CompileAsManaged = ManagedCppType.Pure;
break;
case CppCliMode.Safe:
CompileAsManaged = ManagedCppType.Safe;
break;
case CppCliMode.OldSyntax:
CompileAsManaged = ManagedCppType.OldSyntax;
break;
}
if (!IsDebugInformationFormatSpecified && suite.ActiveGoal.Has(Suite.DebugGoal.Name))
{
DebugInformationFormat = DebugInformationFormat.ProgramDatabase;
}
MinimalRebuild = false;
SmallerTypeCheck = false;
FloatingPointExceptions = false;
if (project.Type == ProjectType.StaticLibrary)
{
Defines = Defines.Concat(new[] { "_LIB" }).ToArray();
}
}
if (project.EffectiveVersion != null)
{
Defines = Defines.Concat(new[]
{
String.Format("BARI_PROJECT_VERSION=\"{0}\"", project.EffectiveVersion)
}).ToArray();
}
if (project.EffectiveCopyright != null)
{
Defines = Defines.Concat(new[]
{
String.Format("BARI_PROJECT_COPYRIGHT=\"{0}\"", project.EffectiveCopyright)
}).ToArray();
}
}
protected override bool PostProcessImpl(TypeDefinition[] componentSystemTypes)
{
var assemblyDefinition = AssemblyDefinition;
var earlyInitHelpers = assemblyDefinition.MainModule.ImportReference(typeof(EarlyInitHelpers)).CheckedResolve();
var autoClassName = $"__JobReflectionRegistrationOutput__{(uint) assemblyDefinition.FullName.GetHashCode()}";
var classDef = new TypeDefinition("", autoClassName, TypeAttributes.Class, assemblyDefinition.MainModule.ImportReference(typeof(object)));
classDef.IsBeforeFieldInit = false;
classDef.CustomAttributes.Add(new CustomAttribute(AttributeConstructorReferenceFor(typeof(DOTSCompilerGeneratedAttribute), assemblyDefinition.MainModule)));
var funcDef = new MethodDefinition("CreateJobReflectionData", MethodAttributes.Static | MethodAttributes.Public | MethodAttributes.HideBySig, assemblyDefinition.MainModule.ImportReference(typeof(void)));
funcDef.Body.InitLocals = false;
classDef.Methods.Add(funcDef);
var body = funcDef.Body;
var processor = body.GetILProcessor();
bool anythingChanged = false;
var declaredGenerics = new HashSet <string>();
var genericJobs = new List <TypeReference>();
foreach (var attr in assemblyDefinition.CustomAttributes)
{
if (attr.AttributeType.FullName != RegisterGenericJobTypeAttributeName)
{
continue;
}
var openTypeRef = (TypeReference)attr.ConstructorArguments[0].Value;
var openType = assemblyDefinition.MainModule.ImportReference(openTypeRef).Resolve();
if (!openTypeRef.IsGenericInstance || !openType.IsValueType)
{
AddDiagnostic(UserError.DC3001(openType));
continue;
}
TypeReference result = new GenericInstanceType(assemblyDefinition.MainModule.ImportReference(new TypeReference(openType.Namespace, openType.Name, assemblyDefinition.MainModule, openTypeRef.Scope, true)));
foreach (var ga in ((GenericInstanceType)openTypeRef).GenericArguments)
{
((GenericInstanceType)result).GenericArguments.Add(LaunderTypeRef(ga, assemblyDefinition.MainModule));
}
genericJobs.Add(result);
var fn = openType.FullName;
if (!declaredGenerics.Contains(fn))
{
declaredGenerics.Add(fn);
}
}
foreach (var t in assemblyDefinition.MainModule.Types)
{
anythingChanged |= VisitJobStructs(t, processor, body, declaredGenerics);
}
foreach (var t in genericJobs)
{
anythingChanged |= VisitJobStructs(t, processor, body, declaredGenerics);
}
processor.Emit(OpCodes.Ret);
if (anythingChanged)
{
var ctorFuncDef = new MethodDefinition("EarlyInit", MethodAttributes.Static | MethodAttributes.Public | MethodAttributes.HideBySig, assemblyDefinition.MainModule.ImportReference(typeof(void)));
#if !UNITY_DOTSRUNTIME
if (!Defines.Contains("UNITY_DOTSPLAYER") && !Defines.Contains("UNITY_EDITOR"))
{
// Needs to run automatically in the player, but we need to
// exclude this attribute when building for the editor, or
// it will re-run the registration for every enter play mode.
var loadTypeEnumType = assemblyDefinition.MainModule.ImportReference(typeof(UnityEngine.RuntimeInitializeLoadType));
var attributeCtor = assemblyDefinition.MainModule.ImportReference(typeof(UnityEngine.RuntimeInitializeOnLoadMethodAttribute).GetConstructor(new[] { typeof(UnityEngine.RuntimeInitializeLoadType) }));
var attribute = new CustomAttribute(attributeCtor);
attribute.ConstructorArguments.Add(new CustomAttributeArgument(loadTypeEnumType, UnityEngine.RuntimeInitializeLoadType.AfterAssembliesLoaded));
ctorFuncDef.CustomAttributes.Add(attribute);
}
if (Defines.Contains("UNITY_EDITOR"))
{
// Needs to run automatically in the editor.
var attributeCtor2 = assemblyDefinition.MainModule.ImportReference(typeof(UnityEditor.InitializeOnLoadMethodAttribute).GetConstructor(Type.EmptyTypes));
ctorFuncDef.CustomAttributes.Add(new CustomAttribute(attributeCtor2));
}
#endif
ctorFuncDef.Body.InitLocals = false;
var p = ctorFuncDef.Body.GetILProcessor();
p.Emit(OpCodes.Ldnull);
p.Emit(OpCodes.Ldftn, funcDef);
var delegateType = assemblyDefinition.MainModule.ImportReference(earlyInitHelpers.NestedTypes.First(x => x.Name == nameof(EarlyInitHelpers.EarlyInitFunction)));
var delegateCtor = assemblyDefinition.MainModule.ImportReference(delegateType.CheckedResolve().GetConstructors().FirstOrDefault((x) => x.Parameters.Count == 2));
p.Emit(OpCodes.Newobj, delegateCtor);
p.Emit(OpCodes.Call, assemblyDefinition.MainModule.ImportReference(earlyInitHelpers.Methods.First(x => x.Name == nameof(EarlyInitHelpers.AddEarlyInitFunction))));
p.Emit(OpCodes.Ret);
classDef.Methods.Add(ctorFuncDef);
assemblyDefinition.MainModule.Types.Add(classDef);
}
return(anythingChanged);
}
public ManagedTestInfo(Platform platform, ManagedTestVariant type = ManagedTestVariant.None)
{
bool fsharp = type == ManagedTestVariant.FSharp;
Platform = platform;
ManagedTestCount = GetBaseTestCount(fsharp);
Defines.Add("TEST_FRAMEWORK=1");
// There would be a lot of fsharp projects to clone to do them all...
if (fsharp && Platform != Platform.macOSModern)
{
throw new NotImplementedException();
}
if (type == ManagedTestVariant.ManagedExceptions)
{
Defines.Add("NATIVEEXCEPTION");
AdditionalGeneratorArgs = "--nativeexception";
}
switch (platform)
{
case Platform.macOSFull:
Dlldir = "macos-full";
Dllname = "managed-macos-full.dll";
Defines.Add("XAMARIN_MAC=1");
Defines.Add("XAMARIN_MAC_FULL=1");
Abi = "x86_64"; // FIXME: fat XM apps not supported yet
ManagedTestCount += GetMacTestCount();
return;
case Platform.macOSSystem:
Dlldir = "macos-system";
Dllname = "managed-macos-system.dll";
Defines.Add("XAMARIN_MAC=1");
Defines.Add("XAMARIN_MAC_SYSTEM=1");
Abi = "x86_64"; // FIXME: fat XM apps not supported yet
ManagedTestCount += GetMacTestCount();
return;
case Platform.macOSModern:
if (fsharp)
{
Dlldir = "fsharp-macos";
Dllname = "fsharp-macos.dll";
Defines.Add("XAMARIN_FSHARP=1");
}
else
{
Dlldir = "macos-modern";
Dllname = "managed-macos-modern.dll";
Defines.Add("XAMARIN_MAC_MODERN=1");
}
Defines.Add("XAMARIN_MAC=1");
Abi = "x86_64"; // FIXME: fat XM apps not supported yet
ManagedTestCount += GetMacTestCount(fsharp);
return;
case Platform.macOS:
Dlldir = "generic";
Dllname = "managed.dll";
Abi = "i386,x86_64";
return;
case Platform.iOS:
Dlldir = "ios";
Dllname = "managed-ios.dll";
Defines.Add("XAMARIN_IOS=1");
Abi = "armv7,arm64,i386,x86_64";
ManagedTestCount += GetIOSTestCount();
return;
case Platform.tvOS:
Dlldir = "tvos";
Dllname = "managed-tvos.dll";
Defines.Add("XAMARIN_TVOS=1");
Abi = "arm64,x86_64";
ManagedTestCount += GetTVTestCount();
return;
default:
throw new NotImplementedException();
}
}
//Options: Case insensitive; Exact spacing; Dot matches line breaks; ^$ don't match at line breaks; Numbered capture
//
//Match the regex below and capture its match into backreference number 1 «(\r\n?|\n)»
// Match this alternative (attempting the next alternative only if this one fails) «\r\n?»
// Match the carriage return character «\r»
// Match the line feed character «\n?»
// Between zero and one times, as many times as possible, giving back as needed (greedy) «?»
// Or match this alternative (the entire group fails if this one fails to match) «\n»
// Match the line feed character «\n»
#region ISourceFilter
/// <summary>
/// Applies the quoted strings filter action on the supplied sourceCode string
/// </summary>
/// <param name="cppSourceFile">CppSourceFile object containing the source file information</param>
/// <param name="definesHandler">not used for this filter</param>
public void Filter(CppSourceFile cppSourceFile, Defines definesHandler)
{
Utility.Code.Require(cppSourceFile, "cppSourceFile");
cppSourceFile.SourceCode = stringLiteralsRegex.Replace(cppSourceFile.SourceCode, ComputeReplacement);
}
/// <summary>
/// Adds a define item.
/// </summary>
/// <param name="define">to add</param>
public void AddDefine(MatchRecognizeDefineItem define)
{
Defines.Add(define);
}
public AsmDefCSharpProgram(AsmDefDescription asmDefDescription)
: base(asmDefDescription.Directory,
asmDefDescription.IncludedAsmRefs.Select(asmref => asmref.Path.Parent),
deferConstruction: true)
{
AsmDefDescription = asmDefDescription;
var asmDefReferences = AsmDefDescription.References.Select(asmDefDescription1 => BuildProgram.GetOrMakeDotsRuntimeCSharpProgramFor(asmDefDescription1)).ToList();
var isExe = asmDefDescription.DefineConstraints.Contains("UNITY_DOTS_ENTRYPOINT") || asmDefDescription.Name.EndsWith(".Tests");
Construct(asmDefDescription.Name, isExe);
ProjectFile.AdditionalFiles.Add(asmDefDescription.Path);
IncludePlatforms = AsmDefDescription.IncludePlatforms;
ExcludePlatforms = AsmDefDescription.ExcludePlatforms;
Unsafe = AsmDefDescription.AllowUnsafeCode;
References.Add(config =>
{
if (config is DotsRuntimeCSharpProgramConfiguration dotsConfig)
{
if (dotsConfig.TargetFramework == TargetFramework.Tiny)
{
return(asmDefReferences.Where(rp => rp.IsSupportedFor(dotsConfig) && !IncompatibleTinyBCLAsmDefs.Contains(rp.FileName)));
}
else
{
return(asmDefReferences.Where(rp => rp.IsSupportedFor(dotsConfig)));
}
}
//this codepath will be hit for the bindgem invocation
return(asmDefReferences);
});
if (AsmDefDescription.IsTinyRoot || isExe)
{
AsmDefCSharpProgramCustomizer.RunAllAddPlatformImplementationReferences(this);
}
if (BuildProgram.UnityTinyBurst != null)
{
References.Add(BuildProgram.UnityTinyBurst);
}
if (BuildProgram.ZeroJobs != null)
{
References.Add(BuildProgram.ZeroJobs);
}
if (BuildProgram.UnityLowLevel != null)
{
References.Add(BuildProgram.UnityLowLevel);
}
if (BuildProgram.TinyIO != null)
{
References.Add(BuildProgram.TinyIO);
}
// Add in any precompiled references found in the asmdef directory or sub-directory
foreach (var pcr in asmDefDescription.PrecompiledReferences)
{
var files = asmDefDescription.Path.Parent.Files(pcr, true);
if (files.Any())
{
References.Add(files);
}
}
if (IsTestAssembly)
{
var nunitLiteMain = BuildProgram.BeeRoot.Combine("CSharpSupport/NUnitLiteMain.cs");
Sources.Add(nunitLiteMain);
// Setup for IL2CPP
var tinyTestFramework = BuildProgram.BeeRoot.Parent.Combine("TinyTestFramework");
Sources.Add(c => ((DotsRuntimeCSharpProgramConfiguration)c).ScriptingBackend == ScriptingBackend.TinyIl2cpp || ((DotsRuntimeCSharpProgramConfiguration)c).TargetFramework == TargetFramework.Tiny, tinyTestFramework);
Defines.Add(c => ((DotsRuntimeCSharpProgramConfiguration)c).ScriptingBackend == ScriptingBackend.TinyIl2cpp || ((DotsRuntimeCSharpProgramConfiguration)c).TargetFramework == TargetFramework.Tiny, "UNITY_PORTABLE_TEST_RUNNER");
// Setup for dotnet
References.Add(c => ((DotsRuntimeCSharpProgramConfiguration)c).ScriptingBackend == ScriptingBackend.Dotnet && ((DotsRuntimeCSharpProgramConfiguration)c).TargetFramework != TargetFramework.Tiny, BuildProgram.NUnitFramework);
ProjectFile.AddCustomLinkRoot(nunitLiteMain.Parent, "TestRunner");
References.Add(c => ((DotsRuntimeCSharpProgramConfiguration)c).ScriptingBackend == ScriptingBackend.Dotnet && ((DotsRuntimeCSharpProgramConfiguration)c).TargetFramework != TargetFramework.Tiny, BuildProgram.NUnitLite);
// General setup
References.Add(BuildProgram.GetOrMakeDotsRuntimeCSharpProgramFor(AsmDefConfigFile.AsmDefDescriptionFor("Unity.Entities")));
References.Add(BuildProgram.GetOrMakeDotsRuntimeCSharpProgramFor(AsmDefConfigFile.AsmDefDescriptionFor("Unity.Tiny.Core")));
References.Add(BuildProgram.GetOrMakeDotsRuntimeCSharpProgramFor(AsmDefConfigFile.AsmDefDescriptionFor("Unity.Tiny.UnityInstance")));
References.Add(BuildProgram.GetOrMakeDotsRuntimeCSharpProgramFor(AsmDefConfigFile.AsmDefDescriptionFor("Unity.Collections")));
}
else if (IsILPostProcessorAssembly)
{
References.Add(BuildProgram.UnityCompilationPipeline);
References.Add(MonoCecil.Paths);
References.Add(Il2Cpp.Distribution.Path.Combine("build/deploy/net471/Unity.Cecil.Awesome.dll"));
}
}
/// <summary>
/// Registers the Microsoft specific PreDefined compiler defines
/// </summary>
private static Defines RegisterMicrosoftPreDefinedCompilerMacros(Defines definesHandler)
{
/*
* taken off https://msdn.microsoft.com/en-us/library/b0084kay(v=vs.110).aspx
*
* Only a limited number of pre defined macros is taken off the list present on Microsoft's website. The general philosophy used
* is that the ones selected are those which are always present. i.e. that their presence is not dependent on the compiler settings, processor
* architecture used.
*
*/
definesHandler.Define("__COUNTER__", "");
definesHandler.Define("__cplusplus", "");
definesHandler.Define("__FUNCDNAME__", "");
definesHandler.Define("__FUNCSIG__", "");
definesHandler.Define("__FUNCTION__", "");
definesHandler.Define("_INTEGRAL_MAX_BITS", "");
definesHandler.Define("_MSC_BUILD", "");
definesHandler.Define("_MSC_FULL_VER", "");
definesHandler.Define("_MSC_VER", "");
definesHandler.Define("_WIN32", "");
return definesHandler;
}
/////////////////////////////////////////////////////////////////////////
//強制フラグのセット（mReelStartメソッドの前で呼んで下さい。）
/////////////////////////////////////////////////////////////////////////
// flagIndex : 強制フラグ(0:無効/1～DfOHHB_V23_DEF.DEF_FORCE_MAX-1）※下記のワードを参照。
//-----------------------------------------------------------------------
// BB未動作時 ｜ BB作動時 ｜ JAC作動中
//DfOHHB_V23_DEF.DEF_FORCE_HAZURE ：（ﾊｽﾞﾚ） ｜（ﾊｽﾞﾚ） ｜（ﾊｽﾞﾚ）
//DfOHHB_V23_DEF.DEF_FORCE_CHERY ：（ﾁｪﾘｰ） ｜（15枚役）ﾄﾞﾝ・ﾍﾞﾙ・ﾍﾞﾙ ｜（無効）
//FORCE_DfOHHB_V23_DEF.DEF_BELL ：（ﾍﾞﾙ） ｜（ﾍﾞﾙ） ｜（無効）
//DfOHHB_V23_DEF.DEF_FORCE_SUIKA ：（ｽｲｶ） ｜（ｽｲｶ or ﾁｪﾘｰ） ｜（無効）
//DfOHHB_V23_DEF.DEF_FORCE_REPLAY ：（ﾘﾌﾟﾚｲ） ｜（JACIN） ｜（15枚役）ﾘﾌﾟ・ﾘﾌﾟ・ﾘﾌﾟ
//DfOHHB_V23_DEF.DEF_FORCE_REG ：（ﾚｷﾞｭﾗｰﾎﾞｰﾅｽ） ｜（無効） ｜（無効）
//DfOHHB_V23_DEF.DEF_FORCE_BIG ：（ﾋﾞｯｸﾞﾎﾞｰﾅｽ） ｜（無効） ｜（無効）
//DfOHHB_V23_DEF.DEF_FORCE_MAX ： フラグ数
//-----------------------------------------------------------------------
//※無効時は、通常通りmReelStart()がRAMDOMXを参照し処理されます。
//※セットされている強制フラグはDfOHHB_V23_DEF.DEF_FORCE_FLAGという名の場所に保存されます。
//※DfOHHB_V23_DEF.DEF_FORCE_FLAGワークはclaerWork(DfOHHB_V23_DEF.DEF_CLR_AREA_3)でゼロクリアされます。
//-----------------------------------------------------------------------
public static void mSetForceFlag(Defines.ForceYakuFlag flagIndex)
{
Defines.RAM_TRACE("mSetForceFlag:["+Defines.DEF_FORCE_FLAG+"]" + flagIndex);
setWork(Defines.DEF_FORCE_FLAG, (ushort)((int)flagIndex & (Enum.GetNames(typeof(Defines.ForceYakuFlag)).Length - 1)));
}
public void Load(Defines defines, RemoteAgent agent)
{
this.Agent = agent;
TopModule = defines.TopModule;
foreach (var c in defines.Consts)
{
AddType(new DefConst(c));
}
foreach (var e in defines.Enums)
{
AddType(new DefEnum(e));
}
foreach (var b in defines.Beans)
{
AddType(new DefBean(b));
}
foreach (var p in defines.DbTables)
{
AddType(new DefTable(p));
}
foreach (var type in Types.Values)
{
type.AssemblyBase = this;
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("precompile type:{0} begin", type.FullName);
type.PreCompile();
s_logger.Trace("precompile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("precompile type:{0} error", type.FullName);
throw;
}
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("compile type:{0} begin", type.FullName);
type.Compile();
s_logger.Trace("compile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("compile type:{0} error", type.FullName);
s_logger.Error("compile type:{0} error", type.FullName);
throw;
}
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("post compile type:{0} begin", type.FullName);
type.PostCompile();
s_logger.Trace("post compile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("post compile type:{0} error", type.FullName);
s_logger.Error("post compile type:{0} error", type.FullName);
throw;
}
}
}
protected void Construct(string name, bool isExe)
{
FileName = name + (isExe ? ".exe" : ".dll");
Framework.Add(c => ShouldTargetTinyCorlib(c, this), Bee.DotNet.Framework.FrameworkNone);
References.Add(c => ShouldTargetTinyCorlib(c, this), Il2Cpp.TinyCorlib);
Framework.Add(c => !ShouldTargetTinyCorlib(c, this), Bee.DotNet.Framework.Framework471);
References.Add(c => !ShouldTargetTinyCorlib(c, this), new SystemReference("System"));
ProjectFile.Path = DeterminePathForProjectFile();
ProjectFile.ReferenceModeCallback = arg =>
{
// Most projects are AsmDefCSharpProgram. For everything else we'll look up their
// packagestatus by the fact that we know it's in the same package as Unity.Entities.CPlusPlus
// XXX This is not true any more!
//var asmdefDotsProgram = (arg as AsmDefCSharpProgram)?.AsmDefDescription ?? AsmDefConfigFile.AsmDefDescriptionFor("Unity.Entities.CPlusPlus");
return(ProjectFile.ReferenceMode.ByCSProj);
};
LanguageVersion = "7.3";
Defines.Add(
"UNITY_DOTSPLAYER",
"NET_DOTS",
// TODO -- figure out what's gated with this, and if it should have a UNITY_DOTSPLAYER || ...
"UNITY_2018_3_OR_NEWER",
// And these might not make sense for DOTS Runtime anyway beacuse they are UnityEngine/UnityEditor APIs.
// They break the build if we add them.
//"UNITY_2019_1_OR_NEWER",
//"UNITY_2019_2_OR_NEWER",
//"UNITY_2019_3_OR_NEWER",
// TODO -- removing this breaks Burst, it should be using DOTSPLAYER!
"UNITY_ZEROPLAYER"
);
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is WebGLPlatform, "UNITY_WEBGL");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is WindowsPlatform, "UNITY_WINDOWS");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is MacOSXPlatform, "UNITY_MACOSX");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is LinuxPlatform, "UNITY_LINUX");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is IosPlatform, "UNITY_IOS");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is AndroidPlatform, "UNITY_ANDROID");
Defines.Add(c => !((DotsRuntimeCSharpProgramConfiguration)c).MultiThreadedJobs, "UNITY_SINGLETHREADED_JOBS");
CopyReferencesNextToTarget = false;
WarningsAsErrors = false;
//hack, fix this in unity.mathematics
foreach (var sourcePath in AllSourcePaths)
{
if (sourcePath.FileName == "Unity.Mathematics")
{
Sources.Add(sourcePath.Files("*.cs", true)
.Where(f => f.FileName != "math_unity_conversion.cs" && f.FileName != "PropertyAttributes.cs"));
}
else
{
Sources.Add(new CustomProvideFiles(sourcePath));
}
}
foreach (var sourcePath in AllSourcePaths)
{
var cppFolder = sourcePath.Combine("cpp~");
var prejsFolder = sourcePath.Combine("prejs~");
var jsFolder = sourcePath.Combine("js~");
var postjsFolder = sourcePath.Combine("postjs~");
var beeFolder = sourcePath.Combine("bee~");
var includeFolder = cppFolder.Combine("include");
NPath[] cppFiles = Array.Empty <NPath>();
if (cppFolder.DirectoryExists())
{
cppFiles = cppFolder.Files("*.c*", true);
ProjectFile.AdditionalFiles.AddRange(cppFolder.Files(true));
GetOrMakeNativeProgram().Sources.Add(cppFiles);
}
if (prejsFolder.DirectoryExists())
{
var jsFiles = prejsFolder.Files("*.js", true);
ProjectFile.AdditionalFiles.AddRange(prejsFolder.Files(true));
GetOrMakeNativeProgram()
.Libraries.Add(c => c.Platform is WebGLPlatform,
jsFiles.Select(jsFile => new PreJsLibrary(jsFile)));
}
//todo: get rid of having both a regular js and a prejs folder
if (jsFolder.DirectoryExists())
{
var jsFiles = jsFolder.Files("*.js", true);
ProjectFile.AdditionalFiles.AddRange(jsFolder.Files(true));
GetOrMakeNativeProgram()
.Libraries.Add(c => c.Platform is WebGLPlatform,
jsFiles.Select(jsFile => new JavascriptLibrary(jsFile)));
}
if (postjsFolder.DirectoryExists())
{
var jsFiles = postjsFolder.Files("*.js", true);
ProjectFile.AdditionalFiles.AddRange(postjsFolder.Files(true));
GetOrMakeNativeProgram()
.Libraries.Add(c => c.Platform is WebGLPlatform,
jsFiles.Select(jsFile => new PostJsLibrary(jsFile)));
}
if (beeFolder.DirectoryExists())
{
ProjectFile.AdditionalFiles.AddRange(beeFolder.Files("*.cs"));
}
if (includeFolder.DirectoryExists())
{
GetOrMakeNativeProgram().PublicIncludeDirectories.Add(includeFolder);
}
}
SupportFiles.Add(AllSourcePaths.SelectMany(p =>
p.Files()
.Where(f => f.HasExtension("jpg", "png", "wav", "mp3", "jpeg", "mp4", "webm", "ogg", "ttf", "json"))));
Defines.Add(c => c.CodeGen == CSharpCodeGen.Debug || (c as DotsRuntimeCSharpProgramConfiguration)?.DotsConfiguration < DotsConfiguration.Release, "DEBUG");
Defines.Add(c => ((DotsRuntimeCSharpProgramConfiguration)c).EnableUnityCollectionsChecks, "ENABLE_UNITY_COLLECTIONS_CHECKS");
Defines.Add(
c => (c as DotsRuntimeCSharpProgramConfiguration)?.ScriptingBackend == ScriptingBackend.TinyIl2cpp,
"UNITY_DOTSPLAYER_IL2CPP");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.ScriptingBackend == ScriptingBackend.Dotnet, "UNITY_DOTSPLAYER_DOTNET");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Defines ?? new List <string>());
ProjectFile.RedirectMSBuildBuildTargetToBee = true;
ProjectFile.AddCustomLinkRoot(MainSourcePath, ".");
ProjectFile.RootNameSpace = "";
DotsRuntimeCSharpProgramCustomizer.RunAllCustomizersOn(this);
}
/// <summary>
/// Identifies the project's configured preprocessor definitions
/// </summary>
/// <param name="definitions">The preprocessor definitions in use by this project</param>
/// <returns>this</returns>
public FakeProjectBuilder Defines(Defines definitions)
{
this._definitions = definitions;
return(this);
}
private void RemoveDefine()
{
Defines.Remove(SelectedDefine);
Save();
}
/// <summary>
/// Renders the clause in textual representation.
/// </summary>
/// <param name="writer">to output to</param>
public void ToEPL(TextWriter writer)
{
string delimiter;
writer.Write(" match_recognize (");
if (PartitionExpressions.Count > 0)
{
delimiter = "";
writer.Write(" partition by ");
foreach (Expression part in PartitionExpressions)
{
writer.Write(delimiter);
part.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
delimiter = ", ";
}
}
delimiter = "";
writer.Write(" measures ");
foreach (SelectClauseExpression part in Measures)
{
writer.Write(delimiter);
part.ToEPLElement(writer);
delimiter = ", ";
}
if (IsAll)
{
writer.Write(" all matches");
}
if (SkipClause != MatchRecognizeSkipClause.PAST_LAST_ROW)
{
writer.Write(" after match skip " + SkipClause.GetText());
}
writer.Write(" pattern (");
Pattern.WriteEPL(writer);
writer.Write(")");
if ((IntervalClause != null) && (IntervalClause.Expression != null))
{
writer.Write(" interval ");
IntervalClause.Expression.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
if (IntervalClause.IsOrTerminated)
{
writer.Write(" or terminated");
}
}
delimiter = "";
if (!Defines.IsEmpty())
{
writer.Write(" define ");
foreach (MatchRecognizeDefine def in Defines)
{
writer.Write(delimiter);
writer.Write(def.Name);
writer.Write(" as ");
def.Expression.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
delimiter = ", ";
}
}
writer.Write(")");
}
private void RemoveDefine(object param)
{
Defines.Remove(SelectedDefine);
Save();
}
// (/\*(?:.+?)\*/)
//
// Options: Case insensitive; Exact spacing; Dot matches line breaks; ^$ don't match at line breaks; Numbered capture
//
// Match the regex below and capture its match into backreference number 1 «(/\*(?:.+?)\*/)»
// Match the character “/” literally «/»
// Match the character “*” literally «\*»
// Match the regular expression below «(?:.+?)»
// Match any single character «.+?»
// Between one and unlimited times, as few times as possible, expanding as needed (lazy) «+?»
// Match the character “*” literally «\*»
// Match the character “/” literally «/»
#region ISourceFilter
/// <summary>
/// Filters any multiline comments from the source code.
/// </summary>
/// <param name="cppSourceFile">CppSourceFile object containing the source file information</param>
/// <param name="definesHandler">not used for this filter</param>
public void Filter(CppSourceFile cppSourceFile, Defines definesHandler)
{
Utility.Code.Require(cppSourceFile, "cppSourceFile");
cppSourceFile.SourceCode = multiLineCommentRegex.Replace(cppSourceFile.SourceCode, ComputeMultiLineCommentReplacement);
}
public void Load(Defines defines, RemoteAgent agent, GenArgs args)
{
LoadCommon(defines, agent, args);
foreach (var e in defines.Enums)
{
AddType(new DefEnum(e));
}
foreach (var b in defines.Beans)
{
AddType(new DefBean(b));
}
foreach (var p in defines.Protos)
{
AddType(new DefProto(p));
}
foreach (var r in defines.Rpcs)
{
AddType(new DefRpc(r));
}
foreach (var type in Types.Values)
{
type.AssemblyBase = this;
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("precompile type:{0} begin", type.FullName);
type.PreCompile();
s_logger.Trace("precompile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("precompile type:{0} error", type.FullName);
throw;
}
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("compile type:{0} begin", type.FullName);
type.Compile();
s_logger.Trace("compile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("compile type:{0} error", type.FullName);
s_logger.Error("compile type:{0} error", type.FullName);
throw;
}
}
foreach (var type in Types.Values)
{
try
{
s_logger.Trace("post compile type:{0} begin", type.FullName);
type.PostCompile();
s_logger.Trace("post compile type:{0} end", type.FullName);
}
catch (Exception)
{
agent.Error("post compile type:{0} error", type.FullName);
s_logger.Error("post compile type:{0} error", type.FullName);
throw;
}
}
}
protected void Construct(string name, bool isExe)
{
FileName = name + (isExe ? ".exe" : ".dll");
Framework.Add(c => ShouldTargetTinyCorlib(c, this), Bee.DotNet.Framework.FrameworkNone);
References.Add(c => ShouldTargetTinyCorlib(c, this), Il2Cpp.TinyCorlib);
Framework.Add(c => !ShouldTargetTinyCorlib(c, this), Bee.DotNet.Framework.Framework471);
References.Add(c => !ShouldTargetTinyCorlib(c, this), new SystemReference("System"));
ProjectFile.Path = new NPath(FileName).ChangeExtension(".csproj");
ProjectFile.ReferenceModeCallback = arg =>
{
if (arg == Il2Cpp.TinyCorlib)
{
return(ProjectFile.ReferenceMode.ByCSProj);
}
//most projects are AsmDefBasedDotsRuntimeCSharpProgram. The remained are things like ZeroJobs. For them we'll look up their packagestatus by the fact that we know
//it's in the same package as Unity.Entities.CPlusPlus
var asmdefDotsProgram = (arg as AsmDefBasedDotsRuntimeCSharpProgram)?.AsmDefDescription ?? BuildProgramConfigFile.AsmDefDescriptionFor("Unity.Entities.CPlusPlus");
switch (asmdefDotsProgram.PackageSource)
{
case "NoPackage":
case "Embedded":
case "Local":
return(ProjectFile.ReferenceMode.ByCSProj);
default:
return(ProjectFile.ReferenceMode.ByDotNetAssembly);
}
};
LanguageVersion = "7.3";
Defines.Add(
"UNITY_2018_3_OR_NEWER",
"UNITY_DOTSPLAYER",
"UNITY_ZEROPLAYER", //<-- this was used for a while, let's keep it around to not break people's incoming PR's.
"NET_TINY",
"NET_DOTS",
"UNITY_USE_TINYMATH",
"UNITY_BINDGEM"
);
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is WebGLPlatform, "UNITY_WEBGL");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is WindowsPlatform, "UNITY_WINDOWS");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is MacOSXPlatform, "UNITY_MACOSX");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is LinuxPlatform, "UNITY_LINUX");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is IosPlatform, "UNITY_IOS");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.Platform is AndroidPlatform, "UNITY_ANDROID");
CopyReferencesNextToTarget = false;
WarningsAsErrors = false;
//hack, fix this in unity.mathematics
if (SourcePath.FileName == "Unity.Mathematics")
{
Sources.Add(SourcePath.Files("*.cs", true).Where(f => f.FileName != "math_unity_conversion.cs" && f.FileName != "PropertyAttributes.cs"));
}
else
{
var csFilesForDirectory = CSFilesForDirectory(SourcePath).ToList();
if (csFilesForDirectory.Count == 0)
{
csFilesForDirectory.Add(BuildProgram.BeeRoot.Combine("CSharpSupport/PlaceHolderForEmptyProject.cs"));
}
Sources.Add(csFilesForDirectory);
}
var cppFolder = SourcePath.Combine("cpp~");
var prejsFolder = SourcePath.Combine("prejs~");
var jsFolder = SourcePath.Combine("js~");
var postjsFolder = SourcePath.Combine("postjs~");
var beeFolder = SourcePath.Combine("bee~");
var includeFolder = cppFolder.Combine("include");
NPath[] cppFiles = Array.Empty <NPath>();
if (cppFolder.DirectoryExists())
{
cppFiles = cppFolder.Files("*.c*", true);
ProjectFile.AdditionalFiles.AddRange(cppFolder.Files(true));
GetOrMakeNativeProgram().Sources.Add(cppFiles);
}
if (prejsFolder.DirectoryExists())
{
var jsFiles = prejsFolder.Files("*.js", true);
ProjectFile.AdditionalFiles.AddRange(prejsFolder.Files(true));
GetOrMakeNativeProgram().Libraries.Add(jsFiles.Select(jsFile => new PreJsLibrary(jsFile)));
}
//todo: get rid of having both a regular js and a prejs folder
if (jsFolder.DirectoryExists())
{
var jsFiles = jsFolder.Files("*.js", true);
ProjectFile.AdditionalFiles.AddRange(jsFolder.Files(true));
GetOrMakeNativeProgram().Libraries.Add(jsFiles.Select(jsFile => new JavascriptLibrary(jsFile)));
}
if (postjsFolder.DirectoryExists())
{
var jsFiles = postjsFolder.Files("*.js", true);
ProjectFile.AdditionalFiles.AddRange(postjsFolder.Files(true));
GetOrMakeNativeProgram().Libraries.Add(jsFiles.Select(jsFile => new PostJsLibrary(jsFile)));
}
if (beeFolder.DirectoryExists())
{
ProjectFile.AdditionalFiles.AddRange(beeFolder.Files("*.cs"));
}
if (includeFolder.DirectoryExists())
{
GetOrMakeNativeProgram().PublicIncludeDirectories.Add(includeFolder);
}
SupportFiles.Add(SourcePath.Files().Where(f => f.HasExtension("jpg", "png", "wav", "mp3", "jpeg", "mp4", "webm", "ogg")));
Defines.Add(c => c.CodeGen == CSharpCodeGen.Debug, "DEBUG");
Defines.Add(c => ((DotsRuntimeCSharpProgramConfiguration)c).EnableUnityCollectionsChecks, "ENABLE_UNITY_COLLECTIONS_CHECKS");
Defines.Add(
c => (c as DotsRuntimeCSharpProgramConfiguration)?.ScriptingBackend == ScriptingBackend.TinyIl2cpp,
"UNITY_DOTSPLAYER_IL2CPP");
Defines.Add(c => (c as DotsRuntimeCSharpProgramConfiguration)?.ScriptingBackend == ScriptingBackend.Dotnet, "UNITY_DOTSPLAYER_DOTNET");
ProjectFile.RedirectMSBuildBuildTargetToBee = true;
ProjectFile.AddCustomLinkRoot(SourcePath, ".");
ProjectFile.RootNameSpace = "";
DotsRuntimeCSharpProgramCustomizer.RunAllCustomizersOn(this);
}
private void AddDefine(object param)
{
Defines.Add(DefineText);
DefineText = string.Empty;
UpdateCompileString();
}
public override bool Execute()
{
int buildId;
try {
dynamic buildEngine = BuildEngine.AccessPrivate();
var host = buildEngine.host;
dynamic pHost = new AccessPrivateWrapper(host);
var bp = pHost.buildParameters;
dynamic pBp = new AccessPrivateWrapper(bp);
buildId = pBp.buildId;
lock (typeof(InvokeBuild)) {
if (buildId <= MaxBuildId)
{
// this happens when we build a solution, and it wants to build each project
return(true);
}
MaxBuildId = buildId;
}
}
catch {
}
using (new PushDirectory(Environment.CurrentDirectory)) {
try {
if (Location.Is())
{
Environment.CurrentDirectory = Location.GetFullPath();
}
if (string.IsNullOrWhiteSpace(ScriptFile))
{
// search for it.
ScriptFile = new[] {
@"copkg\.buildinfo", @"contrib\.buildinfo", @"contrib\coapp\.buildinfo", @".buildinfo"
}.WalkUpPaths();
if (string.IsNullOrEmpty(ScriptFile))
{
throw new ClrPlusException(@"Unable to find .buildinfo file anywhere in the current directory structure.");
}
}
if (!File.Exists(ScriptFile))
{
throw new ClrPlusException(@"Unable to find Invoke-build script file '{0}'.".format(ScriptFile));
}
string[] defines = Defines.IsNullOrEmpty() ? new string[0] : Defines.Select(each => each.ItemSpec).ToArray();
using (var buildScript = new BuildScript(ScriptFile)) {
buildScript.BuildMessage += message => {
try {
switch (message.EventType)
{
case "BuildWarning":
Log.LogWarning(message.Subcategory, message.Code, message.HelpKeyword, message.File, message.LineNumber, message.ColumnNumber, message.EndLineNumber, message.EndColumnNumber, message.Message);
break;
case "BuildError":
Log.LogError(message.Subcategory, message.Code, message.HelpKeyword, message.File, message.LineNumber, message.ColumnNumber, message.EndLineNumber, message.EndColumnNumber, message.Message);
break;
case "ProjectStarted":
Log.LogExternalProjectStarted(message.Message, message.HelpKeyword, message.ProjectFile, message.TargetNames);
break;
case "ProjectFinished":
Log.LogExternalProjectFinished(message.Message, message.HelpKeyword, message.ProjectFile, message.Succeeded);
break;
case "TaskStarted":
Log.LogMessage(MessageImportance.Low, message.Message);
break;
case "TaskFinished":
Log.LogMessage(MessageImportance.Low, message.Message);
break;
case "TargetStarted":
Log.LogMessage(MessageImportance.Low, message.Message);
break;
case "TargetFinished":
Log.LogMessage(MessageImportance.Low, message.Message);
break;
case "BuildStarted":
Log.LogMessage(MessageImportance.Low, message.Message);
break;
case "BuildFinished":
Log.LogMessage(MessageImportance.Low, message.Message);
break;
case "BuildMessage":
Log.LogMessage((MessageImportance)message.Importance, message.Message);
break;
default:
Log.LogMessage(MessageImportance.Low, message.Message);
break;
}
}
catch (Exception e) {
LogError("{0}/{1}/{2}", e.GetType().Name, e.Message, e.StackTrace);
}
return(false);
};
foreach (var i in defines)
{
var p = i.IndexOf("=");
var k = p > -1 ? i.Substring(0, p) : i;
var v = p > -1 ? i.Substring(p + 1) : "";
buildScript.AddMacro(k, v);
}
var targets = Targets.IsNullOrEmpty() ? new string[0] : Targets.Select(each => each.ItemSpec).ToArray();
if (Targets.IsNullOrEmpty())
{
targets = new string[] {
"default"
};
}
Environment.SetEnvironmentVariable("MaxThreads", "" + MaxThreads);
Environment.SetEnvironmentVariable("HIDE_THREADS", "true");
buildScript.MaxThreads = MaxThreads;
return(buildScript.Execute(targets));
}
} catch (Exception e) {
LogError("{0}/{1}/{2}".format(e.GetType().Name, e.Message, e.StackTrace));
return(false);
} finally {
Environment.SetEnvironmentVariable("HIDE_THREADS", null);
Environment.SetEnvironmentVariable("MaxThreads", null);
}
}
}
public CompileSettingsFormViewModel(IProject project) : base("Compiler", project)
{
settings = project.GetToolchainSettings <GccToolchainSettings>().CompileSettings;
defines = new ObservableCollection <string>(settings.Defines);
includePaths = new ObservableCollection <string>(settings.Includes);
miscOptions = settings.CustomFlags;
optimizationLevelSelectedIndex = (int)settings.Optimization;
cppLanguageStandardSelectedIndex = (int)settings.CppLanguageStandard;
clanguageStandardSelectedIndex = (int)settings.CLanguageStandard;
fpuSelectedIndex = (int)settings.Fpu;
debugSymbols = settings.DebugInformation;
rtti = settings.Rtti;
exceptions = settings.Exceptions;
AddDefineCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.DefineText, define => !string.IsNullOrEmpty(define) && !Defines.Contains(define)));
AddDefineCommand.Subscribe(AddDefine);
RemoveDefineCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.SelectedDefine, selected => !string.IsNullOrEmpty(selected)));
RemoveDefineCommand.Subscribe(RemoveDefine);
AddIncludePathCommand = ReactiveCommand.Create();
AddIncludePathCommand.Subscribe(AddIncludePath);
RemoveIncludePathCommand = ReactiveCommand.Create();
RemoveIncludePathCommand.Subscribe(RemoveIncludePath);
UpdateCompileString();
}
public void DisableExceptions()
{
Defines.Add("_HAS_EXCEPTIONS=0");
Options.Add(Sharpmake.Options.Vc.Compiler.Exceptions.Disable);
}
public override bool Execute()
{
if ((_sources == null) || (_sources.Length == 0))
{
Log.LogError("No source files were specified");
return(false);
}
for (int i = 0; i < _sources.Length; i++)
{
ITaskItem source = _sources[i];
if (File.Exists(source.ItemSpec) == false)
{
Log.LogError("'" + source.ItemSpec + "' was not found.");
_hasErrors = true;
}
}
if (_hasErrors)
{
return(false);
}
if (String.IsNullOrEmpty(Defines) == false)
{
_preprocessorVariables = Defines.Split(',', ';', ' ');
}
Log.LogMessage(MessageImportance.Low,
String.Format("Parameters: Debug={0}, Minimize={1}, StripCommentsOnly={2}, WindowsLineBreaks={3}\r\n Defines={4}",
Debug, Minimize, StripCommentsOnly, WindowsLineBreaks, Defines));
ArrayList scripts = new ArrayList(_sources.Length);
for (int i = 0; i < _sources.Length; i++)
{
ITaskItem source = _sources[i];
string sourcePath = source.ItemSpec;
string outputPath = null;
BuildType type = BuildType.Unknown;
string extension = Path.GetExtension(sourcePath);
if (String.Compare(extension, ".jsa", StringComparison.OrdinalIgnoreCase) == 0)
{
type = BuildType.ScriptAssembly;
}
else if (String.Compare(extension, ".jsx", StringComparison.OrdinalIgnoreCase) == 0)
{
type = BuildType.ExtendedScript;
}
else if (String.Compare(extension, ".js", StringComparison.OrdinalIgnoreCase) == 0)
{
type = BuildType.StandardScript;
}
else
{
Log.LogError("'" + sourcePath + "' is an unknown file type.");
_hasErrors = true;
}
if (type != BuildType.Unknown)
{
Log.LogMessage(MessageImportance.Low, "Building '" + sourcePath + "'");
if (type == BuildType.StandardScript)
{
outputPath = CopyStandardScriptFile(sourcePath);
}
else
{
outputPath = ConvertScriptFile(type, sourcePath);
}
if (String.IsNullOrEmpty(outputPath) == false)
{
scripts.Add(new TaskItem(outputPath));
}
else
{
_hasErrors = true;
}
}
}
if (_hasErrors == false)
{
_scripts = (ITaskItem[])scripts.ToArray(typeof(ITaskItem));
return(true);
}
return(false);
}
/// <summary>
/// Populates the provided definesHandler with the preprocessor defines available within the compiler argument
/// </summary>
/// <param name="compiler">The base Visual Studio C++ compiler configuration</param>
/// <param name="definesHandler">The target structure which will host the extracted preprocessor definitions</param>
private static void GetPreprocessorDefines(VCCLCompilerTool compiler, Defines definesHandler)
{
string definitions = compiler.PreprocessorDefinitions.Trim();
string undefinitions = compiler.UndefinePreprocessorDefinitions.Trim();
if (definitions.Length > 0)
{
string[] preProcessorDefinesArray = definitions.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string preProcessorDefine in preProcessorDefinesArray)
{
// the below code is to support valued defines as per https://msdn.microsoft.com/en-us/library/vstudio/hhzbb5c8%28v=vs.100%29.aspx
Match matchResult = RegexPreProcesserDefines.Match(preProcessorDefine);
if (matchResult.Success)
{
definesHandler.Define(matchResult.Groups[1].Value.Trim(), matchResult.Groups[2].Value);
}
else
{
if (!preProcessorDefine.Contains("$(INHERIT)"))
{
definesHandler.Define(preProcessorDefine.Trim(), "1");
//by default user assigned pre-processor defines have a value of 1
}
}
}
}
if (undefinitions.Length > 0)
{
string[] preProcessorUnDefinesArray = undefinitions.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var preProcessorUnDefine in preProcessorUnDefinesArray)
{
if (!preProcessorUnDefine.Contains("$(NOINHERIT)"))
{
definesHandler.UnDefine(preProcessorUnDefine.Trim());
}
}
}
}
