Ejemplo n.º 1
0
        private static void ApplyCompilationOptions(CompilerOptions compilationOptions, List<string> compilerArgs)
        {
            var targetType = compilationOptions.EmitEntryPoint.GetValueOrDefault() ? "exe" : "library";

            compilerArgs.Add($"-target:{targetType}");

            if (compilationOptions.AllowUnsafe.GetValueOrDefault())
            {
                compilerArgs.Add("-unsafe+");
            }

            compilerArgs.AddRange(compilationOptions.Defines.Select(d => $"-d:{d}"));

            if (compilationOptions.Optimize.GetValueOrDefault())
            {
                compilerArgs.Add("-optimize");
            }

            if (!string.IsNullOrEmpty(compilationOptions.Platform))
            {
                compilerArgs.Add($"-platform:{compilationOptions.Platform}");
            }

            if (compilationOptions.WarningsAsErrors.GetValueOrDefault())
            {
                compilerArgs.Add("-warnaserror");
            }

            if (compilationOptions.DelaySign.GetValueOrDefault())
            {
                compilerArgs.Add("-delaysign+");
            }

            if (!string.IsNullOrEmpty(compilationOptions.KeyFile))
            {
                compilerArgs.Add($"-keyFile:\"{compilationOptions.KeyFile}\"");
            }

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                compilerArgs.Add("-debug:full");
            }
            else
            {
                compilerArgs.Add("-debug:portable");
            }

            // TODO: OSS signing
        }
Ejemplo n.º 2
0
        public static CompilerOptions Combine(params CompilerOptions[] options)
        {
            var result = new CompilerOptions();
            foreach (var option in options)
            {
                // Skip null options
                if (option == null)
                {
                    continue;
                }

                // Defines are always combined
                if (option.Defines != null)
                {
                    var existing = result.Defines ?? Enumerable.Empty<string>();
                    result.Defines = existing.Concat(option.Defines).Distinct();
                }

                if (option.LanguageVersion != null)
                {
                    result.LanguageVersion = option.LanguageVersion;
                }

                if (option.Platform != null)
                {
                    result.Platform = option.Platform;
                }

                if (option.AllowUnsafe != null)
                {
                    result.AllowUnsafe = option.AllowUnsafe;
                }

                if (option.WarningsAsErrors != null)
                {
                    result.WarningsAsErrors = option.WarningsAsErrors;
                }

                if (option.Optimize != null)
                {
                    result.Optimize = option.Optimize;
                }

                if (option.KeyFile != null)
                {
                    result.KeyFile = option.KeyFile;
                }

                if (option.DelaySign != null)
                {
                    result.DelaySign = option.DelaySign;
                }

                if (option.StrongName != null)
                {
                    result.StrongName = option.StrongName;
                }

                if (option.EmitEntryPoint != null)
                {
                    result.EmitEntryPoint = option.EmitEntryPoint;
                }
            }

            return result;
        }