string GetMonoBundleDirName() { if (!string.IsNullOrEmpty(ExtraArguments)) { var args = ProcessArgumentBuilder.Parse(ExtraArguments); for (int i = 0; i < args.Length; i++) { string arg; if (string.IsNullOrEmpty(args[i])) { continue; } if (args[i][0] == '/') { arg = args[i].Substring(1); } else if (args[i][0] == '-') { if (args[i].Length >= 2 && args[i][1] == '-') { arg = args[i].Substring(2); } else { arg = args[i].Substring(1); } } else { continue; } if (arg.StartsWith("custom_bundle_name:", StringComparison.Ordinal) || arg.StartsWith("custom_bundle_name=", StringComparison.Ordinal)) { return(arg.Substring("custom_bundle_name=".Length)); } if (arg == "custom_bundle_name" && i + 1 < args.Length) { return(args[i + 1]); } } } return("MonoBundle"); }
void AppendExtraArgs(ProcessArgumentBuilder args, string extraArgs) { var target = this.MainAssembly.ItemSpec; string[] argv = ProcessArgumentBuilder.Parse(extraArgs); var customTags = new Dictionary <string, string> (StringComparer.OrdinalIgnoreCase) { { "projectdir", Path.GetDirectoryName(this.ProjectPath) }, // Apparently msbuild doesn't propagate the solution path, so we can't get it. - MTouchTaskBase.cs // { "solutiondir", proj.ParentSolution != null ? proj.ParentSolution.BaseDirectory : proj.BaseDirectory }, { "appbundledir", this.AppBundleDir }, { "targetpath", Path.Combine(Path.GetDirectoryName(target), Path.GetFileName(target)) }, { "targetdir", Path.GetDirectoryName(target) }, { "targetname", Path.GetFileName(target) }, { "targetext", Path.GetExtension(target) }, }; for (int i = 0; i < argv.Length; i++) { args.AddQuoted(StringParserService.Parse(argv[i], customTags)); } }
protected override string GenerateCommandLineCommands() { var args = new ProcessArgumentBuilder(); TargetArchitecture architectures; bool msym; if (string.IsNullOrEmpty(Architectures) || !Enum.TryParse(Architectures, out architectures)) { architectures = TargetArchitecture.Default; } if (architectures == TargetArchitecture.ARMv6) { Log.LogError("Target architecture ARMv6 is no longer supported in Xamarin.iOS. Please select a supported architecture."); return(null); } if (IsClassic && minimumOSVersion < IPhoneSdkVersion.V3_1 && architectures.HasFlag(TargetArchitecture.ARMv7)) { Log.LogWarning(null, null, null, AppManifest.ItemSpec, 0, 0, 0, 0, "Deployment Target changed from iOS {0} to iOS 3.1 (minimum requirement for ARMv7)", minimumOSVersion); minimumOSVersion = IPhoneSdkVersion.V3_1; } if (!string.IsNullOrEmpty(IntermediateOutputPath)) { Directory.CreateDirectory(IntermediateOutputPath); args.Add("--cache"); args.AddQuoted(Path.GetFullPath(IntermediateOutputPath)); } if (IsClassic || IPhoneSdks.MonoTouch.Version < new IPhoneSdkVersion(8, 5, 0)) { args.Add("--nomanifest"); args.Add("--nosign"); } args.Add(SdkIsSimulator ? "--sim" : "--dev"); args.AddQuoted(Path.GetFullPath(AppBundleDir)); if (AppleSdkSettings.XcodeVersion.Major >= 5 && IPhoneSdks.MonoTouch.Version.CompareTo(new IPhoneSdkVersion(6, 3, 7)) < 0) { args.Add("--compiler", "clang"); } args.Add("--executable"); args.AddQuoted(ExecutableName); if (IsAppExtension) { args.Add("--extension"); } if (Debug) { if (FastDev && IPhoneSdks.MonoTouch.SupportsFastDev) { args.Add("--fastdev"); } args.Add("--debug"); } if (Profiling) { args.Add("--profiling"); } if (LinkerDumpDependencies) { args.Add("--linkerdumpdependencies"); } switch (LinkMode.ToLowerInvariant()) { case "sdkonly": args.Add("--linksdkonly"); break; case "none": args.Add("--nolink"); break; } if (!string.IsNullOrEmpty(I18n)) { args.Add("--i18n"); args.AddQuotedFormat(I18n); } args.Add("--sdkroot"); args.AddQuoted(SdkRoot); args.Add("--sdk"); args.AddQuoted(SdkVersion); if (!minimumOSVersion.IsUseDefault) { args.Add("--targetver"); args.AddQuoted(minimumOSVersion.ToString()); } if (UseFloat32 /* We want to compile 32-bit floating point code to use 32-bit floating point operations */) { args.Add("--aot-options=-O=float32"); } if (IPhoneSdks.MonoTouch.SupportsGenericValueTypeSharing) { if (!EnableGenericValueTypeSharing) { args.Add("--gsharedvt=false"); } } if (LinkDescriptions != null) { foreach (var desc in LinkDescriptions) { args.AddQuoted(string.Format("--xml={0}", desc.ItemSpec)); } } if (EnableBitcode) { switch (Framework) { case PlatformFramework.WatchOS: args.Add("--bitcode=full"); break; case PlatformFramework.TVOS: args.Add("--bitcode=asmonly"); break; default: throw new InvalidOperationException(string.Format("Bitcode is currently not supported on {0}.", Framework)); } } if (!string.IsNullOrEmpty(HttpClientHandler)) { args.Add(string.Format("--http-message-handler={0}", HttpClientHandler)); } if (!string.IsNullOrEmpty(TLSProvider)) { args.Add(string.Format("--tls-provider={0}", TLSProvider.ToLowerInvariant())); } string thumb = UseThumb && UseLlvm ? "+thumb2" : ""; string llvm = UseLlvm ? "+llvm" : ""; string abi = ""; if (SdkIsSimulator) { if (architectures.HasFlag(TargetArchitecture.i386)) { abi += (abi.Length > 0 ? "," : "") + "i386"; } if (architectures.HasFlag(TargetArchitecture.x86_64)) { abi += (abi.Length > 0 ? "," : "") + "x86_64"; } if (string.IsNullOrEmpty(abi)) { architectures = TargetArchitecture.i386; abi = "i386"; } } else { if (architectures == TargetArchitecture.Default) { architectures = TargetArchitecture.ARMv7; } if (architectures.HasFlag(TargetArchitecture.ARMv7)) { abi += (abi.Length > 0 ? "," : "") + "armv7" + llvm + thumb; } if (architectures.HasFlag(TargetArchitecture.ARMv7s)) { abi += (abi.Length > 0 ? "," : "") + "armv7s" + llvm + thumb; } if (architectures.HasFlag(TargetArchitecture.ARM64)) { // Note: ARM64 does not have thumb. abi += (abi.Length > 0 ? "," : "") + "arm64" + llvm; } if (architectures.HasFlag(TargetArchitecture.ARMv7k)) { abi += (abi.Length > 0 ? "," : "") + "armv7k" + llvm; } if (string.IsNullOrEmpty(abi)) { abi = "armv7" + llvm + thumb; } } // Output the CompiledArchitectures CompiledArchitectures = architectures.ToString(); args.Add("--abi=" + abi); // output symbols to preserve when stripping args.Add("--symbollist"); args.AddQuoted(Path.GetFullPath(SymbolsList)); // don't have mtouch generate the dsyms... args.Add("--dsym=no"); if (!string.IsNullOrEmpty(ArchiveSymbols) && bool.TryParse(ArchiveSymbols.Trim(), out msym)) { args.Add("--msym=" + (msym ? "yes" : "no")); } var gcc = new GccOptions(); if (!string.IsNullOrEmpty(ExtraArgs)) { var extraArgs = ProcessArgumentBuilder.Parse(ExtraArgs); var target = MainAssembly.ItemSpec; string projectDir; if (ProjectDir.StartsWith("~/", StringComparison.Ordinal)) { // Note: Since the Visual Studio plugin doesn't know the user's home directory on the Mac build host, // it simply uses paths relative to "~/". Expand these paths to their full path equivalents. var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); projectDir = Path.Combine(home, ProjectDir.Substring(2)); } else { projectDir = ProjectDir; } var customTags = new Dictionary <string, string> (StringComparer.OrdinalIgnoreCase) { { "projectdir", projectDir }, // Apparently msbuild doesn't propagate the solution path, so we can't get it. // { "solutiondir", proj.ParentSolution != null ? proj.ParentSolution.BaseDirectory : proj.BaseDirectory }, { "appbundledir", AppBundleDir }, { "targetpath", Path.Combine(Path.GetDirectoryName(target), Path.GetFileName(target)) }, { "targetdir", Path.GetDirectoryName(target) }, { "targetname", Path.GetFileName(target) }, { "targetext", Path.GetExtension(target) }, }; for (int i = 0; i < extraArgs.Length; i++) { if (extraArgs[i] == "-gcc_flags" || extraArgs[i] == "--gcc_flags") { // user-defined -gcc_flags argument if (i + 1 < extraArgs.Length && !string.IsNullOrEmpty(extraArgs[i + 1])) { var gccArgs = ProcessArgumentBuilder.Parse(extraArgs[i + 1]); for (int j = 0; j < gccArgs.Length; j++) { gcc.Arguments.Add(StringParserService.Parse(gccArgs[j], customTags)); } } i++; } else { // other user-defined mtouch arguments args.AddQuoted(StringParserService.Parse(extraArgs[i], customTags)); } } } BuildNativeReferenceFlags(gcc); BuildEntitlementFlags(gcc); foreach (var framework in gcc.Frameworks) { args.Add("-framework"); args.AddQuoted(framework); } foreach (var framework in gcc.WeakFrameworks) { args.Add("-weak-framework"); args.AddQuoted(framework); } if (gcc.Cxx) { args.Add("--cxx"); } if (gcc.Arguments.Length > 0) { args.Add("--gcc_flags"); args.AddQuoted(gcc.Arguments.ToString()); } foreach (var asm in References) { args.Add("-r"); if (IsFrameworkItem(asm)) { args.AddQuoted(ResolveFrameworkFile(asm.ItemSpec)); } else { args.AddQuoted(Path.GetFullPath(asm.ItemSpec)); } } foreach (var ext in AppExtensionReferences) { args.Add("--app-extension"); args.AddQuoted(Path.GetFullPath(ext.ItemSpec)); } args.Add("--target-framework"); args.Add(TargetFrameworkIdentifier + "," + TargetFrameworkVersion); args.AddQuoted(MainAssembly.ItemSpec); // We give the priority to the ExtraArgs to set the mtouch verbosity. if (string.IsNullOrEmpty(ExtraArgs) || (!string.IsNullOrEmpty(ExtraArgs) && !ExtraArgs.Contains("-q") && !ExtraArgs.Contains("-v"))) { args.Add(GetVerbosityLevel(Verbosity)); } if (!string.IsNullOrWhiteSpace(License)) { args.Add(string.Format("--license={0}", License)); } return(args.ToString()); }
void BuildNativeReferenceFlags(GccOptions gcc) { if (NativeReferences == null) { return; } foreach (var item in NativeReferences) { var value = item.GetMetadata("Kind"); NativeReferenceKind kind; bool boolean; if (string.IsNullOrEmpty(value) || !Enum.TryParse(value, out kind)) { Log.LogWarning("Unknown native reference type for '{0}'.", item.ItemSpec); continue; } if (kind == NativeReferenceKind.Static) { var libName = Path.GetFileName(item.ItemSpec); if (libName.EndsWith(".a", StringComparison.Ordinal)) { libName = libName.Substring(0, libName.Length - 2); } if (libName.StartsWith("lib", StringComparison.Ordinal)) { libName = libName.Substring(3); } if (!string.IsNullOrEmpty(Path.GetDirectoryName(item.ItemSpec))) { gcc.Arguments.AddQuoted("-L" + Path.GetDirectoryName(item.ItemSpec)); } gcc.Arguments.AddQuoted("-l" + libName); value = item.GetMetadata("ForceLoad"); if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out boolean) && boolean) { gcc.Arguments.Add("-force_load"); gcc.Arguments.AddQuoted(item.ItemSpec); } value = item.GetMetadata("IsCxx"); if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out boolean) && boolean) { gcc.Cxx = true; } } else if (kind == NativeReferenceKind.Framework) { gcc.Frameworks.Add(item.ItemSpec); } else { Log.LogWarning("Dynamic native references are not supported: '{0}'", item.ItemSpec); continue; } value = item.GetMetadata("NeedsGccExceptionHandling"); if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out boolean) && boolean) { if (!gcc.Arguments.Contains("-lgcc_eh")) { gcc.Arguments.Add("-lgcc_eh"); } } value = item.GetMetadata("WeakFrameworks"); if (!string.IsNullOrEmpty(value)) { foreach (var framework in value.Split(' ', '\t')) { gcc.WeakFrameworks.Add(framework); } } value = item.GetMetadata("Frameworks"); if (!string.IsNullOrEmpty(value)) { foreach (var framework in value.Split(' ', '\t')) { gcc.Frameworks.Add(framework); } } // Note: these get merged into gccArgs by our caller value = item.GetMetadata("LinkerFlags"); if (!string.IsNullOrEmpty(value)) { var linkerFlags = ProcessArgumentBuilder.Parse(value); foreach (var flag in linkerFlags) { gcc.Arguments.AddQuoted(flag); } } } }
protected override string GenerateCommandLineCommands() { var cmd = new CommandLineBuilder(); #if DEBUG cmd.AppendSwitch("/v"); #endif if (NoStdLib) { cmd.AppendSwitch("/nostdlib"); } cmd.AppendSwitchIfNotNull("/compiler:", CompilerPath); cmd.AppendSwitchIfNotNull("/baselib:", BaseLibDll); cmd.AppendSwitchIfNotNull("/out:", OutputAssembly); if (NoStdLib) { string dir; if (!string.IsNullOrEmpty(BaseLibDll)) { dir = Path.GetDirectoryName(BaseLibDll); } else { dir = null; } cmd.AppendSwitchIfNotNull("/lib:", dir); cmd.AppendSwitchIfNotNull("/r:", Path.Combine(dir, "mscorlib.dll")); } if (ProcessEnums) { cmd.AppendSwitch("/process-enums"); } if (EmitDebugInformation) { cmd.AppendSwitch("/debug"); } if (AllowUnsafeBlocks) { cmd.AppendSwitch("/unsafe"); } cmd.AppendSwitchIfNotNull("/ns:", Namespace); if (!string.IsNullOrEmpty(DefineConstants)) { var strv = DefineConstants.Split(new [] { ';' }); var sanitized = new List <string> (); foreach (var str in strv) { if (str != string.Empty) { sanitized.Add(str); } } if (sanitized.Count > 0) { cmd.AppendSwitchIfNotNull("/d:", string.Join(";", sanitized.ToArray())); } } //cmd.AppendSwitch ("/e"); foreach (var item in ApiDefinitions) { cmd.AppendFileNameIfNotNull(Path.GetFullPath(item.ItemSpec)); } if (CoreSources != null) { foreach (var item in CoreSources) { cmd.AppendSwitchIfNotNull("/s:", Path.GetFullPath(item.ItemSpec)); } } if (Sources != null) { foreach (var item in Sources) { cmd.AppendSwitchIfNotNull("/x:", Path.GetFullPath(item.ItemSpec)); } } if (AdditionalLibPaths != null) { foreach (var item in AdditionalLibPaths) { cmd.AppendSwitchIfNotNull("/lib:", Path.GetFullPath(item.ItemSpec)); } } HandleReferences(cmd); if (Resources != null) { foreach (var item in Resources) { var args = new List <string> (); string id; args.Add(item.ToString()); id = item.GetMetadata("LogicalName"); if (!string.IsNullOrEmpty(id)) { args.Add(id); } cmd.AppendSwitchIfNotNull("/res:", args.ToArray(), ","); } } if (NativeLibraries != null) { foreach (var item in NativeLibraries) { var args = new List <string> (); string id; args.Add(item.ToString()); id = item.GetMetadata("LogicalName"); if (string.IsNullOrEmpty(id)) { id = Path.GetFileName(args[0]); } args.Add(id); cmd.AppendSwitchIfNotNull("/link-with:", args.ToArray(), ","); } } if (GeneratedSourcesDir != null) { cmd.AppendSwitchIfNotNull("/tmpdir:", Path.GetFullPath(GeneratedSourcesDir)); } if (GeneratedSourcesFileList != null) { cmd.AppendSwitchIfNotNull("/sourceonly:", Path.GetFullPath(GeneratedSourcesFileList)); } cmd.AppendSwitch(GetTargetFrameworkArgument()); if (!string.IsNullOrEmpty(ExtraArgs)) { var extraArgs = ProcessArgumentBuilder.Parse(ExtraArgs); var target = OutputAssembly; string projectDir; if (ProjectDir.StartsWith("~/", StringComparison.Ordinal)) { // Note: Since the Visual Studio plugin doesn't know the user's home directory on the Mac build host, // it simply uses paths relative to "~/". Expand these paths to their full path equivalents. var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); projectDir = Path.Combine(home, ProjectDir.Substring(2)); } else { projectDir = ProjectDir; } var customTags = new Dictionary <string, string> (StringComparer.OrdinalIgnoreCase) { { "projectdir", projectDir }, // Apparently msbuild doesn't propagate the solution path, so we can't get it. // { "solutiondir", proj.ParentSolution != null ? proj.ParentSolution.BaseDirectory : proj.BaseDirectory }, { "targetpath", Path.Combine(Path.GetDirectoryName(target), Path.GetFileName(target)) }, { "targetdir", Path.GetDirectoryName(target) }, { "targetname", Path.GetFileName(target) }, { "targetext", Path.GetExtension(target) }, }; for (int i = 0; i < extraArgs.Length; i++) { var argument = extraArgs[i]; cmd.AppendTextUnquoted(StringParserService.Parse(argument, customTags)); } } return(cmd.ToString()); }
public override bool Execute() { if (string.IsNullOrEmpty(NoSymbolStrip)) { NoSymbolStrip = "false"; } if (string.IsNullOrEmpty(NoDSymUtil)) { NoDSymUtil = "false"; } if (!string.IsNullOrEmpty(ExtraArgs)) { var args = ProcessArgumentBuilder.Parse(ExtraArgs); for (int i = 0; i < args.Length; i++) { string arg; if (string.IsNullOrEmpty(args[i])) { continue; } if (args[i][0] == '/') { arg = args[i].Substring(1); } else if (args[i][0] == '-') { if (args[i].Length >= 2 && args[i][1] == '-') { arg = args[i].Substring(2); } else { arg = args[i].Substring(1); } } else { continue; } switch (arg) { case "nosymbolstrip": NoSymbolStrip = "true"; // There's also a version that takes symbols as arguments: // --nosymbolstrip:symbol1,symbol2 // in that case we do want to run the SymbolStrip target, so we // do not set the MtouchNoSymbolStrip property to 'true' in that case. break; case "dsym": NoDSymUtil = "false"; break; default: if (arg.StartsWith("dsym:", StringComparison.Ordinal) || arg.StartsWith("dsym=", StringComparison.Ordinal)) { NoDSymUtil = ParseBool(arg.Substring(5)) ? "false" : "true"; } break; } } } Log.LogTaskProperty("NoSymbolStrip Output", NoSymbolStrip); Log.LogTaskProperty("NoDSymUtil Output", NoDSymUtil); return(!Log.HasLoggedErrors); }