def __TestGetPackageLoader(config: Config, files: List[str],
platformId: str) -> PackageLoader:
packageFilters = PackageFilters()
platformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(
platformId, GeneratorType.Default, True,
config.ToolConfig.CMakeConfiguration, None)
return PackageLoader(config, files, platformGeneratorPlugin)
def __PrepareGeneratorPlugins(lowLevelToolConfig: LowLevelToolConfig,
toolCommonArgConfig: ToolCommonArgConfig) -> List[str]:
generatorPlugins = PluginConfig.GetGeneratorPlugins(lowLevelToolConfig.AllowDevelopmentPlugins)
generatorIds = [entry.Id for entry in generatorPlugins]
if toolCommonArgConfig.AllowPlaformAll:
generatorIds.append(PluginSharedValues.PLATFORM_ID_ALL)
return generatorIds
def Process(self, currentDirPath: str, toolConfig: ToolConfig, localToolConfig: LocalToolConfig) -> None:
config = Config(self.Log, toolConfig, localToolConfig.PackageConfigurationType,
localToolConfig.BuildVariantsDict, localToolConfig.AllowDevelopmentPlugins)
if localToolConfig.DryRun:
config.ForceDisableAllWrite()
if localToolConfig.IgnoreNotSupported:
config.IgnoreNotSupported = True
# Get the platform and see if its supported
platformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(localToolConfig.PlatformName, localToolConfig.Generator, False,
config.ToolConfig.CMakeConfiguration, localToolConfig.GetUserCMakeConfig())
PlatformUtil.CheckBuildPlatform(platformGeneratorPlugin.PlatformName)
config.LogPrint("Active platform: {0}".format(platformGeneratorPlugin.PlatformName))
theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(), currentDirPath, localToolConfig.Recursive)
generatorContext = GeneratorContext(config, localToolConfig.BuildPackageFilters.RecipeFilterManager, config.ToolConfig.Experimental, platformGeneratorPlugin)
PluginConfig.SetLegacyGeneratorType(localToolConfig.GenType)
packageFilters = localToolConfig.BuildPackageFilters
packages = MainFlow.DoGenerateBuildFilesNoAll(config, theFiles, platformGeneratorPlugin, packageFilters)
topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
requestedFiles = None if config.IsSDKBuild else theFiles
# We need the generator to be able to examine its support
if localToolConfig.ListFeatures or localToolConfig.ListVariants or localToolConfig.ListExtensions or localToolConfig.ListRequirements:
if localToolConfig.ListFeatures:
Builder.ShowFeatureList(self.Log, config, topLevelPackage, requestedFiles)
if localToolConfig.ListVariants:
Builder.ShowVariantList(self.Log, topLevelPackage, requestedFiles, platformGeneratorPlugin)
if localToolConfig.ListExtensions:
Builder.ShowExtensionList(self.Log, topLevelPackage, requestedFiles)
if localToolConfig.ListRequirements:
Builder.ShowRequirementList(self.Log, config, topLevelPackage, requestedFiles)
else:
if localToolConfig.BuildPackageFilters is None or localToolConfig.BuildPackageFilters.ExtensionNameList is None:
raise Exception("localToolConfig.BuildPackageFilters.ExtensionNameList not set")
Builder.BuildPackages(generatorContext, config, packages,
localToolConfig.BuildVariantsDict, localToolConfig.RemainingArgs, localToolConfig.ForAllExe,
platformGeneratorPlugin, localToolConfig.EnableContentBuilder, localToolConfig.ForceClaimInstallArea,
localToolConfig.BuildThreads, localToolConfig.Command)
def Process(self, currentDirPath: str, toolConfig: ToolConfig,
localToolConfig: LocalToolConfig) -> None:
config = Config(self.Log, toolConfig, 'sdk',
localToolConfig.BuildVariantsDict,
localToolConfig.AllowDevelopmentPlugins)
if localToolConfig.DryRun:
config.ForceDisableAllWrite()
if localToolConfig.ToCDepth < 1:
localToolConfig.ToCDepth = 1
elif localToolConfig.ToCDepth > 4:
localToolConfig.ToCDepth = 4
config.PrintTitle()
# Get the platform and see if its supported
platform = PluginConfig.GetGeneratorPluginById(
localToolConfig.PlatformName, False)
PlatformUtil.CheckBuildPlatform(platform.Name)
config.LogPrint("Active platform: {0}".format(platform.Name))
packageFilters = localToolConfig.BuildPackageFilters
theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(),
currentDirPath,
localToolConfig.Recursive)
generatorContext = GeneratorContext(config,
config.ToolConfig.Experimental,
platform)
packages = MainFlow.DoGetPackages(generatorContext, config, theFiles,
packageFilters)
#topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
#featureList = [entry.Name for entry in topLevelPackage.ResolvedAllUsedFeatures]
for rootDir in config.ToolConfig.RootDirectories:
readmePath = IOUtil.Join(rootDir.ResolvedPath, "README.md")
packageReadMeLines = TryLoadReadMe(config, readmePath)
result = ProcessPackages(self.ToolAppContext, config, packages,
rootDir, localToolConfig.ExtractArguments,
toolConfig.BuildDocConfiguration)
if packageReadMeLines is not None:
packageReadMeLinesNew = TryReplaceSection(
config, packageReadMeLines, "AG_DEMOAPPS", result,
readmePath)
if packageReadMeLinesNew is not None:
packageReadMeLines = packageReadMeLinesNew
packageReadMeLinesNew = TryInsertTableOfContents(
config, packageReadMeLines, localToolConfig.ToCDepth,
readmePath)
if packageReadMeLinesNew is not None:
packageReadMeLines = packageReadMeLinesNew
SaveReadMe(config, readmePath, packageReadMeLines)
elif config.Verbosity > 2:
config.LogPrintWarning("No README.md found in {0}".format(
rootDir.ResolvedPath))
def __TestGenerateBuildFiles(config: Config, files: List[str],
platformId: str) -> Dict[str, List[Package]]:
packageFilters = PackageFilters()
platform = PluginConfig.GetGeneratorPluginById(platformId, True)
buildFilesDict = DoGenerateBuildFiles3(config, files, platform,
packageFilters)
return {
dictKey: dictValue[0]
for dictKey, dictValue in buildFilesDict.items()
}
def __TestGetPackageLoader(config: Config, files: List[str],
platformId: str) -> PackageLoader:
packageFilters = PackageFilters()
#generatorCMakeConfig = __GetTestGeneratorCMakeConfig()
log = config # type: Log
pluginConfigContext = PluginConfig.InitPluginConfigContext(
log, config.ToolConfig.ToolVersion, allowDevelopmentPlugins=True)
buildVariantConfig = BuildVariantConfig.Debug
platformGeneratorPlugin = pluginConfigContext.GetGeneratorPluginById(
platformId, GeneratorType.Default, buildVariantConfig, True,
config.ToolConfig.CMakeConfiguration, None)
return PackageLoader(config, files, platformGeneratorPlugin)
def DoGenerateBuildFiles3(config: Config, files: List[str], platformGeneratorPlugin: GeneratorPlugin,
packageFilters: PackageFilters) -> MultiPlatformPackageResultType:
config.LogPrint("- Generating build files")
isSDKBuild = len(files) <= 0
packageLoader = PackageLoader(config, files, platformGeneratorPlugin)
if platformGeneratorPlugin.Id != PluginSharedValues.PLATFORM_ID_ALL:
raise Exception("This requires: PLATFORM_ID_ALL")
resDict = {} # type: MultiPlatformPackageResultType
for entry in PluginConfig.GetGeneratorPlugins(config.AllowDevelopmentPlugins):
if not config.IsTestMode or not entry.InDevelopment:
packages = __ResolveAndGenerate(config, entry, copy.deepcopy(packageLoader), packageFilters, isSDKBuild)
resDict[entry.Name] = (packages, entry)
return resDict
def __TestGenerateBuildFiles(config: Config, files: List[str],
platformId: str) -> Dict[str, List[Package]]:
errorHelpManager = ErrorHelpManager()
packageFilters = PackageFilters()
log = config # type: Log
#generatorCMakeConfig = __GetTestGeneratorCMakeConfig()
pluginConfigContext = PluginConfig.InitPluginConfigContext(
log, config.ToolConfig.ToolVersion, allowDevelopmentPlugins=True)
buildVariantConfig = BuildVariantConfig.Debug
platform = pluginConfigContext.GetGeneratorPluginById(
platformId, GeneratorType.Default, buildVariantConfig, True,
config.ToolConfig.CMakeConfiguration, None)
buildFilesDict = DoGenerateBuildFiles3(pluginConfigContext, config,
errorHelpManager, files, platform,
packageFilters)
return {
dictKey: dictValue[0]
for dictKey, dictValue in buildFilesDict.items()
}
def Process(self, currentDirPath: str, toolConfig: ToolConfig, localToolConfig: LocalToolConfig) -> None:
config = Config(self.Log, toolConfig, localToolConfig.PackageConfigurationType,
localToolConfig.BuildVariantsDict, localToolConfig.AllowDevelopmentPlugins)
# Disable downloads and writes
if config.ToolConfig.Experimental is not None:
config.ToolConfig.Experimental.AllowDownloads = False
config.ForceDisableAllWrite()
if localToolConfig.IgnoreNotSupported:
config.IgnoreNotSupported = True
self.Log.PrintTitle()
if not localToolConfig.ForceYes and not self.__AskYesNo("Delete all build directories"):
return
packageFilters = localToolConfig.BuildPackageFilters
generator = PluginConfig.GetGeneratorPluginById(localToolConfig.PlatformName, False)
theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(), currentDirPath, localToolConfig.Recursive)
generatorContext = GeneratorContext(config, config.ToolConfig.Experimental, generator)
packages = MainFlow.DoGetPackages(generatorContext, config, theFiles, packageFilters, autoAddRecipeExternals=False)
topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
requestedFiles = None if config.IsSDKBuild else theFiles
self.Log.LogPrint("Deleting package build directories")
for package in topLevelPackage.ResolvedBuildOrder:
if package.AbsoluteBuildPath is not None:
# While the path is most likely normalized we force it here
removePath = IOUtil.NormalizePath(package.AbsoluteBuildPath)
if IOUtil.IsDirectory(removePath):
self.Log.LogPrint("- Deleting '{0}'".format(removePath))
drive, tail = os.path.splitdrive(removePath)
driveId = IOUtil.NormalizePath(drive).lower()
removePathId = removePath.lower()
# some basic checks to prevent deletes of '/' or a drive letter.
if ('../' in removePath or '/..' in removePath or removePath == '/' or removePath == '..' or
len(removePath) <= 0 or removePathId==driveId or removePath.endswith('/')):
raise Exception("Invalid path format '{0}'".format(removePath))
IOUtil.SafeRemoveDirectoryTree(removePath)
def Process(self, currentDirPath: str, toolConfig: ToolConfig,
localToolConfig: LocalToolConfig) -> None:
config = Config(self.Log, toolConfig,
localToolConfig.PackageConfigurationType,
localToolConfig.BuildVariantsDict,
localToolConfig.AllowDevelopmentPlugins)
packageFilters = localToolConfig.BuildPackageFilters
platform = PluginConfig.GetGeneratorPluginById(
localToolConfig.PlatformName, localToolConfig.Generator, False,
config.ToolConfig.CMakeConfiguration,
localToolConfig.GetUserCMakeConfig())
theFiles = [] # type: List[str]
if not localToolConfig.VoidBuild:
theFiles = MainFlow.DoGetFiles(config,
toolConfig.GetMinimalConfig(),
currentDirPath,
localToolConfig.Recursive)
else:
self.Log.LogPrintVerbose(1, "Doing a void build")
generatorContext = GeneratorContext(config,
packageFilters.RecipeFilterManager,
config.ToolConfig.Experimental,
platform)
packages = MainFlow.DoGetPackages(generatorContext, config, theFiles,
packageFilters)
#packages = DoExperimentalGetRecipes(generatorContext, config, [])
#topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
builderConfig = BuilderConfig()
builderConfig.Settings.PreDeleteBuild = localToolConfig.PreDeleteBuild
builderConfig.Settings.PostDeleteBuild = localToolConfig.PostDeleteBuild
builderConfig.Settings.CheckBuildCommands = localToolConfig.CheckBuildCommands
builderConfig.Settings.ForceClaimInstallArea = localToolConfig.ForceClaimInstallArea
builderConfig.Settings.BuildThreads = localToolConfig.BuildThreads
RecipeBuilder.BuildPackages(config, generatorContext, builderConfig,
packages)
def DoGenerateBuildFiles(
config: Config, files: List[str], platformGeneratorPlugin: GeneratorPlugin,
packageFilters: PackageFilters
) -> Union[List[Package], MultiPlatformPackageResultType]:
config.LogPrint("- Generating build files")
isSDKBuild = len(files) <= 0
packageLoader = PackageLoader(config, files, platformGeneratorPlugin)
res = [] # type: Union[List[Package], MultiPlatformPackageResultType]
if platformGeneratorPlugin.PlatformId == PluginSharedValues.PLATFORM_ID_ALL:
resDict = {} # type: MultiPlatformPackageResultType
for entry in PluginConfig.GetGeneratorPlugins(
config.AllowDevelopmentPlugins):
if not config.IsTestMode or not entry.InDevelopment:
packages = __ResolveAndGenerate(config, entry,
copy.deepcopy(packageLoader),
packageFilters, isSDKBuild)
resDict[entry.PlatformName] = (packages, entry)
res = resDict
else:
res = __ResolveAndGenerate(config, platformGeneratorPlugin,
packageLoader, packageFilters, isSDKBuild)
return res
def __TestGenerateBuildFilesAllPlatforms(
config: Config, files: List[str]) -> Dict[str, List[Package]]:
res = {} # type: Dict[str, List[Package]]
for platformId in PackageConfig.APPROVED_PLATFORM_NAMES:
errorHelpManager = ErrorHelpManager()
packageFilters = PackageFilters()
log = config # type: Log
#generatorCMakeConfig = __GetTestGeneratorCMakeConfig()
pluginConfigContext = PluginConfig.InitPluginConfigContext(
log, config.ToolConfig.ToolVersion, allowDevelopmentPlugins=True)
pluginConfigContext.SetVSVersion(
str(config.ToolConfig.GetVisualStudioDefaultVersion()))
buildVariantConfig = BuildVariantConfig.Debug
platform = pluginConfigContext.GetGeneratorPluginById(
platformId, GeneratorType.Default, buildVariantConfig,
config.ToolConfig.DefaultPackageLanguage,
config.ToolConfig.CMakeConfiguration, None, False)
resultTuple = DoGenerateBuildFilesNow(pluginConfigContext, config,
errorHelpManager, files,
platform, packageFilters)
if resultTuple is not None:
res[platformId] = resultTuple[0]
return res
def __Run(appFlowFactory: AToolAppFlowFactory, strToolAppTitle: str,
toolCommonArgConfig: ToolCommonArgConfig,
lowLevelToolConfig: LowLevelToolConfig,
allowStandaloneMode: bool) -> None:
log = Log(strToolAppTitle,
lowLevelToolConfig.VerbosityLevel,
showAppTitleIfVerbose=True)
generatorIds = __PrepareGeneratorPlugins(lowLevelToolConfig,
toolCommonArgConfig)
try:
defaultPlatform = DetectBuildPlatform()
except (Exception) as ex:
print("ERROR: {0}".format(ex))
if lowLevelToolConfig.DebugEnabled:
raise
sys.exit(1)
### Do the actual command line parsing
parser = __CreateParser(toolCommonArgConfig, allowStandaloneMode)
if toolCommonArgConfig.AddPlatformArg:
parser.add_argument('-p',
'--platform',
default=defaultPlatform,
help='Select build platform: {0}'.format(
", ".join(generatorIds)))
if toolCommonArgConfig.AllowForceClaimInstallArea:
parser.add_argument(
'--ForceClaimInstallArea',
action='store_true',
help=
'Override the security checks on the install area allowing us to use it even though its not empty. This means the existing content can be lost.'
)
#parser.add_argument('--NativeGen', action='store_true', help='Force use the native build generator')
toolConfig = None
baseConfig = None
try:
basicConfig = BasicConfig(log)
currentDir = lowLevelToolConfig.CurrentDir
# Try to locate a project root configuration file
projectRootConfig = GetProjectRootConfig(lowLevelToolConfig,
basicConfig, currentDir)
toolConfigFile = projectRootConfig.ToolConfigFile
# Get the path to the toolconfig file if necessary and load the tool config file
toolConfigPath = __GetToolConfigPath(toolConfigFile)
toolConfig = ToolConfig(basicConfig, toolConfigPath, projectRootConfig)
baseConfig = BaseConfig(log, toolConfig)
except (Exception) as ex:
print("ERROR: {0}".format(ex))
if lowLevelToolConfig.DebugEnabled:
raise
sys.exit(1)
buildTiming = None
try:
defaultVSVersion = toolConfig.GetVisualStudioDefaultVersion()
#if toolCommonArgConfig.AllowVSVersion:
parser.add_argument(
'--VSVersion',
default=str(defaultVSVersion),
help=
'Choose a specific visual studio version (2015,2017), This project defaults to: {0}'
.format(defaultVSVersion))
userTag = appFlowFactory.CreateUserTag(baseConfig)
appFlowFactory.AddCustomArguments(parser, toolConfig, userTag)
args = parser.parse_args()
#if toolCommonArgConfig.AllowVSVersion:
PluginConfig.SetVSVersion(args.VSVersion)
#if toolCommonArgConfig.AddPlatformArg and args.platform.lower() != PluginSharedValues.PLATFORM_ID_ALL:
#PluginConfig.SetForceUseNativeGenerator(True)
#PluginConfig.SetForceUseNativeGenerator(args.NativeGen)
if toolCommonArgConfig.ProcessRemainingArgs:
args.RemainingArgs = __ProcessRemainingArgs(args.RemainingArgs)
if toolCommonArgConfig.SupportBuildTime and args.BuildTime:
buildTiming = BuildTimer()
if toolCommonArgConfig.AddBuildFiltering and args.Recipes == DefaultValue.Recipes:
if projectRootConfig.XmlExperimental is not None:
tmpResult = projectRootConfig.XmlExperimental.TryGetRecipesDefaultValue(
defaultPlatform)
if tmpResult is not None:
args.Recipes = "[{0}]".format(tmpResult)
toolAppConfig = __CreateToolAppConfig(args, defaultPlatform,
toolCommonArgConfig,
defaultVSVersion)
toolAppContext = ToolAppContext(log, lowLevelToolConfig, toolAppConfig)
toolAppFlow = appFlowFactory.Create(toolAppContext)
toolAppFlow.ProcessFromCommandLine(args, currentDir, toolConfig,
userTag)
if buildTiming:
PrintBuildTiming(buildTiming)
except GroupedException as ex:
if buildTiming:
PrintBuildTiming(buildTiming)
for entry in ex.ExceptionList:
print("ERROR: {0}".format(entry))
if lowLevelToolConfig.DebugEnabled:
raise
for entry in ex.ExceptionList:
if isinstance(entry, ExitException):
sys.exit(entry.ExitCode)
sys.exit(1)
except AggregateException as ex:
if buildTiming:
PrintBuildTiming(buildTiming)
for entry in ex.ExceptionList:
print("ERROR: {0}".format(entry))
if lowLevelToolConfig.DebugEnabled:
if len(ex.ExceptionList) > 0:
raise ex.ExceptionList[0]
raise
for entry in ex.ExceptionList:
if isinstance(entry, ExitException):
sys.exit(entry.ExitCode)
sys.exit(1)
except ExitException as ex:
sys.exit(ex.ExitCode)
except Exception as ex:
if buildTiming:
PrintBuildTiming(buildTiming)
print("ERROR: {0}".format(ex))
if lowLevelToolConfig.DebugEnabled:
raise
sys.exit(1)
def Process(self, currentDirPath: str, toolConfig: ToolConfig,
localToolConfig: LocalToolConfig) -> None:
config = Config(self.Log, toolConfig,
localToolConfig.PackageConfigurationType,
localToolConfig.BuildVariantsDict,
localToolConfig.AllowDevelopmentPlugins)
if localToolConfig.DryRun:
config.ForceDisableAllWrite()
if localToolConfig.IgnoreNotSupported:
config.IgnoreNotSupported = True
if localToolConfig.Graph:
PluginConfig.EnableGraph()
theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(),
currentDirPath,
localToolConfig.Recursive)
PluginConfig.SetGeneratorType(localToolConfig.GenType)
platformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(
localToolConfig.PlatformName, True)
generatorContext = GeneratorContext(config,
config.ToolConfig.Experimental,
platformGeneratorPlugin)
packages = MainFlow.DoGenerateBuildFiles(
config, theFiles, platformGeneratorPlugin,
localToolConfig.BuildPackageFilters)
# If the platform was manually switched, then check if the build platform is supported,
# if its not disable recipe building and log a warning
if localToolConfig.DefaultPlatformName != localToolConfig.PlatformName:
if not PlatformUtil.TryCheckBuildPlatform(
localToolConfig.PlatformName):
self.Log.DoPrintWarning(
"Build recipes not supported for '{0}' on this OS".format(
localToolConfig.PlatformName))
localToolConfig.DontBuildRecipes = True
if localToolConfig.ListVariants or localToolConfig.ListBuildVariants:
requestedFiles = None if config.IsSDKBuild else theFiles
if not isinstance(packages, dict):
self.__DoShowList(packages, requestedFiles,
localToolConfig.ListVariants,
localToolConfig.ListBuildVariants,
platformGeneratorPlugin)
else:
for platformName, platformResult in packages.items():
platformPackageList = platformResult[0]
if len(platformPackageList) > 0:
self.Log.DoPrint("Generator: {0}".format(platformName))
try:
self.Log.PushIndent()
self.__DoShowList(
platformPackageList, requestedFiles,
localToolConfig.ListVariants,
localToolConfig.ListBuildVariants,
platformResult[1])
finally:
self.Log.PopIndent()
elif not localToolConfig.DontBuildRecipes:
if not isinstance(packages, dict):
self.__DoBuildRecipes(config, generatorContext, packages,
localToolConfig.ForceClaimInstallArea,
localToolConfig.BuildThreads)
else:
for platformName, platformResult in packages.items():
platformPackageList = platformResult[0]
if len(platformPackageList
) > 0 and PlatformUtil.TryCheckBuildPlatform(
platformName):
self.Log.DoPrint("Generator: {0}".format(platformName))
tempPlatformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(
platformName, True)
tempGeneratorContext = GeneratorContext(
config, config.ToolConfig.Experimental,
tempPlatformGeneratorPlugin)
try:
self.Log.PushIndent()
self.__DoBuildRecipes(
config, tempGeneratorContext,
platformPackageList,
localToolConfig.ForceClaimInstallArea,
localToolConfig.BuildThreads)
finally:
self.Log.PopIndent()
def Process(self, currentDirPath: str, toolConfig: ToolConfig,
localToolConfig: LocalToolConfig) -> None:
# Check if a environment variable has been set to disable this tool
# This is for example done by FslBuild to prevent multiple executions of content building.
toolEnabled = IOUtil.TryGetEnvironmentVariable(
CONFIG_FSLBUILDCONTENT_ENABLED)
featureList = localToolConfig.BuildPackageFilters.FeatureNameList
config = Config(self.Log, toolConfig,
localToolConfig.PackageConfigurationType,
localToolConfig.BuildVariantsDict,
localToolConfig.AllowDevelopmentPlugins)
# Get the platform and see if its supported
generator = PluginConfig.GetGeneratorPluginById(
localToolConfig.PlatformName, localToolConfig.Generator, False,
config.ToolConfig.CMakeConfiguration,
localToolConfig.GetUserCMakeConfig())
PlatformUtil.CheckBuildPlatform(generator.PlatformName)
generatorContext = GeneratorContext(
config, localToolConfig.BuildPackageFilters.RecipeFilterManager,
config.ToolConfig.Experimental, generator)
config.LogPrint("Active platform: {0}".format(generator.PlatformName))
discoverFeatureList = '*' in featureList
topLevelPackage = None
if discoverFeatureList or localToolConfig.Project is None:
if discoverFeatureList:
config.LogPrint(
"No features specified, so using package to determine them"
)
topLevelPackage = self.__ResolveAndGetTopLevelPackage(
generatorContext, config, currentDirPath,
toolConfig.GetMinimalConfig(), localToolConfig.Recursive)
if discoverFeatureList:
featureList = [
entry.Name
for entry in topLevelPackage.ResolvedAllUsedFeatures
]
#if localToolConfig.Project is None:
# executeablePackage = PackageListUtil.FindFirstExecutablePackage(packages)
# localToolConfig.Project = executeablePackage.ShortName
if localToolConfig.Validate:
Validate.ValidatePlatform(config, localToolConfig.PlatformName,
featureList)
if topLevelPackage is None:
topLevelPackage = self.__ResolveAndGetTopLevelPackage(
generatorContext, config, currentDirPath,
toolConfig.GetMinimalConfig(), localToolConfig.Recursive)
RecipeBuilder.ValidateInstallationForPackages(
config, generatorContext, topLevelPackage.ResolvedBuildOrder)
if toolEnabled is not None and not ParseUtil.ParseBool(toolEnabled):
if self.Log.Verbosity > 0:
print(
"FslBuildContent has been disabled by environment variable {0} set to {1}"
.format(CONFIG_FSLBUILDCONTENT_ENABLED, toolEnabled))
return
locations = toolConfig.PackageConfiguration[
localToolConfig.PackageConfigurationType].Locations
location = self.__FindLocation(locations, currentDirPath)
packagePath = PackagePath(currentDirPath, location)
ContentBuilder.Build(config, packagePath, featureList,
localToolConfig.Output)
def Process(self, currentDirPath: str, toolConfig: ToolConfig,
localToolConfig: LocalToolConfig) -> None:
config = Config(self.Log, toolConfig,
localToolConfig.PackageConfigurationType,
localToolConfig.BuildVariantsDict,
localToolConfig.AllowDevelopmentPlugins)
# create a config we control and that can be used to just build the tool recipe's
configToolCheck = Config(self.Log, toolConfig,
PluginSharedValues.TYPE_DEFAULT,
localToolConfig.BuildVariantsDict,
localToolConfig.AllowDevelopmentPlugins)
if localToolConfig.DryRun:
config.ForceDisableAllWrite()
configToolCheck.ForceDisableAllWrite()
self.__CheckUserArgs(localToolConfig.ClangFormatArgs, "formatArgs")
self.__CheckUserArgs(localToolConfig.ClangTidyArgs, "tidyArgs")
self.__CheckUserArgs(localToolConfig.ClangTidyPostfixArgs,
"tidyPostfixArgs")
applyClangFormat = toolConfig.ClangFormatConfiguration is not None and localToolConfig.ClangFormat
applyClangTidy = toolConfig.ClangTidyConfiguration is not None and localToolConfig.ClangTidy
if localToolConfig.IgnoreNotSupported or (
(localToolConfig.ScanSource or applyClangFormat)
and not applyClangTidy):
config.IgnoreNotSupported = True
configToolCheck.IgnoreNotSupported = True
packageFilters = localToolConfig.BuildPackageFilters
# Get the platform and see if its supported
platform = PluginConfig.GetGeneratorPluginById(
localToolConfig.PlatformName, False)
PlatformUtil.CheckBuildPlatform(platform.Name)
generatorContext = GeneratorContext(config,
config.ToolConfig.Experimental,
platform)
config.LogPrint("Active platform: {0}".format(platform.Name))
packageRecipeResultManager = None # type: Optional[PackageRecipeResultManager]
toolPackageNames = []
if applyClangFormat or applyClangTidy:
if applyClangFormat:
if toolConfig.ClangFormatConfiguration is None:
raise Exception("internal error")
toolPackageNames.append(
toolConfig.ClangFormatConfiguration.RecipePackageName)
if applyClangTidy:
if toolConfig.ClangTidyConfiguration is None:
raise Exception("internal error")
toolPackageNames.append(
toolConfig.ClangTidyConfiguration.RecipePackageName)
packageRecipeResultManager = ForceCheckBuildTools(
configToolCheck, generatorContext, toolPackageNames)
searchDir = currentDirPath
if localToolConfig.File is not None and IOUtil.IsAbsolutePath(
localToolConfig.File):
searchDir = IOUtil.GetDirectoryName(localToolConfig.File)
closestGenFilePath = FileFinder.TryFindClosestFileInRoot(
config, toolConfig, searchDir, config.GenFileName)
if closestGenFilePath is None:
closestGenFilePath = searchDir
if (self.Log.Verbosity >= 4):
self.Log.LogPrint("Closest '{0}' file path: '{1}'".format(
toolConfig.GenFileName, closestGenFilePath))
packageProcess = None # type: Optional[MainFlow.PackageLoadAndResolveProcess]
packages = None
discoverFeatureList = '*' in packageFilters.FeatureNameList
if discoverFeatureList or localToolConfig.Project is None or localToolConfig.ScanSource or applyClangFormat or applyClangTidy:
if discoverFeatureList:
config.LogPrint(
"No features specified, so using package to determine them"
)
if localToolConfig.ScanSource or applyClangFormat or applyClangTidy or discoverFeatureList:
packageProcess = self.__CreatePackageProcess(
config, toolConfig.GetMinimalConfig(), closestGenFilePath,
localToolConfig.Recursive, generatorContext.Platform,
toolPackageNames)
packageProcess.Resolve(generatorContext, packageFilters,
applyClangTidy, False)
packages = packageProcess.Packages
topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
if discoverFeatureList:
packageFilters.FeatureNameList = [
entry.Name
for entry in topLevelPackage.ResolvedAllUsedFeatures
]
customPackageFileFilter = None # type: Optional[CustomPackageFileFilter]
if not localToolConfig.ScanSource and not applyClangFormat and not applyClangTidy:
Validate.ValidatePlatform(config, localToolConfig.PlatformName,
packageFilters.FeatureNameList)
if packageProcess is None:
packageProcess = self.__CreatePackageProcess(
config, toolConfig.GetMinimalConfig(), closestGenFilePath,
localToolConfig.Recursive, generatorContext.Platform,
toolPackageNames)
if not packageProcess.IsFullResolve or packages is None:
# For now this requires a full resolve (but basically it only requires basic + files)
packages = packageProcess.Resolve(generatorContext,
packageFilters,
applyClangTidy, True)
topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
RecipeBuilder.ValidateInstallationForPackages(
config, generatorContext, topLevelPackage.ResolvedBuildOrder)
else:
if localToolConfig.File is not None:
# Delay extension validation
customPackageFileFilter = CustomPackageFileFilter(
localToolConfig.File)
theTopLevelPackage = None # type: Optional[Package]
filteredPackageList = [] # type: List[Package]
if applyClangTidy or applyClangFormat or localToolConfig.ScanSource:
addExternals = applyClangTidy
filteredPackageList, theTopLevelPackage = self.__PreparePackages(
self.Log, localToolConfig, packageProcess, generatorContext,
packageFilters, addExternals, packages, config.IsSDKBuild,
applyClangTidy, config)
if len(filteredPackageList) <= 0:
self.Log.DoPrint("No supported packages left to process")
return
if applyClangTidy:
self.__ApplyClangTidy(self.Log, toolConfig, localToolConfig,
packageRecipeResultManager,
theTopLevelPackage, filteredPackageList,
platform, config, generatorContext,
customPackageFileFilter)
if applyClangFormat:
self.__ApplyClangFormat(self.Log, toolConfig, localToolConfig,
packageRecipeResultManager,
filteredPackageList,
customPackageFileFilter)
# Scan source after 'format' to ensure we dont warn about stuff that has been fixed
if localToolConfig.ScanSource:
self.__ApplyScanSource(self.Log, localToolConfig,
config.IsSDKBuild, config.DisableWrite,
filteredPackageList,
customPackageFileFilter)
def __TestGetPackageLoader(config: Config, files: List[str], platformId: str) -> PackageLoader:
packageFilters = PackageFilters()
platformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(platformId, True)
return PackageLoader(config, files, platformGeneratorPlugin)
def __ToolMainEx(self,
currentDir: str,
toolConfig: ToolConfig,
localToolConfig: LocalToolConfig,
templateDict: Dict[str, List[XmlNewTemplateFile]],
performSanityCheck: bool = False) -> None:
config = Config(self.Log, toolConfig, 'sdk',
localToolConfig.BuildVariantsDict,
localToolConfig.AllowDevelopmentPlugins)
#config.ForceDisableAllWrite()
config.PrintTitle()
packageFilters = localToolConfig.BuildPackageFilters
reservedProjectNames = set() # type: Set[str]
packages = None # type: Optional[List[Package]]
if not localToolConfig.NoParse:
# Get the platform and see if its supported
platform = PluginConfig.GetGeneratorPluginById(
localToolConfig.PlatformName, False)
PlatformUtil.CheckBuildPlatform(platform.Name)
config.LogPrint("Active platform: {0}".format(platform.Name))
generatorContext = GeneratorContext(config,
config.ToolConfig.Experimental,
platform)
packages = ParsePackages(generatorContext, config,
toolConfig.GetMinimalConfig(), currentDir,
packageFilters)
# Reserve the name of all packages
if not packages is None:
for package in packages:
reservedProjectNames.add(package.Name)
currentDir, projectName = DetermineDirAndProjectName(
currentDir, localToolConfig.ProjectName)
localConfig = LocalConfig(config, currentDir, projectName,
localToolConfig.Template,
localToolConfig.Force, templateDict,
reservedProjectNames,
localToolConfig.Language)
configVariant = localConfig.ConfigVariant
if not localToolConfig.AllowOverwrite:
if os.path.isdir(configVariant.ProjectPath):
raise EnvironmentError(
"The project directory already exist: '{0}', you can use '{1}' to overwrite it."
.format(configVariant.ProjectPath, g_allowOverwriteOption))
elif os.path.exists(configVariant.ProjectPath):
raise EnvironmentError(
"A file named '{0}' already exist, you can use '{1}' to overwrite it."
.format(configVariant.ProjectPath, g_allowOverwriteOption))
visualStudioGUID = localToolConfig.VisualStudioGUID
if packages:
visualStudioGUID = GenerateGUID(config, packages, visualStudioGUID)
GenerateProject(config, localConfig, configVariant, visualStudioGUID,
localToolConfig.GenFileOnly)
if not localToolConfig.NoBuildGen:
config.DoPrint("Generating build files")
projectConfig = Config(self.Log, toolConfig,
PluginSharedValues.TYPE_DEFAULT,
localToolConfig.BuildVariantsDict,
localToolConfig.AllowDevelopmentPlugins)
theFiles = MainFlow.DoGetFiles(projectConfig,
toolConfig.GetMinimalConfig(),
configVariant.ProjectPath)
platformGeneratorPlugin = PluginConfig.GetGeneratorPluginById(
localToolConfig.PlatformName, False)
MainFlow.DoGenerateBuildFiles(projectConfig, theFiles,
platformGeneratorPlugin,
packageFilters)
if performSanityCheck:
self.__PerformSanityCheck(config, currentDir,
localConfig.ProjectName,
localConfig.Template)
def __RunStandalone(appFlowFactory: AToolAppFlowFactory, strToolAppTitle: str,
toolCommonArgConfig: ToolCommonArgConfig,
lowLevelToolConfig: LowLevelToolConfig) -> None:
log = Log(strToolAppTitle,
lowLevelToolConfig.VerbosityLevel,
showAppTitleIfVerbose=True)
pluginConfigContext = PluginConfig.InitPluginConfigContext(
log, CurrentVersion, lowLevelToolConfig.AllowDevelopmentPlugins)
generatorIds = __PrepareGeneratorPlugins(pluginConfigContext,
lowLevelToolConfig,
toolCommonArgConfig)
### Do the actual command line parsing
parser = __CreateParser(toolCommonArgConfig, True)
if toolCommonArgConfig.AddPlatformArg:
parser.add_argument('-p',
'--platform',
required=True,
help='Select build platform: {0}'.format(
", ".join(generatorIds)))
buildTiming = None
errorHelpManager = ErrorHelpManager()
try:
userTag = appFlowFactory.CreateStandaloneUserTag()
appFlowFactory.AddCustomStandaloneArguments(parser, userTag)
args = parser.parse_args()
if toolCommonArgConfig.ProcessRemainingArgs:
args.RemainingArgs = __ProcessRemainingArgs(args.RemainingArgs)
if toolCommonArgConfig.SupportBuildTime and args.BuildTime:
buildTiming = BuildTimer()
currentDir = lowLevelToolConfig.CurrentDir
toolAppConfig = __CreateToolAppConfig(args, args.platform,
toolCommonArgConfig, 0)
toolAppContext = ToolAppContext(log, errorHelpManager,
lowLevelToolConfig, toolAppConfig,
pluginConfigContext)
toolAppFlow = appFlowFactory.Create(toolAppContext)
toolAppFlow.ProcessFromStandaloneCommandLine(args, currentDir, userTag)
if buildTiming:
PrintBuildTiming(buildTiming)
except GroupedException as ex:
__OnErrorInfo(buildTiming, errorHelpManager)
for entry in ex.ExceptionList:
print("ERROR: {0}".format(entry))
if lowLevelToolConfig.DebugEnabled:
raise
for entry in ex.ExceptionList:
if isinstance(entry, ExitException):
sys.exit(entry.ExitCode)
sys.exit(1)
except AggregateException as ex:
__OnErrorInfo(buildTiming, errorHelpManager)
for entry in ex.ExceptionList:
print("ERROR: {0}".format(entry))
if lowLevelToolConfig.DebugEnabled:
if len(ex.ExceptionList) > 0:
raise ex.ExceptionList[0]
raise
for entry in ex.ExceptionList:
if isinstance(entry, ExitException):
sys.exit(entry.ExitCode)
sys.exit(1)
except ExitException as ex:
__OnErrorInfo(buildTiming, errorHelpManager)
sys.exit(ex.ExitCode)
except Exception as ex:
__OnErrorInfo(buildTiming, errorHelpManager)
print("ERROR: {0}".format(ex))
if lowLevelToolConfig.DebugEnabled:
raise
sys.exit(1)
def Process(self, currentDirPath: str, toolConfig: ToolConfig,
localToolConfig: LocalToolConfig) -> None:
config = Config(self.Log, toolConfig, 'sdk',
localToolConfig.BuildVariantsDict,
localToolConfig.AllowDevelopmentPlugins)
if localToolConfig.DryRun:
config.ForceDisableAllWrite()
if localToolConfig.ToCDepth < 1:
localToolConfig.ToCDepth = 1
elif localToolConfig.ToCDepth > 4:
localToolConfig.ToCDepth = 4
config.PrintTitle()
# Get the generator and see if its supported
generator = PluginConfig.GetGeneratorPluginById(
localToolConfig.PlatformName, localToolConfig.Generator, False,
config.ToolConfig.CMakeConfiguration,
localToolConfig.GetUserCMakeConfig())
PlatformUtil.CheckBuildPlatform(generator.PlatformName)
config.LogPrint("Active platform: {0}".format(generator.PlatformName))
packageFilters = localToolConfig.BuildPackageFilters
theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(),
currentDirPath,
localToolConfig.Recursive)
generatorContext = GeneratorContext(config,
packageFilters.RecipeFilterManager,
config.ToolConfig.Experimental,
generator)
packages = MainFlow.DoGetPackages(generatorContext, config, theFiles,
packageFilters)
#topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
#featureList = [entry.Name for entry in topLevelPackage.ResolvedAllUsedFeatures]
for projectContext in config.ToolConfig.ProjectInfo.Contexts:
rootDir = self.__TryLocateRootDirectory(
config.ToolConfig.RootDirectories, projectContext.Location)
if rootDir is None:
raise Exception(
"Root directory not found for location {0}".format(
projectContext.Location))
readmePath = IOUtil.Join(rootDir.ResolvedPath, "README.md")
packageReadMeLines = TryLoadReadMe(config, readmePath)
result = ProcessPackages(self.ToolAppContext, config, packages,
rootDir, localToolConfig.ExtractArguments,
toolConfig.BuildDocConfiguration,
currentDirPath)
if packageReadMeLines is not None:
projectCaption = "# {0} {1}".format(
projectContext.ProjectName, projectContext.ProjectVersion)
packageReadMeLinesNew = TryReplaceSection(
config, packageReadMeLines, "AG_PROJECT_CAPTION",
[projectCaption], readmePath)
if packageReadMeLinesNew is not None:
packageReadMeLines = packageReadMeLinesNew
packageReadMeLinesNew = TryReplaceSection(
config, packageReadMeLines, "AG_DEMOAPPS", result,
readmePath)
if packageReadMeLinesNew is not None:
packageReadMeLines = packageReadMeLinesNew
packageReadMeLinesNew = TryInsertTableOfContents(
config, packageReadMeLines, localToolConfig.ToCDepth,
readmePath)
if packageReadMeLinesNew is not None:
packageReadMeLines = packageReadMeLinesNew
SaveReadMe(config, readmePath, packageReadMeLines)
elif config.Verbosity > 2:
config.LogPrintWarning("No README.md found in {0}".format(
rootDir.ResolvedPath))
def Process(self, currentDirPath: str, toolConfig: ToolConfig,
localToolConfig: LocalToolConfig) -> None:
config = Config(self.Log, toolConfig,
localToolConfig.PackageConfigurationType,
localToolConfig.BuildVariantsDict,
localToolConfig.AllowDevelopmentPlugins)
#if localToolConfig.DryRun:
# config.ForceDisableAllWrite()
if localToolConfig.IgnoreNotSupported:
config.IgnoreNotSupported = True
self.Log.PrintTitle()
packageFilters = localToolConfig.BuildPackageFilters
generator = PluginConfig.GetGeneratorPluginById(
localToolConfig.PlatformName, False)
theFiles = MainFlow.DoGetFiles(config, toolConfig.GetMinimalConfig(),
currentDirPath,
localToolConfig.Recursive)
generatorContext = GeneratorContext(config,
config.ToolConfig.Experimental,
generator)
packages = MainFlow.DoGetPackages(generatorContext,
config,
theFiles,
packageFilters,
autoAddRecipeExternals=False)
topLevelPackage = PackageListUtil.GetTopLevelPackage(packages)
requestedFiles = None if config.IsSDKBuild else theFiles
if localToolConfig.SaveJson is not None:
if localToolConfig.BuildPackageFilters.ExtensionNameList is None:
raise Exception(
"Invalid config missing ExtensionNameList filters")
config.LogPrint("Saving to json file '{0}'".format(
localToolConfig.SaveJson))
generatorConfig = GeneratorConfig(config.SDKConfigTemplatePath,
config.ToolConfig)
InfoSaver.SavePackageMetaDataToJson(
generatorContext, generatorConfig, localToolConfig.SaveJson,
config, topLevelPackage, localToolConfig.PackageTypeList,
localToolConfig.IncludeGeneratorReport)
if localToolConfig.ListFeatures:
Builder.ShowFeatureList(self.Log, config, topLevelPackage,
requestedFiles)
if localToolConfig.ListVariants:
requestedFiles = None if config.IsSDKBuild else theFiles
Builder.ShowVariantList(self.Log, topLevelPackage, requestedFiles,
generator)
if localToolConfig.ListBuildVariants:
Builder.ShowBuildVariantList(self.Log, generator)
if localToolConfig.ListExtensions:
Builder.ShowExtensionList(self.Log, topLevelPackage,
requestedFiles)
if localToolConfig.ListRequirements:
Builder.ShowRequirementList(self.Log, config, topLevelPackage,
requestedFiles)
if localToolConfig.ListRecipes:
RecipeInfo.ShowRecipeList(self.Log, topLevelPackage,
requestedFiles)