def __init__(self, filename: str, strPackageName: Optional[str], packageLocation: ToolConfigPackageLocation) -> None: super(PackageFile, self).__init__() if not IOUtil.IsAbsolutePath(filename): raise UsageErrorException() if not isinstance(packageLocation, ToolConfigPackageLocation): raise UsageErrorException() filename = IOUtil.NormalizePath(filename) if not filename.startswith(packageLocation.ResolvedPathEx): raise UsageErrorException( "The filename '{0}' does not belong to the supplied location '{1}'" .format(filename, packageLocation.ResolvedPathEx)) self.Filename = IOUtil.GetFileName(filename) self.RelativeFilePath = filename[ len(packageLocation.ResolvedPathEx ):] # The full relative path to the file self.RelativeDirPath = IOUtil.GetDirectoryName( self.RelativeFilePath) # The relative containing directory self.AbsoluteFilePath = filename # type: str self.AbsoluteDirPath = IOUtil.GetDirectoryName(filename) # type: str self.PackageRootLocation = packageLocation # type: ToolConfigPackageLocation self.PackageName = self.__DeterminePackageNameFromRelativeName( self.RelativeDirPath ) if strPackageName is None else strPackageName # type: str
def __GetGenerator(self, pluginId: str, generatorType: GeneratorType, allowAll: bool) -> GeneratorPlugin: pluginId = pluginId.lower() generatorPluginDict = self.__GeneratorPluginDict if not pluginId in generatorPluginDict: raise UsageErrorException( "Unknown platform: '{0}'".format(pluginId)) if pluginId == PluginSharedValues.PLATFORM_ID_ALL and not allowAll: raise UsageErrorException( "Platform '{0}' is not allowed".format(pluginId)) if generatorType == GeneratorType.CMake: platformName = generatorPluginDict[pluginId].PlatformName return GeneratorPluginCMakeBase(platformName) elif generatorType == GeneratorType.Legacy: platformName = generatorPluginDict[pluginId].PlatformName if platformName == PlatformNameString.UBUNTU: legacyUbuntuGenerator = GeneratorPluginUbuntuLegacy() return legacyUbuntuGenerator elif platformName == PlatformNameString.YOCTO: legacyYoctoGenerator = GeneratorPluginYoctoLegacy() return legacyYoctoGenerator elif platformName == PlatformNameString.QNX: legacyQnxGenerator = GeneratorPluginQNXLegacy() return legacyQnxGenerator return generatorPluginDict[pluginId]
def __ResolvePaths(self, config: Config, filename: str, allowNoInclude: bool) -> None: if not os.path.isabs(filename): raise UsageErrorException() self.AbsolutePath = IOUtil.GetDirectoryName(filename) if not self.IsVirtual: sourcePath = self.BaseSourcePath if self.PackageLanguage == PackageLanguage.CPP: self.__ResolvePathIncludeDir(config, allowNoInclude) elif self.PackageLanguage == PackageLanguage.CSharp: #sourcePath = self.Name pass else: raise UnsupportedException( "Unsupported package language: {0}".format( self.PackageLanguage)) self.AbsoluteSourcePath = IOUtil.Join(self.AbsolutePath, sourcePath) self.AbsoluteContentPath = IOUtil.Join(self.AbsolutePath, "Content") self.AbsoluteContentSourcePath = IOUtil.Join( self.AbsolutePath, "Content.bld") if not os.path.isdir(self.AbsoluteSourcePath ) and not config.DisableSourceDirCheck: raise PackageMissingRequiredSourceDirectoryException( self.AbsoluteSourcePath) elif self.Type == PackageType.HeaderLibrary: if self.PackageLanguage == PackageLanguage.CPP: self.__ResolvePathIncludeDir(config, allowNoInclude) else: raise UsageErrorException( "HeaderLibrary is only supported for C++")
def GetGeneratorPluginById(pluginId: str, allowAll: bool) -> GeneratorPlugin: pluginId = pluginId.lower() if not pluginId in __g_generatorPluginDict: raise UsageErrorException("Unknown platform: '{0}'".format(pluginId)) if pluginId == PluginSharedValues.PLATFORM_ID_ALL and not allowAll: raise UsageErrorException( "Platform '{0}' is not allowed".format(pluginId)) return __g_generatorPluginDict[pluginId]
def GetCircularDependencyString(self, srcList: List[DependencyGraphNode]) -> str: if srcList is None or len(srcList) < 1: raise UsageErrorException( "No circular dependency exist in the supplied list") try: index = srcList.index(srcList[-1]) return self.GetNameListString(srcList[index:], "->") except ValueError: raise UsageErrorException( "No circular dependency exist in the supplied list")
def GetCircularDependencyString(self, srcList: List[DependencyGraphNode]) -> str: if srcList is None or len(srcList) < 1: raise UsageErrorException( "No circular dependency exist in the supplied list") try: # Since the last element is where the circular dependency is detected # we need to find the first occurrance of the last element index = srcList.index(srcList[-1]) return self.GetNameListString(srcList[index:], "->") except ValueError: raise UsageErrorException( "No circular dependency exist in the supplied list")
def ToPath(rootDirectories: List[ToolConfigRootDirectory], path: str) -> str: """ convert to a path that we know reside in one of the package roots """ if path.find("\\") >= 0: raise UsageErrorException("Backslash found in the supplied path '{0}'".format(path)) for rootDir in rootDirectories: if path.startswith(rootDir.ResolvedPathEx): lenRootPath = len(rootDir.ResolvedPathEx) path = path[lenRootPath:] return rootDir.Name + "/" + Util.UTF8ToAscii(path) elif path == rootDir.ResolvedPath: return rootDir.Name + "/" raise UsageErrorException("the folder '{0}' does not reside inside one of the root dirs".format(path))
def ToBashPath(self, path: str) -> str: if path.find("\\") >= 0: raise UsageErrorException( "Backslash found in the supplied path '{0}'".format(path)) for rootDir in self.RootDirectories: if path.startswith(rootDir.ResolvedPathEx): lenRootPath = len(rootDir.ResolvedPathEx) path = path[lenRootPath:] return rootDir.BashName + "/" + Util.UTF8ToAscii(path) elif path == rootDir.ResolvedPath: return rootDir.Name + "/" raise UsageErrorException( "the folder '{0}' does not reside inside one of the root dirs". format(path))
def __GetGenerator(self, pluginId: str, defaultPackageLanguage: PackageLanguage, generatorType: GeneratorType) -> GeneratorPlugin: pluginId = pluginId.lower() generatorPluginDict = self.__GeneratorPluginDict if not pluginId in generatorPluginDict: raise UsageErrorException( "Unknown platform: '{0}'".format(pluginId)) if generatorType == GeneratorType.CMake: platformName = generatorPluginDict[pluginId].PlatformName return GeneratorPluginCMakeBase(self.__Log, platformName) elif generatorType == GeneratorType.Legacy: platformName = generatorPluginDict[pluginId].PlatformName if platformName == PlatformNameString.UBUNTU: legacyUbuntuGenerator = GeneratorPluginUbuntuLegacy(self.__Log) return legacyUbuntuGenerator elif platformName == PlatformNameString.YOCTO: legacyYoctoGenerator = GeneratorPluginYoctoLegacy(self.__Log) return legacyYoctoGenerator elif platformName == PlatformNameString.WINDOWS: return GeneratorPluginWindowsLegacy(self.__Log) elif defaultPackageLanguage == PackageLanguage.CSharp: platformName = generatorPluginDict[pluginId].PlatformName if platformName == PlatformNameString.WINDOWS: return GeneratorPluginWindowsLegacy(self.__Log) return generatorPluginDict[pluginId]
def ToDosPathDirectConversion(self, path: str) -> str: """ This does not make the path relative to a root path """ if path.find("\\") >= 0: raise UsageErrorException( "Backslash found in the supplied path '{0}'".format(path)) path = Util.ChangeToDosEnvironmentVariables(path) return Util.UTF8ToAscii(path).replace('/', '\\')
def __ResolvePaths(self, configDisableIncludeDirCheck: bool, configDisableSourceDirCheck: bool, packagePath: PackagePath, allowNoInclude: bool) -> None: rootRelativeDirPath = packagePath.RootRelativeDirPath if not self.IsVirtual: sourcePath = self.BaseSourcePath if self.PackageLanguage == PackageLanguage.CPP: self.__ResolvePathIncludeDir(configDisableIncludeDirCheck, allowNoInclude) elif self.PackageLanguage == PackageLanguage.CSharp: #sourcePath = self.Name pass else: raise UnsupportedException("Unsupported package language: {0}".format(self.PackageLanguage)) self.SourcePath = PackagePath(IOUtil.Join(rootRelativeDirPath, sourcePath), packagePath.PackageRootLocation) self.ContentPath = PackagePath(IOUtil.Join(rootRelativeDirPath, ToolSharedValues.CONTENT_FOLDER_NAME), packagePath.PackageRootLocation) self.ContentSourcePath = PackagePath(IOUtil.Join(rootRelativeDirPath, ToolSharedValues.CONTENT_BUILD_FOLDER_NAME), packagePath.PackageRootLocation) if not os.path.isdir(self.SourcePath.AbsoluteDirPath) and not configDisableSourceDirCheck: raise PackageMissingRequiredSourceDirectoryException(self.SourcePath.AbsoluteDirPath) elif self.Type == PackageType.HeaderLibrary: if self.PackageLanguage == PackageLanguage.CPP: self.__ResolvePathIncludeDir(configDisableIncludeDirCheck, allowNoInclude) else: raise UsageErrorException("HeaderLibrary is only supported for C++")
def DoGetFiles(config: Config, toolMiniConfig: ToolMinimalConfig, currentDir: str, allowRecursiveScan: bool = False) -> List[str]: """ :param currentDir: currentDir must be part of a package root :param allowRecursiveScan: if True and not a sdk build all subdirectories will be scanned """ if allowRecursiveScan and config.IsSDKBuild: config.DoPrintWarning("recursive is ignored for sdk builds") if ToolConfigPackageRootUtil.TryFindRootDirectory( toolMiniConfig.RootDirectories, currentDir) is None: raise UsageErrorException( "the folder '{0}' does not reside inside one of the root dirs". format(currentDir)) theFiles = [] # type: List[str] if not config.IsSDKBuild: if allowRecursiveScan: theFiles += IOUtil.FindFileByName(currentDir, config.GenFileName, toolMiniConfig.IgnoreDirectories) else: theFile = IOUtil.Join(currentDir, config.GenFileName) if not os.path.isfile(theFile): raise Exception("File not found: '{0}'".format(theFile)) theFiles.append(theFile) return theFiles
def FindProjectContext(contexts: List[ToolConfigProjectContext], path: str) -> ToolConfigProjectContext: context = ToolConfigPackageProjectContextUtil.TryFindToProjectContext( contexts, path) if context is None: raise UsageErrorException( "Could not locate a context for path '{0}'".format(path)) return context
def __init__(self, log: Log, xmlElement: ET.Element, subPackageSupport: SubPackageSupportConfig) -> None: if not isinstance(subPackageSupport, SubPackageSupportConfig): raise UsageErrorException("The support object was not of the correct type") super().__init__(log, xmlElement) self.SystemSubPackageSupport = subPackageSupport # type: SubPackageSupportConfig self.ExternalDependencies = self.__GetXMLExternalDependencies(xmlElement) self.DirectDefines = self.__GetXMLDefines(xmlElement) self.DirectDependencies = self._GetXMLDependencies(xmlElement)
def AddNodeAndEdges(self, package: Package) -> None: if not package in self.UniqueNodeDict: newNode = DependencyGraphNode(package) for dep in package.ResolvedDirectDependencies: if not dep.Package in self.UniqueNodeDict: raise UsageErrorException( "Unknown dependency to: '{0}'".format(dep.Name)) newNode.AddEdge(self.UniqueNodeDict[dep.Package]) self.UniqueNodeDict[package] = newNode self.Nodes.append(newNode)
def __init__(self, path: str, location: ToolConfigPackageLocation) -> None: super().__init__() if not isinstance(location, ToolConfigPackageLocation): raise UsageErrorException( "the supplied location was not of the type ToolConfigPackageLocation" ) self.Path = path self.Location = location
def ToPath(rootDirectories: List[ToolConfigRootDirectory], path: str) -> str: """ convert to a path that we know reside in one of the package roots """ foundPath = ToolConfigPackageRootUtil.TryToPath(rootDirectories, path) if foundPath is not None: return foundPath raise UsageErrorException( "the folder '{0}' does not reside inside one of the root dirs". format(path))
def __init__(self, path: str, packageLocation: ToolConfigPackageLocation, normalize: bool = True) -> None: super().__init__() path = IOUtil.NormalizePath(path) if normalize else path if not isinstance(packageLocation, ToolConfigPackageLocation): raise UsageErrorException() if IOUtil.IsAbsolutePath(path): if not path.startswith(packageLocation.ResolvedPathEx): raise UsageErrorException("The path '{0}' does not belong to the supplied location '{1}'".format(path, packageLocation.ResolvedPathEx)) rootRelativeDirPath = path[len(packageLocation.ResolvedPathEx):] absoluteDirPath = path else: rootRelativeDirPath = path absoluteDirPath = IOUtil.Join(packageLocation.ResolvedPath, path) self.RootRelativeDirPath = rootRelativeDirPath # The root relative containing directory self.AbsoluteDirPath = absoluteDirPath # type: str self.PackageRootLocation = packageLocation # type: ToolConfigPackageLocation
def CreatePackage(self, config: Config, platformName: str, genFile: XmlGenFile, insertAtFront: bool = False) -> Package: if genFile.Name in self.OriginalPackageDict: raise UsageErrorException("Package '{0}' already exist".format(genFile.Name)) packageProjectContext = self.__FindProjectContext(config, genFile) package = self.__PackageFactoryFunction(config, self.__GeneratorInfo, genFile, packageProjectContext) self.__ResolvePackageDependencies(platformName, package) if not insertAtFront: self.Packages.append(package) else: self.Packages.insert(0, package) self.OriginalPackageDict[package.Name] = package return package
def GetGeneratorPluginById( pluginId: str, generatorType: int, allowAll: bool, cmakeConfiguration: CMakeConfiguration, userCMakeConfig: Optional[UserCMakeConfig]) -> GeneratorPlugin: pluginId = pluginId.lower() if not pluginId in __g_generatorPluginDict: raise UsageErrorException("Unknown platform: '{0}'".format(pluginId)) if pluginId == PluginSharedValues.PLATFORM_ID_ALL and not allowAll: raise UsageErrorException( "Platform '{0}' is not allowed".format(pluginId)) if generatorType == GeneratorType.CMake: platformName = __g_generatorPluginDict[pluginId].PlatformName cmakeGenerator = GeneratorPluginCMakeBase(platformName) cmakeGenerator.DotEnabled = __g_globalContext.DotEnabled cmakeGenerator.ToolVersion = __g_globalContext.VSVersion cmakeGenerator.CMakeConfig = CMakeConfigUtil.BuildGeneratorCMakeConfig( platformName, userCMakeConfig, cmakeConfiguration, cmakeGenerator.ToolVersion) cmakeGenerator.SetLegacyGeneratorType( __g_globalContext.LegacyGeneratorType) return cmakeGenerator return __g_generatorPluginDict[pluginId]
def GetRequirementList(topLevelPackage: Package, requestedPackages: Optional[List[Package]], requirementType: Optional[str] = None) -> List[PackageRequirement]: """ Generate a requirement list based on input, the requirement list can be optionally filtered by requirementType. If requestedPackages are None then then all packages used by the top level package will be filtered. If a top level package is supplied then we return the 'ResolvedAllRequirements' for it (filtered as requested). """ if topLevelPackage is None: raise UsageErrorException("topLevelPackage can not be None") if requestedPackages is None or len(requestedPackages) <= 0: # Since no files were supplied we use the topLevelPackage return RequirementFilter.FilterRequirementsByType(topLevelPackage.ResolvedAllRequirements, requirementType) return RequirementFilter.GetRequirementListFromPackages(requestedPackages, requirementType)
def __init__(self, filename: str, strPackageName: Optional[str], packageLocation: ToolConfigPackageLocation) -> None: filename = IOUtil.NormalizePath(filename) if not IOUtil.IsAbsolutePath(filename): raise UsageErrorException() rootRelativePath = filename[len(packageLocation.ResolvedPathEx):] super().__init__(IOUtil.GetDirectoryName(rootRelativePath), packageLocation, False) self.Filename = IOUtil.GetFileName(filename) self.RootRelativeFilePath = rootRelativePath # The full root relative path to the file self.AbsoluteFilePath = filename # type: str self.PackageName = self.__DeterminePackageNameFromRelativeName( self.RootRelativeDirPath ) if strPackageName is None else strPackageName # type: str
def __FindProjectContext(self, config: Config, genFile: XmlGenFile) -> PackageProjectContext: """ Associate the package with the 'project' that it belongs to """ if genFile.PackageLocation is None: if genFile.Type != PackageType.TopLevel: raise UsageErrorException("Package '{0}' did not contain a valid location".format(genFile.Name)) # The top level package is not associated with a project context topLevelProjectContext = PackageProjectContext(ProjectId("__TopLevel__"), "__TopLevel__", "0.0.0.0", []) self.__ProjectContextCache.Add(topLevelProjectContext) return topLevelProjectContext projectContext = ToolConfigPackageProjectContextUtil.FindProjectContext(config.ToolConfig.ProjectInfo.Contexts, genFile.PackageLocation.ResolvedPath) basePackages = self.__CreateBasePackageList(projectContext.BasePackages) packageProjectContext = self.__ProjectContextCache.TryGet(projectContext.ProjectName) if packageProjectContext is None: packageProjectContext = PackageProjectContext(projectContext.ProjectId, projectContext.ProjectName, projectContext.ProjectVersion, basePackages) self.__ProjectContextCache.Add(packageProjectContext) return packageProjectContext
def Extend(self, variant: 'PackagePlatformVariant', extendingPackageName: str) -> 'PackagePlatformVariant': if not variant.AllowExtend: raise VariantNotMarkedAsExtendingException(self, variant) extendedVariant = PackagePlatformVariant(extendingPackageName, self, False) extendedVariant.ExtensionInfo = "{0}<-{1}".format( self.IntroducedByPackageName, extendingPackageName) dstOptions = extendedVariant.Options srcOptions = variant.Options for entry in srcOptions: index = self.__IndexOf(dstOptions, entry.Name) if index >= 0: dstOptions[index] = dstOptions[index].Extend( entry, extendingPackageName) else: raise UsageErrorException( "A extending variant can not introduce new options") extendedVariant.__BuildOptionDict(dstOptions) return extendedVariant
def CreatePackage(self, log: Log, configBuildDir: str, configIgnoreNotSupported: bool, toolConfig: ToolConfig, platformName: str, hostPlatformName: str, genFile: XmlGenFile, insertAtFront: bool = False) -> Package: filePackageInstanceName = PackageInstanceName(genFile.Name) if filePackageInstanceName in self.OriginalPackageDict: raise UsageErrorException("Package '{0}' already exist".format(filePackageInstanceName)) createContext = PackageManager.__CreateFactoryCreateContext(log, toolConfig, self.__GeneratorInfo) packageProjectContext = self.__FindProjectContext(toolConfig, genFile) processedPackage = PackageManager.__AllocatePreprocessedPackage(createContext, packageProjectContext, configIgnoreNotSupported, platformName, hostPlatformName, genFile, True) packageLookupDict = PreResolver.CreatePackageLookupDict(self.__unresolvedPackages) preResolvedPackageResult = PreResolver.PreResolvePackage(log, packageLookupDict, processedPackage, 0xffffffff) package = Package(log, configBuildDir, preResolvedPackageResult) self.__ResolvePackageDependencies(package, self.OriginalPackageDict) if not insertAtFront: self.Packages.append(package) else: self.Packages.insert(0, package) self.OriginalPackageDict[package.NameInfo.FullName] = package return package