def __init__(self, log: Log, configBuildDir: str, configIgnoreNotSupported: bool, toolConfig: ToolConfig, platformName: str,
hostPlatformName: str, basicBuildConfig: BasicBuildConfig, generatorInfo: GeneratorInfo, genFiles: List[XmlGenFile],
packageManagerFilter: PackageManagerFilter, writeGraph: bool) -> None:
super().__init__()
self.__GeneratorInfo = generatorInfo
self.__ProjectContextCache = ProjectContextCache()
createContext = PackageManager.__CreateFactoryCreateContext(log, toolConfig, generatorInfo)
# Handle flavor package resolving.
unresolvedInput = self.__CreateInitialUnresolvedPackageList(configIgnoreNotSupported, toolConfig, platformName, hostPlatformName, genFiles,
createContext)
unresolvedPackages = PackageManager2.Resolve2(basicBuildConfig, createContext, unresolvedInput, writeGraph)
unresolvedPackages = PackageManager.__Filter(log, unresolvedPackages, packageManagerFilter)
uniqueDict = {} # type: Dict[PackageInstanceName, Package]
for unresolvedPackage in unresolvedPackages:
if unresolvedPackage.SourcePackage.NameInfo.FullName not in uniqueDict:
uniqueDict[unresolvedPackage.SourcePackage.NameInfo.FullName] = Package(log, configBuildDir, unresolvedPackage)
else:
raise InternalErrorException("Package has been defined multiple times, this ought to have been caught earlier")
self.__unresolvedPackages = unresolvedPackages
self.OriginalPackageDict = uniqueDict
self.Packages = list(uniqueDict.values()) # type: List[Package]
# Resolve dependency package names -> actual package objects
for package in self.Packages:
self.__ResolvePackageDependencies(package, self.OriginalPackageDict)
def __init__(self, config: Config, platformName: str, genFiles: List[XmlGenFile]) -> None:
super().__init__()
self.__ProjectContextCache = ProjectContextCache()
self.__PackageFactoryFunction = _AllocatePackage
uniqueDict = {} # type: Dict[str, Package]
for genFile in genFiles:
if not genFile.Name in uniqueDict:
packageProjectContext = self.__FindProjectContext(config, genFile)
uniqueDict[genFile.Name] = self.__PackageFactoryFunction(config, genFile, packageProjectContext)
else:
raise InternalErrorException("Package has been defined multiple times, this ought to have been caught earlier")
self.OriginalPackageDict = uniqueDict
self.Packages = list(uniqueDict.values()) # type: List[Package]
# Resolve dependency package names -> actual package objects
for package in self.Packages:
self.__ResolvePackageDependencies(platformName, package)
def __CreateInitialUnresolvedPackageList(self, configIgnoreNotSupported: bool, toolConfig: ToolConfig, platformName: str, hostPlatformName: str,
genFiles: List[XmlGenFile], createContext: FactoryCreateContext) -> List[UnresolvedPackage]:
#clonedList = list(genFiles)
# Create a fake top level file and append it to the list
#topLevelGenFile = XmlGenFile(config, config.ToolConfig.DefaultPackageLanguage)
#topLevelGenFile.Name = PackageNameMagicString.TopLevelName
#topLevelGenFile.SetType(PackageType.TopLevel)
#clonedList.append(topLevelGenFile)
unresolvedPackageDict = {} # type: Dict[str, UnresolvedPackage]
for genFile in genFiles:
if genFile.Name not in unresolvedPackageDict:
packageProjectContext = self.__FindProjectContext(toolConfig, genFile)
unresolvedPackageDict[genFile.Name] = PackageManager.__AllocateUnresolvedPackage(createContext, packageProjectContext,
configIgnoreNotSupported, platformName,
hostPlatformName, genFile, False)
else:
raise InternalErrorException("Package has been defined multiple times, this ought to have been caught earlier")
return list(unresolvedPackageDict.values())
def __GenerateBuildFile(self, config: Config, generatorName: str,
package: Package, template: str,
dstMakeFilename: str) -> None:
if package.ShortName is None or package.Namespace is None or package.ResolvedMakeObjectPath is None or package.AbsolutePath is None:
raise Exception("Invalid Package")
name = GeneratorGNUmakefileUtil.GetTargetName(package)
installPath = package.Namespace
if package.Type == PackageType.Library:
name = "lib" + name
if package.ResolvedBuildSourceFiles is None or package.ResolvedBuildAllIncludeDirs is None or package.ResolvedBuildAllPrivateDefines is None or package.ResolvedBuildAllPublicDefines is None:
raise Exception("Invalid Package")
files = MakeFileHelper.CreateList(package.ResolvedBuildSourceFiles)
includeDirs = MakeFileHelper.CreateList(
package.ResolvedBuildAllIncludeDirs)
localDefines = Util.ExtractNames(
package.ResolvedBuildAllPrivateDefines)
localDefines += Util.ExtractNames(
package.ResolvedBuildAllPublicDefines)
localDefineNames = MakeFileHelper.CreateList(localDefines)
variantSection = self.__GetVariantSection(package)
if package.ResolvedMakeVariantNameHint is None:
raise InternalErrorException(
"Package '{0}' ResolvedMakeVariantNameHint can not be None".
format(package.Name))
variantName = package.ResolvedMakeVariantNameHint
build = template
build = build.replace("##PACKAGE_TARGET_NAME##", name)
build = build.replace("##PACKAGE_TARGET_INSTALL_PATH##", installPath)
build = build.replace("##PACKAGE_SOURCE_FILES##", files)
build = build.replace("##PACKAGE_INCLUDE_DIRS##", includeDirs)
build = build.replace("##PACKAGE_DEFINES##", localDefineNames)
build = build.replace("##PACKAGE_VARIANT_SECTION##", variantSection)
build = build.replace("##PACKAGE_OBJECT_PATH##",
package.ResolvedMakeObjectPath)
build = build.replace("##PACKAGE_VARIANT_NAME##", variantName)
if package.Type == PackageType.Executable:
libraryDependencies = self.__GetLibraryDependencies(
config, package)
strLibraryDependencies = MakeFileHelper.CreateList(
libraryDependencies)
build = build.replace("##PACKAGE_LIBRARY_DEPENDENCIES##",
strLibraryDependencies)
extLibraryDependencies = self.__GetExternalLibraryDependencies(
package)
strExtLibraryDependencies = MakeFileHelper.CreateList(
extLibraryDependencies)
build = build.replace("##PACKAGE_EXTERNAL_LIBRARY_DEPENDENCIES##",
strExtLibraryDependencies)
extLibraryPaths = self.__GetExternalLibraryPaths(
package,
[ExternalDependencyType.StaticLib, ExternalDependencyType.DLL])
strExtLibraryPaths = MakeFileHelper.CreateList(extLibraryPaths)
build = build.replace("##PACKAGE_EXTERNAL_LIBRARY_PATHS##",
strExtLibraryPaths)
extDllPaths = self.__GetExternalLibraryPaths(
package, [ExternalDependencyType.DLL])
strExtDllPaths = MakeFileHelper.CreateList(extDllPaths)
build = build.replace("##PACKAGE_EXTERNAL_DLL_PATHS##",
strExtDllPaths)
executableReport = GeneratorGNUmakefileUtil.TryGenerateExecutableReport(
config, generatorName, package)
if executableReport is not None:
variableReport = GeneratorGNUmakefileUtil.GenerateVariableReport(
config, generatorName, package, self.ConfigVariantOptions)
GitIgnoreHelper.AddFromBuildReport(self.GitIgnoreDict, package,
executableReport,
variableReport)
dstFile = IOUtil.Join(package.AbsolutePath, dstMakeFilename)
if not config.DisableWrite:
IOUtil.WriteFileIfChanged(dstFile, build)
GitIgnoreHelper.AddPathIfInPackageRoot(self.GitIgnoreDict, package,
dstFile)
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)