private Options.ExplicitOptions GenerateOptions(AndroidPackageProject project, string projectPath, Project.Configuration conf)
{
Options.ExplicitOptions options = new Options.ExplicitOptions();
options["OutputFile"] = FileGeneratorUtilities.RemoveLineTag;
if (_Project.AppLibType != null)
{
Project.Configuration appLibConf = conf.ConfigurationDependencies.FirstOrDefault(confDep => (confDep.Project.GetType() == _Project.AppLibType));
if (appLibConf != null)
{
// The lib name to first load from an AndroidActivity must be a dynamic library.
if (appLibConf.Output != Project.Configuration.OutputType.Dll)
{
throw new Error("Cannot use configuration \"{0}\" as app lib for package configuration \"{1}\". Output type must be set to dynamic library.", appLibConf, conf);
}
options["OutputFile"] = appLibConf.TargetFileFullName;
}
else
{
throw new Error("Missing dependency of type \"{0}\" in configuration \"{1}\" dependencies.", _Project.AppLibType.ToNiceTypeName(), conf);
}
}
//Options.Vc.General.UseDebugLibraries.
// Disable WarnAsError="false"
// Enable WarnAsError="true" /WX
SelectOption
(
Options.Option(Options.Vc.General.UseDebugLibraries.Disabled, () => { options["UseDebugLibraries"] = "false"; }),
Options.Option(Options.Vc.General.UseDebugLibraries.Enabled, () => { options["UseDebugLibraries"] = "true"; })
);
SelectOption
(
Options.Option(Options.Android.General.AndroidAPILevel.Default, () => { options["AndroidAPILevel"] = FileGeneratorUtilities.RemoveLineTag; }),
Options.Option(Options.Android.General.AndroidAPILevel.Android19, () => { options["AndroidAPILevel"] = "android-19"; }),
Options.Option(Options.Android.General.AndroidAPILevel.Android21, () => { options["AndroidAPILevel"] = "android-21"; }),
Options.Option(Options.Android.General.AndroidAPILevel.Android22, () => { options["AndroidAPILevel"] = "android-22"; }),
Options.Option(Options.Android.General.AndroidAPILevel.Android23, () => { options["AndroidAPILevel"] = "android-23"; }),
Options.Option(Options.Android.General.AndroidAPILevel.Android24, () => { options["AndroidAPILevel"] = "android-24"; })
);
//OutputDirectory
// The debugger need a rooted path to work properly.
// So we root the relative output directory to $(ProjectDir) to work around this limitation.
// Hopefully in a futur version of the cross platform tools will be able to remove this hack.
string outputDirectoryRelative = Util.PathGetRelative(projectPath, conf.TargetPath);
options["OutputDirectory"] = outputDirectoryRelative;
//IntermediateDirectory
string intermediateDirectoryRelative = Util.PathGetRelative(projectPath, conf.IntermediatePath);
options["IntermediateDirectory"] = intermediateDirectoryRelative;
return(options);
}
public CompileCommandGenerationContext(Builder builder, Project project, Project.Configuration config)
{
Builder = builder;
Project = project;
ProjectDirectory = config.ProjectPath;
ProjectDirectoryCapitalized = Util.GetCapitalizedPath(ProjectDirectory);
ProjectSourceCapitalized = Util.GetCapitalizedPath(project.SourceRootPath);
Configuration = config;
Options = new Options.ExplicitOptions();
CommandLineOptions = new Dictionary <string, string>();
}
private void Generate(
AndroidPackageProject project,
List <Project.Configuration> unsortedConfigurations,
string projectPath,
string projectFile,
List <string> generatedFiles,
List <string> skipFiles)
{
// Need to sort by name and platform
List <Project.Configuration> configurations = new List <Project.Configuration>();
configurations.AddRange(unsortedConfigurations.OrderBy(conf => conf.Name + conf.Platform));
// validate that 2 conf name in the same project don't have the same name
Dictionary <string, Project.Configuration> configurationNameMapping = new Dictionary <string, Project.Configuration>();
string projectName = null;
foreach (Project.Configuration conf in configurations)
{
if (projectName == null)
{
projectName = conf.ProjectName;
}
else if (projectName != conf.ProjectName)
{
throw new Error("Project configurations in the same project files must be the same: {0} != {1} in {2}", projectName, conf.ProjectName, projectFile);
}
Project.Configuration otherConf;
string projectUniqueName = conf.Name + Util.GetPlatformString(conf.Platform, conf.Project);
if (configurationNameMapping.TryGetValue(projectUniqueName, out otherConf))
{
var differBy = Util.MakeDifferenceString(conf, otherConf);
throw new Error(
"Project {0} ({5} in {6}) have 2 configurations with the same name: \"{1}\" for {2} and {3}"
+ Environment.NewLine + "Nb: ps3 and win32 cannot have same conf name: {4}",
project.Name, conf.Name, otherConf.Target, conf.Target, differBy, projectFile, projectPath);
}
configurationNameMapping[projectUniqueName] = conf;
// set generator information
switch (conf.Platform)
{
case Platform.android:
conf.GeneratorSetGeneratedInformation("elf", "elf", "so", "pdb");
break;
default:
break;
}
}
Resolver resolver = new Resolver();
_ProjectDirectoryCapitalized = Util.GetCapitalizedPath(projectPath);
//_ProjectSourceCapitalized = Util.GetCapitalizedPath(project.SourceRootPath);
_Project = project;
_ProjectConfigurationList = configurations;
MemoryStream memoryStream = new MemoryStream();
StreamWriter writer = new StreamWriter(memoryStream);
// xml begin header
DevEnvRange devEnvRange = new DevEnvRange(unsortedConfigurations);
using (resolver.NewScopedParameter("toolsVersion", devEnvRange.MinDevEnv.GetVisualProjectToolsVersionString()))
{
Write(Template.Project.ProjectBegin, writer, resolver);
}
Write(Template.Project.ProjectBeginConfigurationDescription, writer, resolver);
// xml header contain description of each target
foreach (Project.Configuration conf in _ProjectConfigurationList)
{
using (resolver.NewScopedParameter("platformName", Util.GetPlatformString(conf.Platform, conf.Project)))
using (resolver.NewScopedParameter("conf", conf))
{
Write(Template.Project.ProjectConfigurationDescription, writer, resolver);
}
}
Write(Template.Project.ProjectEndConfigurationDescription, writer, resolver);
// xml end header
var firstConf = _ProjectConfigurationList.First();
using (resolver.NewScopedParameter("projectName", projectName))
using (resolver.NewScopedParameter("guid", firstConf.ProjectGuid))
using (resolver.NewScopedParameter("toolsVersion", devEnvRange.MinDevEnv.GetVisualProjectToolsVersionString()))
{
Write(Template.Project.ProjectDescription, writer, resolver);
}
// generate all configuration options once...
Dictionary <Project.Configuration, Options.ExplicitOptions> options = new Dictionary <Project.Configuration, Options.ExplicitOptions>();
foreach (Project.Configuration conf in _ProjectConfigurationList)
{
_ProjectConfiguration = conf;
Options.ExplicitOptions option = GenerateOptions(project, projectPath, conf);
_ProjectConfiguration = null;
options.Add(conf, option);
}
// configuration general
foreach (Project.Configuration conf in _ProjectConfigurationList)
{
using (resolver.NewScopedParameter("platformName", Util.GetPlatformString(conf.Platform, conf.Project)))
using (resolver.NewScopedParameter("conf", conf))
using (resolver.NewScopedParameter("options", options[conf]))
{
Write(Template.Project.ProjectConfigurationsGeneral, writer, resolver);
}
}
// .props files
Write(Template.Project.ProjectAfterConfigurationsGeneral, writer, resolver);
Write(Template.Project.ProjectAfterImportedProps, writer, resolver);
string androidPackageDirectory = project.AntBuildRootDirectory;
// configuration ItemDefinitionGroup
foreach (Project.Configuration conf in _ProjectConfigurationList)
{
using (resolver.NewScopedParameter("platformName", Util.GetPlatformString(conf.Platform, conf.Project)))
using (resolver.NewScopedParameter("conf", conf))
using (resolver.NewScopedParameter("options", options[conf]))
using (resolver.NewScopedParameter("androidPackageDirectory", androidPackageDirectory))
{
Write(Template.Project.ProjectConfigurationBeginItemDefinition, writer, resolver);
{
Write(Template.Project.AntPackage, writer, resolver);
}
Write(Template.Project.ProjectConfigurationEndItemDefinition, writer, resolver);
}
}
GenerateFilesSection(project, writer, resolver, projectPath, projectFile, generatedFiles, skipFiles);
GenerateProjectReferences(configurations, resolver, writer, options);
// .targets
Write(Template.Project.ProjectTargets, writer, resolver);
Write(Template.Project.ProjectEnd, writer, resolver);
// Write the project file
writer.Flush();
// remove all line that contain RemoveLineTag
MemoryStream cleanMemoryStream = Util.RemoveLineTags(memoryStream, FileGeneratorUtilities.RemoveLineTag);
FileInfo projectFileInfo = new FileInfo(Path.Combine(projectPath, projectFile + ProjectExtension));
if (_Builder.Context.WriteGeneratedFile(project.GetType(), projectFileInfo, cleanMemoryStream))
{
generatedFiles.Add(projectFileInfo.FullName);
}
else
{
skipFiles.Add(projectFileInfo.FullName);
}
writer.Close();
_Project = null;
}
private Options.ExplicitOptions GenerateOptions(Project.Configuration conf, FileInfo projectFileInfo)
{
Options.ExplicitOptions options = new Options.ExplicitOptions();
// CompilerToUse
SelectOption(conf,
Options.Option(Options.Makefile.General.PlatformToolset.Gcc, () => { options["CompilerToUse"] = "g++"; }),
Options.Option(Options.Makefile.General.PlatformToolset.Clang, () => { options["CompilerToUse"] = "clang++"; })
);
// IntermediateDirectory
options["IntermediateDirectory"] = PathMakeUnix(Util.PathGetRelative(projectFileInfo.DirectoryName, conf.IntermediatePath));
// OutputDirectory
string outputDirectory = PathMakeUnix(GetOutputDirectory(conf, projectFileInfo));
options["OutputDirectory"] = outputDirectory;
#region Compiler
// Defines
var defines = new Strings();
if (conf.DefaultOption == Options.DefaultTarget.Debug)
{
defines.Add("_DEBUG");
}
else // Release
{
defines.Add("NDEBUG");
}
foreach (string define in conf.Defines)
{
if (!string.IsNullOrWhiteSpace(define))
{
defines.Add(define.Replace(@"""", @"\"""));
}
}
defines.InsertPrefixSuffix(@"-D """, @"""");
options["Defines"] = defines.JoinStrings(" ");
// Includes
OrderableStrings includePaths = new OrderableStrings();
includePaths.AddRange(Util.PathGetRelative(projectFileInfo.DirectoryName, Util.PathGetCapitalized(conf.IncludePrivatePaths)));
includePaths.AddRange(Util.PathGetRelative(projectFileInfo.DirectoryName, Util.PathGetCapitalized(conf.IncludePaths)));
includePaths.AddRange(Util.PathGetRelative(projectFileInfo.DirectoryName, Util.PathGetCapitalized(conf.DependenciesIncludePaths)));
PathMakeUnix(includePaths);
includePaths.InsertPrefix("-I");
includePaths.Sort();
options["Includes"] = includePaths.JoinStrings(" ");
if (conf.ForcedIncludes.Count > 0)
{
OrderableStrings relativeForceIncludes = new OrderableStrings(Util.PathGetRelative(projectFileInfo.DirectoryName, conf.ForcedIncludes));
PathMakeUnix(relativeForceIncludes);
relativeForceIncludes.InsertPrefix("-include ");
relativeForceIncludes.Sort();
options["Includes"] += " " + relativeForceIncludes.JoinStrings(" ");
}
// CFLAGS
{
StringBuilder cflags = new StringBuilder();
// ExtraWarnings
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.ExtraWarnings.Enable, () => { cflags.Append("-Wextra "); }),
Options.Option(Options.Makefile.Compiler.ExtraWarnings.Disable, () => { })
);
// GenerateDebugInformation
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.GenerateDebugInformation.Enable, () => { cflags.Append("-g "); }),
Options.Option(Options.Makefile.Compiler.GenerateDebugInformation.Disable, () => { })
);
// OptimizationLevel
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.OptimizationLevel.Disable, () => { }),
Options.Option(Options.Makefile.Compiler.OptimizationLevel.Standard, () => { cflags.Append("-O1 "); }),
Options.Option(Options.Makefile.Compiler.OptimizationLevel.Full, () => { cflags.Append("-O2 "); }),
Options.Option(Options.Makefile.Compiler.OptimizationLevel.FullWithInlining, () => { cflags.Append("-O3 "); }),
Options.Option(Options.Makefile.Compiler.OptimizationLevel.ForSize, () => { cflags.Append("-Os "); })
);
// Warnings
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.Warnings.NormalWarnings, () => { }),
Options.Option(Options.Makefile.Compiler.Warnings.MoreWarnings, () => { cflags.Append("-Wall "); }),
Options.Option(Options.Makefile.Compiler.Warnings.Disable, () => { cflags.Append("-w "); })
);
// WarningsAsErrors
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.TreatWarningsAsErrors.Enable, () => { cflags.Append("-Werror "); }),
Options.Option(Options.Makefile.Compiler.TreatWarningsAsErrors.Disable, () => { })
);
// AdditionalCompilerOptions
cflags.Append(conf.AdditionalCompilerOptions.JoinStrings(" "));
options["CFLAGS"] = cflags.ToString();
}
// CXXFLAGS
{
StringBuilder cxxflags = new StringBuilder();
// CppLanguageStandard
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.Default, () => { cxxflags.Append(""); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.Cpp98, () => { cxxflags.Append("-std=c++98 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.Cpp11, () => { cxxflags.Append("-std=c++11 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.Cpp14, () => { cxxflags.Append("-std=c++14 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.Cpp17, () => { cxxflags.Append("-std=c++17 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.Cpp2a, () => { cxxflags.Append("-std=c++2a "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.GnuCpp98, () => { cxxflags.Append("-std=gnu++98 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.GnuCpp11, () => { cxxflags.Append("-std=gnu++11 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.GnuCpp14, () => { cxxflags.Append("-std=gnu++14 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.GnuCpp17, () => { cxxflags.Append("-std=gnu++17 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.GnuCpp2a, () => { cxxflags.Append("-std=gnu++2a "); })
);
// Exceptions
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.Exceptions.Enable, () => { cxxflags.Append("-fexceptions "); }),
Options.Option(Options.Makefile.Compiler.Exceptions.Disable, () => { cxxflags.Append("-fno-exceptions "); })
);
// RTTI
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.Rtti.Enable, () => { cxxflags.Append("-frtti "); }),
Options.Option(Options.Makefile.Compiler.Rtti.Disable, () => { cxxflags.Append("-fno-rtti "); })
);
options["CXXFLAGS"] = cxxflags.ToString();
}
#endregion
#region Linker
// OutputFile
options["OutputFile"] = conf.TargetFileFullNameWithExtension.Replace(" ", @"\ ");
// LibraryFiles
options["LibraryFiles"] = GenerateLibraryReferences(conf.LibraryFiles, conf);
// LibraryPaths
OrderableStrings libraryPaths = new OrderableStrings();
libraryPaths.AddRange(Util.PathGetRelative(projectFileInfo.DirectoryName, conf.LibraryPaths));
libraryPaths.AddRange(Util.PathGetRelative(projectFileInfo.DirectoryName, conf.DependenciesOtherLibraryPaths));
libraryPaths.AddRange(Util.PathGetRelative(projectFileInfo.DirectoryName, conf.DependenciesBuiltTargetsLibraryPaths));
PathMakeUnix(libraryPaths);
libraryPaths.InsertPrefix("-L");
libraryPaths.Sort();
options["LibraryPaths"] = libraryPaths.JoinStrings(" ");
// Dependencies
var deps = new OrderableStrings();
foreach (Project.Configuration depConf in conf.ResolvedDependencies)
{
switch (depConf.Output)
{
case Project.Configuration.OutputType.None:
continue;
case Project.Configuration.OutputType.Lib:
case Project.Configuration.OutputType.DotNetClassLibrary:
deps.Add(Path.Combine(depConf.TargetLibraryPath, depConf.TargetFileFullNameWithExtension), depConf.TargetFileOrderNumber);
break;
case Project.Configuration.OutputType.Dll:
default:
deps.Add(Path.Combine(depConf.TargetPath, depConf.TargetFileFullNameWithExtension), depConf.TargetFileOrderNumber);
break;
}
}
var depsRelative = Util.PathGetRelative(projectFileInfo.DirectoryName, deps);
PathMakeUnix(depsRelative);
depsRelative.Sort();
options["LDDEPS"] = depsRelative.JoinStrings(" ");
// DependenciesLibraryFiles
options["DependenciesLibraryFiles"] = GenerateLibraryReferences(conf.DependenciesOtherLibraryFiles, conf, depsRelative);
// LinkCommand
if (conf.Output == Project.Configuration.OutputType.Lib)
{
options["LinkCommand"] = Template.Project.LinkCommandLib;
}
else if (conf.Output == Project.Configuration.OutputType.Dll)
{
options["LinkCommand"] = Template.Project.LinkCommandDll;
}
else
{
options["LinkCommand"] = Template.Project.LinkCommandExe;
}
if (conf.AdditionalLibrarianOptions.Any())
{
throw new NotImplementedException(nameof(conf.AdditionalLibrarianOptions) + " not supported with Makefile generator");
}
string linkerAdditionalOptions = conf.AdditionalLinkerOptions.JoinStrings(" ");
options["AdditionalLinkerOptions"] = linkerAdditionalOptions;
// this is supported in both gcc and clang
SelectOption(conf,
Options.Option(Options.Makefile.Linker.LibGroup.Enable, () => { options["LibsStartGroup"] = " -Wl,--start-group "; options["LibsEndGroup"] = " -Wl,--end-group "; }),
Options.Option(Options.Makefile.Linker.LibGroup.Disable, () => { options["LibsStartGroup"] = string.Empty; options["LibsEndGroup"] = string.Empty; })
);
#endregion
return(options);
}
private string GenerateProject(
Builder builder,
Project project,
List <Project.Configuration> unsortedConfigurations,
FileInfo projectFileInfo,
out bool updated)
{
// Need to sort by name and platform
List <Project.Configuration> configurations = new List <Project.Configuration>();
configurations.AddRange(unsortedConfigurations.OrderBy(conf => conf.Name + conf.Platform));
// Build source files list.
List <ProjectFile> sourceFiles = GetSourceFiles(project, configurations, projectFileInfo);
// Generate options.
Dictionary <Project.Configuration, Options.ExplicitOptions> options = new Dictionary <Project.Configuration, Options.ExplicitOptions>();
foreach (Project.Configuration conf in configurations)
{
Options.ExplicitOptions option = GenerateOptions(conf, projectFileInfo);
options.Add(conf, option);
}
var fileGenerator = new FileGenerator();
{
fileGenerator.Write(Template.Project.Header);
// Configurations variables.
foreach (Project.Configuration conf in configurations)
{
string precompHeader = "";
string precompHeaderOut = "";
string precompIntermediate = "";
string precompCommand = "";
string precompPreBuildCmds = "";
string precompPreLinkCmds = "";
string precompPostBuildCmds = "";
if (!string.IsNullOrEmpty(conf.PrecompHeader))
{
// Support pch files in sub folders
var pchFile = PathMakeUnix(conf.PrecompHeader);
// Don't make additional subfolder in temp directory
var pchObj = Path.GetFileName(conf.PrecompHeader);
var fileName = Path.Combine(PathMakeUnix(project.SourceRootPath), pchFile);
precompHeader = PathMakeUnix(Util.PathGetRelative(projectFileInfo.DirectoryName, fileName, true));
precompHeaderOut = $"$(OBJDIR)/{pchObj}";
precompIntermediate = $"$(OBJDIR)/{pchObj}.gch";
precompCommand = "-include $(PCHOUT)";
}
if (conf.EventPreBuild.Any())
{
precompPreBuildCmds = conf.EventPreBuild.Aggregate((curr, next) => $"{curr} && {next}");
}
if (conf.EventPreLink.Any())
{
precompPreLinkCmds = conf.EventPreLink.Aggregate((curr, next) => $"{curr} && {next}");
}
if (conf.EventPostBuild.Any())
{
precompPostBuildCmds = conf.EventPostBuild.Aggregate((curr, next) => $"{curr} && {next}");
}
using (fileGenerator.Declare("name", conf.Name.ToLower()))
using (fileGenerator.Declare("options", options[conf]))
using (fileGenerator.Declare("precompHeader", precompHeader))
using (fileGenerator.Declare("precompHeaderOut", precompHeaderOut))
using (fileGenerator.Declare("precompIntermediate", precompIntermediate))
using (fileGenerator.Declare("precompCommand", precompCommand))
using (fileGenerator.Declare("precompPreBuildCmds", precompPreBuildCmds))
using (fileGenerator.Declare("precompPreLinkCmds", precompPreLinkCmds))
using (fileGenerator.Declare("precompPostBuildCmds", precompPostBuildCmds))
{
fileGenerator.Write(Template.Project.ProjectConfigurationVariables);
}
}
// Objects variables
foreach (Project.Configuration conf in configurations)
{
using (fileGenerator.Declare("name", conf.Name.ToLower()))
{
fileGenerator.Write(Template.Project.ObjectsVariableBegin);
foreach (ProjectFile file in sourceFiles)
{
// Excluded source files are written to the makefile but are commented out.
// This support the use case where you have a huge unit tests suite that take too long to compile.
// In this case, you just exclude all unit tests from the build and manually uncomment only the unit tests you want to build.
using (fileGenerator.Declare("excludeChar", conf.ResolvedSourceFilesBuildExclude.Contains(file.FileName) ? "#" : ""))
using (fileGenerator.Declare("objectFile", file.GetObjectFileName()))
{
fileGenerator.Write(Template.Project.ObjectsVariableElement);
}
}
fileGenerator.Write(Template.Project.ObjectsVariableEnd);
}
}
// General rules
using (fileGenerator.Declare("projectName", project.Name))
{
fileGenerator.Write(Template.Project.ProjectRulesGeneral);
}
// Source file rules
// Since we write excluded source files commented. Here we write rules for all files
// in case one of the commented out object file is manually uncomment.
foreach (ProjectFile file in sourceFiles)
{
using (fileGenerator.Declare("objectFile", file.GetObjectFileName()))
using (fileGenerator.Declare("sourceFile", PathMakeUnix(file.FileNameProjectRelative)))
{
if (file.FileExtensionLower == ".c")
{
fileGenerator.Write(Template.Project.ObjectRuleC);
}
else
{
fileGenerator.Write(Template.Project.ObjectRuleCxx);
}
}
}
fileGenerator.Write(Template.Project.Footer);
// Write the project file
updated = builder.Context.WriteGeneratedFile(project.GetType(), projectFileInfo, fileGenerator.ToMemoryStream());
}
return(projectFileInfo.FullName);
}
private string GenerateProject(
Builder builder,
Project project,
List <Project.Configuration> unsortedConfigurations,
FileInfo projectFileInfo,
out bool updated)
{
// Need to sort by name and platform
List <Project.Configuration> configurations = new List <Project.Configuration>();
configurations.AddRange(unsortedConfigurations.OrderBy(conf => conf.Name + conf.Platform));
// Build source files list.
List <ProjectFile> sourceFiles = GetSourceFiles(project, configurations, projectFileInfo);
// Generate options.
Dictionary <Project.Configuration, Options.ExplicitOptions> options = new Dictionary <Project.Configuration, Options.ExplicitOptions>();
foreach (Project.Configuration conf in configurations)
{
Options.ExplicitOptions option = GenerateOptions(conf, projectFileInfo);
options.Add(conf, option);
}
var fileGenerator = new FileGenerator();
{
fileGenerator.Write(Template.Project.Header);
// Configurations variables.
foreach (Project.Configuration conf in configurations)
{
using (fileGenerator.Declare("name", conf.Name.ToLower()))
using (fileGenerator.Declare("options", options[conf]))
{
fileGenerator.Write(Template.Project.ProjectConfigurationVariables);
}
}
// Objects variables
foreach (Project.Configuration conf in configurations)
{
using (fileGenerator.Declare("name", conf.Name.ToLower()))
{
fileGenerator.Write(Template.Project.ObjectsVariableBegin);
foreach (ProjectFile file in sourceFiles)
{
// Excluded source files are written to the makefile but are commented out.
// This support the use case where you have a huge unit tests suite that take too long to compile.
// In this case, you just exclude all unit tests from the build and manually uncomment only the unit tests you want to build.
using (fileGenerator.Declare("excludeChar", conf.ResolvedSourceFilesBuildExclude.Contains(file.FileName) ? "#" : ""))
using (fileGenerator.Declare("objectFile", file.FileNameWithoutExtension + ObjectExtension))
{
fileGenerator.Write(Template.Project.ObjectsVariableElement);
}
}
fileGenerator.Write(Template.Project.ObjectsVariableEnd);
}
}
// General rules
using (fileGenerator.Declare("projectName", project.Name))
{
fileGenerator.Write(Template.Project.ProjectRulesGeneral);
}
// Source file rules
// Since we write excluded source files commented. Here we write rules for all files
// in case one of the commented out object file is manually uncomment.
foreach (ProjectFile file in GetSourceFiles(project, configurations, projectFileInfo))
{
using (fileGenerator.Declare("objectFile", file.FileNameWithoutExtension + ObjectExtension))
using (fileGenerator.Declare("sourceFile", PathMakeUnix(file.FileNameProjectRelative)))
{
if (file.FileExtensionLower == ".c")
{
fileGenerator.Write(Template.Project.ObjectRuleC);
}
else
{
fileGenerator.Write(Template.Project.ObjectRuleCxx);
}
}
}
fileGenerator.Write(Template.Project.Footer);
// Write the project file
updated = builder.Context.WriteGeneratedFile(project.GetType(), projectFileInfo, fileGenerator.ToMemoryStream());
}
return(projectFileInfo.FullName);
}
private Options.ExplicitOptions GenerateOptions(Project.Configuration conf, FileInfo projectFileInfo)
{
Options.ExplicitOptions options = new Options.ExplicitOptions();
// CompilerToUse
SelectOption(conf,
Options.Option(Options.Makefile.General.PlatformToolset.Gcc, () => { options["CompilerToUse"] = "g++"; }),
Options.Option(Options.Makefile.General.PlatformToolset.Clang, () => { options["CompilerToUse"] = "clang++"; })
);
// IntermediateDirectory
options["IntermediateDirectory"] = PathMakeUnix(Util.PathGetRelative(projectFileInfo.DirectoryName, conf.IntermediatePath));
// OutputDirectory
options["OutputDirectory"] = PathMakeUnix(GetOutputDirectory(conf, projectFileInfo));
#region Compiler
// Defines
Strings defines = new Strings();
defines.AddRange(conf.Defines);
defines.InsertPrefix("-D");
options["Defines"] = defines.JoinStrings(" ");
// Includes
OrderableStrings includePaths = new OrderableStrings();
includePaths.AddRange(Util.PathGetRelative(projectFileInfo.DirectoryName, conf.IncludePrivatePaths));
includePaths.AddRange(Util.PathGetRelative(projectFileInfo.DirectoryName, conf.IncludePaths));
includePaths.AddRange(Util.PathGetRelative(projectFileInfo.DirectoryName, conf.DependenciesIncludePaths));
PathMakeUnix(includePaths);
includePaths.InsertPrefix("-I");
options["Includes"] = includePaths.JoinStrings(" ");
// CFLAGS
{
StringBuilder cflags = new StringBuilder();
// CppLanguageStandard
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.Cpp11, () => { cflags.Append("-std=c++11 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.Cpp98, () => { cflags.Append("-std=c++98 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.GnuCpp11, () => { cflags.Append("-std=gnu++11 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.GnuCpp98, () => { cflags.Append("-std=gnu++98 "); }),
Options.Option(Options.Makefile.Compiler.CppLanguageStandard.Default, () => { cflags.Append(""); })
);
// ExtraWarnings
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.ExtraWarnings.Enable, () => { cflags.Append("-Wextra "); }),
Options.Option(Options.Makefile.Compiler.ExtraWarnings.Disable, () => { cflags.Append(""); })
);
// GenerateDebugInformation
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.GenerateDebugInformation.Enable, () => { cflags.Append("-g "); }),
Options.Option(Options.Makefile.Compiler.GenerateDebugInformation.Disable, () => { cflags.Append(""); })
);
// OptimizationLevel
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.OptimizationLevel.Disable, () => { cflags.Append(""); }),
Options.Option(Options.Makefile.Compiler.OptimizationLevel.Standard, () => { cflags.Append("-O1 "); }),
Options.Option(Options.Makefile.Compiler.OptimizationLevel.Full, () => { cflags.Append("-O2 "); }),
Options.Option(Options.Makefile.Compiler.OptimizationLevel.FullWithInlining, () => { cflags.Append("-O3 "); }),
Options.Option(Options.Makefile.Compiler.OptimizationLevel.ForSize, () => { cflags.Append("-Os "); })
);
// Warnings
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.Warnings.NormalWarnings, () => { cflags.Append(""); }),
Options.Option(Options.Makefile.Compiler.Warnings.MoreWarnings, () => { cflags.Append("-Wall "); }),
Options.Option(Options.Makefile.Compiler.Warnings.Disable, () => { cflags.Append("-w "); })
);
// WarningsAsErrors
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.TreatWarningsAsErrors.Enable, () => { cflags.Append("-Werror "); }),
Options.Option(Options.Makefile.Compiler.TreatWarningsAsErrors.Disable, () => { cflags.Append(""); })
);
// AdditionalCompilerOptions
cflags.Append(conf.AdditionalCompilerOptions.JoinStrings(" "));
options["CFLAGS"] = cflags.ToString();
}
// CXXFLAGS
{
StringBuilder cxxflags = new StringBuilder();
// Exceptions
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.Exceptions.Enable, () => { cxxflags.Append("-fexceptions "); }),
Options.Option(Options.Makefile.Compiler.Exceptions.Disable, () => { cxxflags.Append("-fno-exceptions "); })
);
// RTTI
SelectOption(conf,
Options.Option(Options.Makefile.Compiler.Rtti.Enable, () => { cxxflags.Append("-frtti "); }),
Options.Option(Options.Makefile.Compiler.Rtti.Disable, () => { cxxflags.Append("-fno-rtti "); })
);
options["CXXFLAGS"] = cxxflags.ToString();
}
#endregion
#region Linker
// OutputFile
options["OutputFile"] = FormatOutputFileName(conf);
// DependenciesLibraryFiles
OrderableStrings dependenciesLibraryFiles = GetDependenciesOutputFilesProjectRelative(conf, projectFileInfo);
PathMakeUnix(dependenciesLibraryFiles);
options["DependenciesLibraryFiles"] = dependenciesLibraryFiles.JoinStrings(" ");
// LibraryFiles
OrderableStrings libraryFiles = new OrderableStrings();
libraryFiles.AddRange(conf.LibraryFiles);
libraryFiles.InsertPrefix("-l");
options["LibraryFiles"] = libraryFiles.JoinStrings(" ");
// LibraryPaths
OrderableStrings libraryPaths = new OrderableStrings();
libraryPaths.AddRange(Util.PathGetRelative(projectFileInfo.DirectoryName, conf.LibraryPaths));
PathMakeUnix(libraryPaths);
libraryPaths.InsertPrefix("-L");
options["LibraryPaths"] = libraryPaths.JoinStrings(" ");
// LinkCommand
if (conf.Output == Project.Configuration.OutputType.Lib)
{
options["LinkCommand"] = Template.Project.LinkCommandLib;
}
else
{
options["LinkCommand"] = Template.Project.LinkCommandExe;
}
#endregion
return(options);
}
