def __GenerateCMakeFile(self, config: Config, package: Package,
platformName: str,
template: CMakeGeneratorUtil.CodeTemplateCMake,
androidProjectDir: str,
androidProjectCMakeDir: str) -> None:
toolConfig = config.ToolConfig
pathType = CMakeGeneratorUtil.CMakePathType.Relative
packageName = CMakeGeneratorUtil.GetPackageName(package)
# this ignore is a workaround allowing us to build using the same info as the old Android builder
ignoreLibs = ["android_native_app_glue"]
aliasPackageName = CMakeGeneratorUtil.GetAliasName(
packageName, package.ProjectContext.ProjectName)
targetIncludeDirectories = CMakeGeneratorUtil.BuildTargetIncludeDirectories(
toolConfig, package, template.PackageTargetIncludeDirectories,
template.PackageTargetIncludeDirEntry,
template.PackageTargetIncludeDirVirtualEntry, pathType)
targetIncludeDirectories = targetIncludeDirectories.replace(
Variable.RecipeVariant, "${ANDROID_ABI}")
publicIncludeFiles = CMakeGeneratorUtil.ExpandPathAndJoin(
toolConfig, package, package.ResolvedBuildPublicIncludeFiles)
privateIncludeFiles = CMakeGeneratorUtil.ExpandPathAndJoin(
toolConfig, package, package.ResolvedBuildPrivateIncludeFiles)
includeFiles = CMakeGeneratorUtil.ExpandPathAndJoin(
toolConfig, package, package.ResolvedBuildAllIncludeFiles)
sourceFiles = CMakeGeneratorUtil.ExpandPathAndJoin(
toolConfig, package, package.ResolvedBuildSourceFiles)
linkLibrariesDirectDependencies = CMakeGeneratorUtil.BuildTargetLinkLibrariesForDirectDependencies(
config, package, template.PackageDependencyTargetLinkLibraries,
template.PackageDependencyFindPackage, ignoreLibs)
linkLibrariesDirectDependencies = linkLibrariesDirectDependencies.replace(
Variable.RecipeVariant, "${ANDROID_ABI}")
directDefinitions = CMakeGeneratorUtil.BuildDirectDefinitions(
config, package,
template.PackageDependencyTargetCompileDefinitions)
findDirectExternalDependencies = CMakeGeneratorUtil.BuildFindDirectExternalDependencies(
config, package, template.PackageDependencyFindPackage)
installInstructions = CMakeGeneratorUtil.BuildInstallInstructions(
config, package, template.PackageInstall,
template.PackageInstallTargets, template.PackageInstallHeaders,
template.PackageInstallContent, template.PackageInstallDLL,
template.PackageInstallAppInfo)
targetCompileFeatures = CMakeGeneratorUtil.BuildCompileFeatures(
config, package, template.SnippetTargetCompileFeaturesDefault,
template.SnippetTargetCompileFeaturesInterface)
targetCompileOptions = CMakeGeneratorUtil.BuildCompileOptions(
config, package, template.SnippetTargetCompileOptionsDefault)
buildCMakeFile = template.Master
if package.Type == PackageType.Executable:
if package.ContentPath is None or package.AbsolutePath is None:
raise Exception("Invalid package")
packagePath = CMakeGeneratorUtil.GetSDKBasedPathUsingCMakeVariable(
toolConfig, package.AbsolutePath)
packageContentPath = CMakeGeneratorUtil.GetSDKBasedPathUsingCMakeVariable(
toolConfig, package.ContentPath.AbsoluteDirPath)
buildCMakeFile = buildCMakeFile.replace("##PACKAGE_PATH##",
packagePath)
buildCMakeFile = buildCMakeFile.replace("##PACKAGE_CONTENT_PATH##",
packageContentPath)
buildCMakeFile = buildCMakeFile.replace(
"##PACKAGE_ANDROID_PROJECT_PATH##", androidProjectDir)
buildCMakeFile = buildCMakeFile.replace("##PACKAGE_INCLUDE_FILES##",
includeFiles)
buildCMakeFile = buildCMakeFile.replace(
"##PACKAGE_PUBLIC_INCLUDE_FILES##", publicIncludeFiles)
buildCMakeFile = buildCMakeFile.replace(
"##PACKAGE_PRIVATE_INCLUDE_FILES##", privateIncludeFiles)
buildCMakeFile = buildCMakeFile.replace("##PACKAGE_SOURCE_FILES##",
sourceFiles)
buildCMakeFile = buildCMakeFile.replace(
"##TARGET_INCLUDE_DIRECTORIES##", targetIncludeDirectories)
buildCMakeFile = buildCMakeFile.replace(
"##PACKAGE_DIRECT_DEPENDENCIES_TARGET_LINK_LIBRARIES##",
linkLibrariesDirectDependencies)
buildCMakeFile = buildCMakeFile.replace(
"##PACKAGE_DIRECT_DEPENDENCIES_TARGET_COMPILE_DEFINITIONS##",
directDefinitions)
buildCMakeFile = buildCMakeFile.replace(
"##PACKAGES_FIND_DIRECT_EXTERNAL_DEPENDENCIES##",
findDirectExternalDependencies)
buildCMakeFile = buildCMakeFile.replace(
"##SNIPPET_DEFAULT_TARGET_COMPILE_OPTIONS##", targetCompileOptions)
buildCMakeFile = buildCMakeFile.replace(
"##SNIPPET_DEFAULT_TARGET_COMPILE_FEATURES##",
template.SnippetTargetCompileFeaturesDefault)
buildCMakeFile = buildCMakeFile.replace(
"##PACKAGE_GENERATE_INSTALL_INSTRUCTIONS##", installInstructions)
buildCMakeFile = buildCMakeFile.replace("##PACKAGE_NAME!##",
packageName.upper())
buildCMakeFile = buildCMakeFile.replace("##PACKAGE_NAME##",
packageName)
buildCMakeFile = buildCMakeFile.replace("##ALIAS_PACKAGE_NAME##",
aliasPackageName)
buildCMakeFile = buildCMakeFile.replace(
"##PROJECT_NAME##", package.ProjectContext.ProjectName)
buildCMakeFile = buildCMakeFile.replace(
"##PROJECT_VERSION##", package.ProjectContext.ProjectVersion)
if not config.DisableWrite:
# We store all cmake build files in their own dir inside the 'android' exe-project's folder
# to prevent collision with other more generic CMake builders
packageCMakeDir = self.__GetPackageCMakeDir(
androidProjectCMakeDir, package)
IOUtil.SafeMakeDirs(packageCMakeDir)
dstFileCMakeFile = self.__GetPackageCMakeFileName(
androidProjectCMakeDir, package)
IOUtil.WriteFileIfChanged(dstFileCMakeFile, buildCMakeFile)
def __RunToolMainForSanityCheck(self, currentDir: str,
toolConfig: ToolConfig,
localToolConfig: LocalToolConfig,
templateDict: Dict[
str, List[XmlNewTemplateFile]],
debugMode: bool,
templateList: List[str]) -> None:
currentDir = IOUtil.Join(currentDir, GlobalStrings.SanityCheckDir)
IOUtil.SafeMakeDirs(currentDir)
if not IOUtil.IsDirectory(currentDir):
raise Exception(
"could not create work directory: '{0}'".format(currentDir))
isBuilding = False
try:
for currentTemplateName in templateList:
if currentTemplateName == '*' or currentTemplateName.startswith(
'/') or '..' in currentTemplateName:
raise Exception("Usage error")
localToolConfig.Template = currentTemplateName
localToolConfig.ProjectName = "{0}_{1}".format(
GlobalStrings.SanityCheckProjectName,
localToolConfig.Template)
localToolConfig.Force = True
if debugMode:
generatedDir = IOUtil.Join(currentDir,
localToolConfig.ProjectName)
if IOUtil.IsDirectory(generatedDir):
continue
print(("Generating sanity project for template '{0}' begin".
format(localToolConfig.Template)))
self.__ToolMainEx(currentDir, toolConfig, localToolConfig,
templateDict, False)
print((
"Generating sanity project for template '{0}' ended successfully"
.format(localToolConfig.Template)))
isBuilding = True
config = Config(self.Log, toolConfig, 'sdk',
localToolConfig.BuildVariantsDict,
localToolConfig.AllowDevelopmentPlugins)
print(
("Building sanity projects for all template begin {0}".format(
localToolConfig.Template)))
self.__BuildNow(config, currentDir, True)
print(("Building sanity project for template end {0}".format(
localToolConfig.Template)))
except:
if not isBuilding:
print("Sanity check of template '{0}' failed".format(
localToolConfig.Template))
else:
print("Sanity build of templates failed")
raise
finally:
if not debugMode:
for currentTemplateName in templateList:
if currentTemplateName == '*' or currentTemplateName.startswith(
'/') or '..' in currentTemplateName:
raise Exception("Usage error")
projectName = "{0}_{1}".format(
GlobalStrings.SanityCheckProjectName,
currentTemplateName)
projectDir = IOUtil.Join(currentDir, projectName)
if IOUtil.IsDirectory(projectDir):
shutil.rmtree(projectDir)
def __ConfigureBuild(self, report: PackageGeneratorConfigReport,
buildConfig: BuildConfigRecord) -> None:
configReport = report.ConfigReport.ConfigCommandReport
variableReport = report.VariableReport
buildArgumentList = []
for buildArgument in configReport.Arguments:
buildArgument = ReportVariableFormatter.Format(
buildArgument, variableReport, buildConfig.VariantSettingsDict)
buildArgumentList.append(buildArgument)
configCommandStr = ReportVariableFormatter.Format(
configReport.CommandFormatString, variableReport,
buildConfig.VariantSettingsDict)
currentWorkingDirectory = ReportVariableFormatter.Format(
configReport.CurrentWorkingDirectoryFormatString, variableReport,
buildConfig.VariantSettingsDict)
configCommand = [configCommandStr
] + buildArgumentList # + buildConfig.BuildConfigArgs
#if len(buildContext.Platform.AdditionalBuildConfigArguments) > 0:
# buildCommand += buildContext.Platform.AdditionalBuildConfigArguments
try:
IOUtil.SafeMakeDirs(currentWorkingDirectory)
cacheFilename = IOUtil.Join(currentWorkingDirectory,
'.FslConfigureCache.json')
dirtyBuildConfigureCache = self.__CheckBuildConfigureModifications(
cacheFilename, report.GeneratedFileSet, configCommand,
buildConfig.PlatformName)
if dirtyBuildConfigureCache is None:
self.Log.LogPrint(
"Build configuration not modified, skipping configure")
return
self.Log.LogPrint("Build configuration modifed, running configure")
if self.Log.Verbosity >= 1:
self.Log.LogPrint(
"Running build config command '{0}' in '{1}'".format(
self.__SafeJoinCommandArguments(configCommand),
currentWorkingDirectory))
result = subprocess.call(configCommand,
cwd=currentWorkingDirectory)
if result != 0:
self.Log.LogPrintWarning(
"The build config command '{0}' failed with '{1}'. It was run with CWD: '{2}'"
.format(self.__SafeJoinCommandArguments(configCommand),
result, currentWorkingDirectory))
sys.exit(result)
else:
BuildConfigureCache.Save(self.Log, cacheFilename,
dirtyBuildConfigureCache)
except FileNotFoundError:
self.Log.DoPrintWarning(
"The build config command '{0}' failed with 'file not found'. It was run with CWD: '{1}'"
.format(self.__SafeJoinCommandArguments(configCommand),
currentWorkingDirectory))
raise
def EnsureDirectoryExist(self, config: Config,
outputFileName: str) -> None:
outputDirectory = IOUtil.GetDirectoryName(outputFileName)
if not config.DisableWrite:
IOUtil.SafeMakeDirs(outputDirectory)
def __GenerateFolderStructure(self, config: Config, package: Package) -> None:
#don't generate anything for unsuported packages
if package.ResolvedPlatformNotSupported:
return
if (package.AbsolutePath is None or package.ResolvedBuildPath is None or
package.ResolvedBuildAllIncludeDirs is None or
package.ResolvedBuildSourceFiles is None or package.ShortName is None):
raise Exception("Invalid package")
# Use a standard build path
buildBasePath = IOUtil.Join(package.AbsolutePath, package.ResolvedBuildPath)
newDir = "arm"
relativePathBuildArm = IOUtil.Join(package.ResolvedBuildPath, newDir)
buildArmPath = IOUtil.Join(buildBasePath, newDir)
buildPath = buildBasePath
#relativePathBuild = ""
newDir = "a-le-v7"
relativePathBuildLib = IOUtil.Join(relativePathBuildArm, newDir)
buildPathLib = IOUtil.Join(buildArmPath, newDir)
#check package type and prepare folder name
if package.Type == PackageType.Library:
relativePathBuild = relativePathBuildLib
buildPath = buildPathLib
elif package.Type == PackageType.Executable:
newDir = "o-le-v7"
relativePathBuild = IOUtil.Join(relativePathBuildArm, newDir)
buildPath = IOUtil.Join(buildArmPath, newDir)
else:
raise InternalErrorException("Unknown package type: {0}".format(package.Name))
if not config.DisableWrite:
# create folder structure
IOUtil.SafeMakeDirs(buildPath)
#copy make files that are not modified
IOUtil.CopySmallFile(IOUtil.Join(config.SDKConfigTemplatePath, ".qnx_internal.mk"), IOUtil.Join(buildBasePath, ".qnx_internal.mk"))
dstFile = IOUtil.Join(buildBasePath, "Makefile")
content = self.TemplateMakefileCPU
IOUtil.WriteFileIfChanged(dstFile, content)
dstFile = IOUtil.Join(buildArmPath, "Makefile")
content = self.TemplateMakefileVariant
IOUtil.WriteFileIfChanged(dstFile, content)
dstFile = IOUtil.Join(buildPath, "Makefile")
content = self.TemplateMakefileTop
IOUtil.WriteFileIfChanged(dstFile, content)
#create common.mk with package-specific content
dstFile = IOUtil.Join(buildBasePath, "common.mk")
content = self.TemplateCommonMk
#add "$(project_root)/" to local includes like "include", keep others as they are ("$(FSL_GRAPHICS_SDK)/a/b/")
updatedIncludedirs = []
for includeDir in package.ResolvedBuildAllIncludeDirs:
if not os.path.dirname(includeDir):
updatedIncludedirs.append("$(project_root)/" + includeDir)
else:
updatedIncludedirs.append(includeDir)
includes = self.__FormatListToString("EXTRA_INCVPATH += ", updatedIncludedirs)
content = content.replace("##EXTRA_INCVPATHS##", includes)
srcDirsList = self.__ExtractUniqueDirectoriesFromList(package.ResolvedBuildSourceFiles)
srcDirs = self.__FormatListToString("EXTRA_SRCVPATH += $(project_root)/", srcDirsList)
content = content.replace("##EXTRA_SRCVPATHS##", srcDirs)
# QNX takes all sources in folder, just like this generator, so there is no need to
# list all files in makefile.
#sourceObjs = []
#for sourceFile in package.ResolvedBuildSourceFiles:
# sourceObjs.append(os.path.splitext(sourceFile)[0] + ".o")
#sourceObjsString = self.__FormatListToString("SOURCE_OBJECTS += $(project_root)/", sourceObjs)
#content = content.replace("##EXTRA_SOURCE_OBJS##", sourceObjsString)
content = content.replace("##EXTRA_SOURCE_OBJS##", "")
libDirsList = self.__GetStaticLibsPaths(config, package, relativePathBuildLib)
extLibraryDependencies = self.__GetExternalLibraryDependencies(package)
libsExtern = ""
for lib in extLibraryDependencies:
libsExtern = libsExtern + lib[0] + " "
if lib[1] is not None and lib[1] not in libDirsList:
libDirsList.append(lib[1])
if libsExtern:
libsExtern = "LIBS += " + libsExtern + "\n"
content = content.replace("##PACKAGE_EXTERNAL_LIBRARY_DEPENDENCIES##", libsExtern)
libDirs = self.__FormatListToString("EXTRA_LIBVPATH += ", libDirsList)
content = content.replace("##EXTRA_LIBVPATHS##", libDirs)
sl = self.__GetStaticLibs(package)
content = content.replace("##STATIC_LIBS##", sl)
name = package.ShortName if package.Type == PackageType.Executable else package.Name
content = content.replace("##PINFO_DESC##", name)
content = content.replace("##NAME##", name)
# Local CPP defines
localDefines = Util.ExtractNames(package.ResolvedBuildAllPrivateDefines)
localDefines += Util.ExtractNames(package.ResolvedBuildAllPublicDefines)
localDefineNames = MakeFileHelper.CreateList(localDefines)
content = content.replace("##PACKAGE_DEFINES##", localDefineNames)
#if package.Type == PackageType.Executable:
#libraryDependencies = self.__GetLibraryDependencies(config, package)
#libraryDependencies = MakeFileHelper.CreateList(libraryDependencies)
#build = build.replace("##PACKAGE_LIBRARY_DEPENDENCIES##", libraryDependencies)
if not config.DisableWrite:
IOUtil.WriteFileIfChanged(dstFile, content)
#remove this if statement if build scripts are required also for libraries
if package.Type == PackageType.Executable:
self.__GenerateBuildScript(config, package, self.BldTemplate, buildBasePath)
def _CreateDirectory(self, path: str) -> None:
if not IOUtil.IsDirectory(path):
self.LogPrint("- Creating '{0}' as it was missing".format(path))
IOUtil.SafeMakeDirs(path)
def __RunCMakeAndBuild(self, sourcePackage: Package,
toolFinder: PackageToolFinder,
recipeVariants: List[str], sourcePath: str,
installPath: str, tempBuildPath: str,
target: CMakeTargetType, cmakeProjectName: str,
configurationList: List[BuildVariantConfig],
cmakeOptionList: List[str],
allowSkip: bool) -> None:
installedDependencyList = self.__BuildDependencyPathList(
sourcePackage, sourcePackage.ResolvedExperimentalRecipeBuildOrder)
if len(recipeVariants) <= 0:
installedDependencies = self.__BuildDependencyPathString(
installedDependencyList)
if installedDependencies is not None and len(
installedDependencies) > 0:
cmakeOptionList = list(cmakeOptionList)
cmakeOptionList.append(installedDependencies)
self.Task.RunCMakeAndBuild(toolFinder, sourcePath, installPath,
tempBuildPath, target, cmakeProjectName,
configurationList, cmakeOptionList,
allowSkip)
return
for variant in recipeVariants:
self.BasicConfig.LogPrint("Recipe variant: {0}".format(variant))
self.BasicConfig.PushIndent()
try:
cmakeOptionListCopy = list(cmakeOptionList)
if len(installedDependencyList) > 0:
installedDependencyListCopy = [
IOUtil.Join(entry, variant)
for entry in installedDependencyList
]
installedDependencies = self.__BuildDependencyPathString(
installedDependencyListCopy)
cmakeOptionListCopy.append(installedDependencies)
if self._IsAndroid:
# FIX: Set this depending on package type
if not AndroidUtil.UseNDKCMakeToolchain():
optionList = [
"-DCMAKE_SYSTEM_VERSION={0}".format(
AndroidUtil.GetMinimumSDKVersion()),
"-DCMAKE_ANDROID_ARCH_ABI={0}".format(variant)
]
else:
optionList = [
"-DANDROID_PLATFORM=android-{0}".format(
AndroidUtil.GetMinimumSDKVersion()),
"-DANDROID_ABI={0}".format(variant)
]
cmakeOptionListCopy += optionList
installPathCopy = IOUtil.Join(installPath, variant)
tempBuildPathCopy = IOUtil.Join(tempBuildPath, variant)
IOUtil.SafeMakeDirs(tempBuildPathCopy)
self.Task.RunCMakeAndBuild(toolFinder, sourcePath,
installPathCopy, tempBuildPathCopy,
target, cmakeProjectName,
configurationList,
cmakeOptionListCopy, allowSkip)
finally:
self.BasicConfig.PopIndent()
