def __GetExternalLibraryDependencies(self, package: Package) -> List[Tuple[str, str]]:
libsAndPaths = [] # type: List[Tuple[str, str]]
buildOrder = list(package.ResolvedBuildOrder)
for entry in buildOrder:
depList = Util.FilterByType(entry.ResolvedDirectExternalDependencies, ExternalDependencyType.StaticLib)
for dep in depList:
libName = dep.Name
libPath = dep.Location
libsAndPaths.append((libName, libPath))
return libsAndPaths
def __ParseCMakeVersionString(self,
versionStr: Optional[str]) -> CMakeVersion:
toolMin = CMakeUtil.GetMinimumVersion()
if versionStr is None:
return toolMin
parsedMinVersion = Util.ParseVersionString(versionStr, maxValues=3)
while len(parsedMinVersion) < 3:
parsedMinVersion.append(0)
projectMin = CMakeVersion(parsedMinVersion[0], parsedMinVersion[1],
parsedMinVersion[2])
return projectMin if projectMin >= toolMin else toolMin
def __ValidateName(self) -> None:
name = self.Name
trimmed = name.strip()
if trimmed != name:
raise Exception("Name contained leading or ending whitespaces'{0}'".format(name))
if len(name) <= 0:
raise Exception("Name length must be greater than zero")
if not Util.IsValidComamndName(name):
raise Exception("Name must start with a a-z or A-Z and can only contain a-z,A-Z,0-9,_ and - '{0}'".format(name))
if name.lower() in g_bannedCommands:
raise Exception("The command '{0}' is banned".format(name))
def PrintExecutableSkipReason(log: Log, fullPackageList: List[Package],
filteredPackageList: List[Package]) -> None:
for package in fullPackageList:
if package.Type == PackageType.Executable:
if package.ResolvedPlatformNotSupported:
notSupported = LocalUtil.BuildListOfDirectlyNotSupported(
package)
notSupportedNames = Util.ExtractNames(notSupported)
log.DoPrint(
"{0} was marked as not supported on this platform by package: {1}"
.format(package.Name, notSupportedNames))
def __TryValidateCommandVersion(self, cmd: str, versionCommand: str, versionRegEx: str, minVersion: Optional[str],
addOnErrorWarning: List[XmlRecipeValidateCommandFindExecutableFileInPathAddOnErrorWarning]) -> List[int]:
output = ""
try:
runCmd = [cmd, versionCommand]
with subprocess.Popen(runCmd, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, universal_newlines=True) as proc:
output = proc.stdout.read().strip()
proc.stdout.close()
result = proc.wait()
if result != 0:
self.__BasicConfig.LogPrintWarning("The command '{0}' failed with '{1}'".format(" ".join(runCmd), result))
return []
except FileNotFoundError:
self.__BasicConfig.DoPrintWarning("The command '{0}' failed with 'file not found'.".format(" ".join(runCmd)))
return []
match = re.search(versionRegEx, output)
if match is None:
self.__BasicConfig.DoPrintWarning("The regex '{0}' did not capture the version".format(versionRegEx))
return []
if len(match.groups()) > 1:
self.__BasicConfig.DoPrintWarning("The regex '{0}' captured more than one group: {1}".format(versionRegEx, match.groups))
if len(match.groups()) != 1:
self.__BasicConfig.DoPrintWarning("The regex '{0}' did not capture a group with version information".format(versionRegEx))
matchResult = match.group(1)
try:
# time to parse the version string
foundVersionList = Util.ParseVersionString(matchResult, maxValues=4)
if minVersion is not None:
minVersionList = Util.ParseVersionString(minVersion, maxValues=4)
if len(minVersionList) > len(foundVersionList):
self.__BasicConfig.DoPrintWarning("The regex '{0}' did not capture the enough version number elements to compare against the min version '{1}'".format(versionRegEx, minVersion))
return []
self.__BasicConfig.LogPrint(" Found version {0} expected minVersion {1}".format(matchResult, minVersion))
if not self.__CheckVersion(minVersionList, foundVersionList):
return []
self.__CheckOnErrorWarnings(foundVersionList, versionRegEx, addOnErrorWarning)
return foundVersionList
except Exception as ex:
self.__BasicConfig.DoPrintWarning("Failed to parse version string: {0}".format(str(ex)))
return []
def __ValidateRequirementList(requirementNameList: List[str],
strHelpListName: str,
strHelpEntryName: str) -> None:
if len(requirementNameList) <= 0 or requirementNameList[0] == '*':
return
for entry in requirementNameList:
if not Util.IsValidRequirementName(entry):
raise Exception(
"The {0} must be valid, the {1} name '{2}' is not a valid {1} name in list {3}"
.format(strHelpListName, strHelpEntryName, entry,
requirementNameList))
def __FiltersPackagesBySupported(log: Log, packages: Union[List[Package], List[AppInfoPackage]]) -> List[T]:
""" Remove packages that are marked as not supported by the platform
"""
packageList = []
for package in packages:
if not package.ResolvedPlatformNotSupported:
packageList.append(package)
elif not package.Type == PackageType.TopLevel and log.IsVerbose and isinstance(package, Package):
notSupported = LocalUtil.BuildListOfDirectlyNotSupported(package)
notSupportedNames = Util.ExtractNames(notSupported)
log.DoPrint("Skipping {0} since its marked as not supported on this platform by package: {1}".format(package.Name, notSupportedNames))
return cast(List[T], packageList)
def __init__(self, log: Log, requirementTypes: List[str],
xmlElement: ET.Element) -> None:
super().__init__(log, xmlElement)
self.Name = self._ReadAttrib(xmlElement, 'Name') # type: str
self.Type = self._ReadAttrib(xmlElement, 'Type') # type: str
self.Extends = self._ReadAttrib(xmlElement, 'Extends', '') # type: str
self.Version = self._ReadAttrib(xmlElement, 'Version', '') # type: str
if not Util.IsValidRequirementName(self.Name):
raise XmlRequirementNameException(xmlElement, self.Name)
if not self.Type in requirementTypes:
raise XmlRequirementTypeException(xmlElement, self.Name, self.Type,
self.Extends, requirementTypes)
if len(self.Extends) > 0 and not Util.IsValidRequirementName(
self.Extends):
raise XmlRequirementStringException(xmlElement, "extends",
self.Extends)
if self.Type == PackageRequirementTypeString.Extension and len(
self.Extends) == 0:
raise XmlRequirementTypeExtensionRequiresAValidExtendFieldException(
xmlElement, self.Name)
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 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 AddNew(self, packageName: str, packageProjectId: str) -> None:
if not Util.IsValidPackageName(packageName):
raise InvalidPackageNameException(packageName)
if packageProjectId in self.__projectIdToNameDict:
raise Exception(
"Package '{0}' uses project id '{1}' already used by package: '{2}'"
.format(packageName, packageProjectId,
self.__projectIdToNameDict[packageProjectId]))
if packageName in self.__projectIdCache.ProjectIdDict:
raise Exception("Package '{0}' already added".format(packageName))
self.__projectIdCache.Add(packageName, packageProjectId)
self.__projectIdToNameDict[packageProjectId] = packageName
def BuildTargetLinkLibrariesForDirectDependencies(
config: Config,
package: Package,
templatePackageDependencyTargetLinkLibraries: str,
ignoreLibs: Optional[List[str]] = None) -> str:
if ignoreLibs is None:
ignoreLibs = []
if package.ResolvedDirectDependencies is None:
raise Exception("Invalid package")
isExternalLibrary = package.Type == PackageType.ExternalLibrary
deps = ""
for entry1 in package.ResolvedDirectDependencies:
if entry1.Package.Type != PackageType.ToolRecipe:
deps += "\n {0} {1}".format(
GetAccessTypeString(package, entry1.Access, False),
GetPackageName(entry1.Package))
# deps += "\n {0} {1}".format(GetAccessTypeString(package, entry1.Access), GetAliasPackageName(entry1.Package))
# FIX: handle debug libraries
for entry2 in package.ResolvedDirectExternalDependencies:
libraryName = LibUtil.ToUnixLibName(entry2.Name)
if libraryName not in ignoreLibs:
if entry2.Type == ExternalDependencyType.StaticLib:
location = entry2.Location if entry2.Location and not isExternalLibrary else ""
fullPathLinkDir = Util.ChangeToCMakeEnvVariables(
IOUtil.Join(location, libraryName))
deps += "\n {0} {1}".format(
GetAccessTypeString(package, entry2.Access, False),
fullPathLinkDir)
if entry2.Type == ExternalDependencyType.Find:
linkName = "${%s_LIBRARY}" % (libraryName)
deps += "\n {0} {1}".format(
GetAccessTypeString(package, entry2.Access, False),
linkName)
else:
config.LogPrintVerbose(
2, "INFO: Force ignored '{0}'".format(libraryName))
if len(deps) <= 0:
return ""
content = templatePackageDependencyTargetLinkLibraries
content = content.replace("##PACKAGE_DIRECT_DEPENDENCIES##", deps)
return content
def __CheckOnErrorWarning(
self, foundVersionList: List[int], versionRegEx: str, warning:
XmlRecipeValidateCommandFindExecutableFileInPathAddOnErrorWarning
) -> None:
startVersionList = Util.ParseVersionString(warning.StartVersion,
maxValues=4)
if len(startVersionList) > len(foundVersionList):
self.__Log.DoPrintWarning(
"The regex '{0}' did not capture the enough version number elements to compare against the start version '{1}'"
.format(versionRegEx, warning.StartVersion))
return # Its just a warning hint we can't display, so we log it and skip it for now
if self.__CheckVersion(startVersionList, foundVersionList):
# ok we passed the start version check for this warning hint
if warning.EndVersion is not None:
endVersionList = Util.ParseVersionString(warning.EndVersion,
maxValues=4)
if len(endVersionList) > len(foundVersionList):
self.__Log.DoPrintWarning(
"The regex '{0}' did not capture the enough version number elements to compare against the end version '{1}'"
.format(versionRegEx, warning.EndVersion))
return # Its just a warning hint we can't display, so we log it and skip it for now
if self.__CheckVersion(endVersionList, foundVersionList):
return
self.__ErrorHelpManager.AddOnErrorWarningHint(warning.Help)
def __init__(self, base: Union[UnresolvedPackageDefine, 'PackageDefine'],
introducedByPackageName: str,
fromPackageAccess: AccessType) -> None:
super().__init__(base.Name)
self.IntroducedByPackageName = introducedByPackageName # type: str
self.Value = base.Value # type: Optional[str]
self.Access = base.Access # type: AccessType
self.IsFirstActualUse = False # type: bool
self.ConsumedBy = base.ConsumedBy if isinstance(
base, PackageDefine) else None # type: Optional[Package]
# the access to the package this was received from
self.FromPackageAccess = fromPackageAccess # type: AccessType
if self.Value is not None and not Util.IsValidDefineValue(self.Value):
raise InvalidDefineValueException(self.Name, self.Value)
def __TryParseFlavor(self, flavor: Optional[str]) -> Dict[str, str]:
if flavor is None or len(flavor) <= 0:
return {}
uniqueIds = {} # type: Dict[str, str]
resDict = {} # type: Dict[str, str]
entries = flavor.split(',')
for entry in entries:
parts = entry.split('=')
if len(parts) != 2:
raise XmlFormatException(
"Dependency flavor constraint '{0}' not in the expected format 'flavor1=option, flavor2=option'"
.format(flavor))
key = parts[0].strip()
value = parts[1].strip()
if key in resDict:
raise XmlFormatException(
"Dependency flavor constraint key '{0}' already defined to '{1}'"
.format(key, resDict[key]))
keyId = key.upper()
if keyId in uniqueIds:
raise XmlFormatException(
"Dependency flavor constraint key '{0}' already collides with '{1}'"
.format(key, uniqueIds[keyId]))
if not Util.IsValidFlavorName(key):
raise XmlFormatException(
"Dependency flavor name '{0}' is invalid".format(key))
if not Util.IsValidFlavorOptionName(value):
raise XmlFormatException(
"Dependency flavor option '{1}' is invalid in {0}={1}".
format(key, value))
uniqueIds[keyId] = key
resDict[key] = value
return resDict
def ParseExtensionList(strExtensionList: str) -> ExtensionListManager:
parsedList = ParseList(strExtensionList, "extension", True)
if not '*' in parsedList:
newParsedList = []
for entry in parsedList:
# Do some minimal basic validation of the input
# All extensions has to be qualified with a feature "featureName:extensionName
values = entry.split(':')
if not len(values) == 2:
raise Exception(
"The extension list must be valid, the extension '{0}' did not follow the expected '<FeatureName>:<ExtensionName>' format"
.format(entry))
if not Util.IsValidRequirementName(values[0]):
raise Exception(
"The extension list must be valid, the extension '{0}' did not contain a valid feature name '{1}'"
.format(entry, values[0]))
if not Util.IsValidRequirementName(values[1]):
raise Exception(
"The extension list must be valid, the extension '{0}' did not contain a valid extension name '{1}'"
.format(entry, values[1]))
newParsedList.append(
QualifiedRequirementExtensionName(values[0], values[1]))
return ExtensionListManager(False, newParsedList)
return ExtensionListManager(True, [])
def __init__(self, projectIdDict: Dict[str, str]) -> None:
super().__init__()
self.Version = JsonProjectIdCache.CURRENT_VERSION
self.ProjectIdDict = projectIdDict
projectIdToNameDict = {} # type: Dict[str, str]
for packageName, packageProjectId in projectIdToNameDict.items():
if not Util.IsValidPackageName(packageName):
raise InvalidPackageNameException(packageName)
if packageProjectId in projectIdDict:
raise Exception(
"The package project id '{0}' is registered for multiple package names. First '{1}' Second '{2}'"
.format(packageProjectId, projectIdToNameDict[packageName],
packageName))
projectIdToNameDict[packageProjectId] = packageName
def __ValidateOptionNames(self) -> None:
if self.Type == VariantType.Normal:
for option in self.Options:
if not Util.IsValidName(option.Name):
raise XmlUnsupportedVariantOptionNameException(
option.XMLElement, option.Name)
elif self.Type == VariantType.Virtual:
if len(self.Options) != 1:
raise XmlInvalidVirtualVariantOptionException(
self.XMLElement, self.Name)
if not self.Options[0].Name == self.Name:
raise XmlUnsupportedVirtualVariantOptionNameException(
self.Options[0].XMLElement, self.Options[0].Name,
self.Name)
else:
raise XmlException(self.XMLElement, "Unknown variant type")
def __ResolveAndGenerate(config: Config, platformGeneratorPlugin: GeneratorPlugin, packageLoader: PackageLoader,
packageFilters: PackageFilters, isSDKBuild: bool) -> List[Package]:
generatorContext = GeneratorContext(config, config.ToolConfig.Experimental, platformGeneratorPlugin)
process = PackageLoadAndResolveProcess(config, packageLoader, platformGeneratorPlugin)
process.Resolve(generatorContext, packageFilters)
if not isSDKBuild:
for package in process.Packages:
if package.ResolvedPlatformNotSupported and package.Type != PackageType.TopLevel:
notSupported = LocalUtil.BuildListOfDirectlyNotSupported(package)
notSupportedNames = Util.ExtractNames(notSupported)
config.DoPrintWarning("{0} was marked as not supported on this platform by package: {1}".format(package.Name, notSupportedNames))
return platformGeneratorPlugin.Generate(generatorContext, config, process.Packages)
def __GetExternalLibraryPaths(
self, package: Package,
dependencyTypeFilter: List[int]) -> List[str]:
# GCC apparently needs the list to be in reverse order
buildOrder = list(package.ResolvedBuildOrder)
buildOrder.reverse()
additionalLibraryDirectories = set() # type: Set[str]
for currentPackage in buildOrder:
extDeps = Util.FilterByType(
currentPackage.ResolvedDirectExternalDependencies,
dependencyTypeFilter) # type: List[PackageExternalDependency]
for entry in extDeps:
if entry.Location is not None:
additionalLibraryDirectories.add(entry.Location)
result = list(additionalLibraryDirectories)
result.sort()
return result
def __init__(self, genFileName: str, template: XmlNewTemplateFile,
projectPath: str, projectName: str, packageName: str) -> None:
self.Template = template
self.ProjectName = projectName
self.ProjectPath = projectPath
self.PrefixedProjectName = template.Prefix + projectName
self.PackageName = packageName
self.PackageShortName, self.PackageNamespace = Util.GetPackageNames(
packageName)
self.PackageTargetName = packageName
self.ProjectPrefix = template.Prefix
self.ProjectPathInclude = os.path.join(projectPath, g_projectInclude)
self.ProjectPathSource = os.path.join(projectPath, g_projectSource)
self.TemplatePathCode = os.path.join(template.Path, g_templatePathCode)
self.TemplatePathFslGen = os.path.join(template.Path,
g_templatePathFslGen)
self.ConfigCode = ConfigCode(self.TemplatePathCode, projectPath,
projectName, self.PrefixedProjectName)
self.ConfigFslGen = ConfigFslGen(genFileName, self.TemplatePathFslGen,
projectPath, projectName,
self.PrefixedProjectName)
def __init__(self, name: str) -> None:
super().__init__()
if not Util.IsValidFlavorOptionName(name):
raise InvalidPackageFlavorOptionNameException(name)
self.Value = name
def __init__(self, name: str, allowInternalNames: bool = False) -> None:
super().__init__()
if (not allowInternalNames and not Util.IsValidUnresolvedPackageName(name)) or (allowInternalNames and not Util.IsValidPackageInstanceName(name)):
raise InvalidUnresolvedPackageNameException(name)
self.Value = name
def BuildTargetIncludeDirectories(
config: Config,
package: Package,
templatePackageTargetIncludeDirectories: str,
templatePackageTargetIncludeDirEntry: str,
pathType: int = CMakePathType.Relative) -> str:
isExternalLibrary = package.Type == PackageType.ExternalLibrary
publicIncludeDir = ""
if package.AbsoluteIncludePath:
pubIncPath = __GetPackageIncludePath(config, package,
package.AbsoluteIncludePath,
pathType)
accessString = "PUBLIC" if not package.IsVirtual else "INTERFACE"
publicIncludeDir = "\n" + __GenerateDirEntryString(
accessString, pubIncPath, templatePackageTargetIncludeDirEntry)
privateIncludeDir = ""
if package.AbsoluteSourcePath:
priIncPath = __GetPackageIncludePath(config, package,
package.AbsoluteSourcePath,
pathType)
accessString = "PRIVATE" if not package.IsVirtual else "INTERFACE"
privateIncludeDir = "\n" + __GenerateDirEntryString(
accessString, priIncPath, templatePackageTargetIncludeDirEntry)
for directExternalDeps in package.ResolvedDirectExternalDependencies:
if directExternalDeps.Type != ExternalDependencyType.Find:
currentIncDir = directExternalDeps.Include
if currentIncDir is not None:
if package.AbsolutePath is None:
raise Exception("Invalid package")
packageRootPath = config.ToPath(package.AbsolutePath)
if currentIncDir.startswith(packageRootPath):
relativeCurrentIncDir = currentIncDir[
len(packageRootPath) +
1:] if pathType == CMakePathType.LocalRelative else Util.ChangeToCMakeVariables(
currentIncDir)
add = "\n" + __GenerateDirEntryString(
GetAccessTypeString(package,
directExternalDeps.Access),
relativeCurrentIncDir,
templatePackageTargetIncludeDirEntry)
else:
relativeCurrentIncDir = config.ToPath(currentIncDir)
if relativeCurrentIncDir is None:
add = "\n {0} {1}".format(
GetAccessTypeString(package,
directExternalDeps.Access),
Util.ChangeToCMakeEnvVariables(currentIncDir))
else:
if pathType != CMakePathType.LocalRelative:
relativeCurrentIncDir = Util.ChangeToCMakeVariables(
relativeCurrentIncDir)
add = "\n" + __GenerateDirEntryString(
GetAccessTypeString(package,
directExternalDeps.Access),
relativeCurrentIncDir,
templatePackageTargetIncludeDirEntry)
if directExternalDeps.Access == AccessType.Public:
publicIncludeDir += add
else:
privateIncludeDir += add
else:
add = "\n %s ${%s_INCLUDE_DIRS}" % (GetAccessTypeString(
package, directExternalDeps.Access), directExternalDeps.Name)
if directExternalDeps.Access == AccessType.Public:
publicIncludeDir += add
else:
privateIncludeDir += add
if len(publicIncludeDir) <= 0 and len(privateIncludeDir) <= 0:
return ""
content = templatePackageTargetIncludeDirectories
content = content.replace("##PACKAGE_PUBLIC_INCLUDE_DIRECTORIES##",
publicIncludeDir)
content = content.replace("##PACKAGE_PRIVATE_INCLUDE_DIRECTORIES##",
privateIncludeDir)
return content
def __ValidateFlavorName(self) -> None:
if not Util.IsValidName(self.Name):
raise XmlUnsupportedFlavorNameException(self.XMLElement, self.Name)
def Add(self, packageName: str, packageProjectId: str) -> None:
if not Util.IsValidPackageName(packageName):
raise InvalidPackageNameException(packageName)
self.ProjectIdDict[packageName] = packageProjectId
def __ValidateOptionNames(self) -> None:
for option in self.Options:
if not Util.IsValidName(option.Name):
raise XmlUnsupportedFlavorOptionNameException(
option.XMLElement, option.Name)
def __init__(self,
source: str,
variableDict: Optional[VariableDict],
environmentVariableResolver: Optional[
FormatStringEnvironmentVariableResolver] = None,
noVariableResolve: bool = False,
noEnvVariableResolve: bool = False) -> None:
super().__init__()
self.SplitList = [] # type: List[str]
self.VarCommandList = [] # type: List[LookupVariableCommand]
self.EnvCommandList = [
] # type: List[LookupEnvironmentVariableCommand]
if source == "":
self.SplitList.append("")
return
state = ParseState.Scanning
startSplitIndex = 0
blockStartIndex = 0
for index, ch in enumerate(source):
if state == ParseState.Scanning:
if ch == '$':
state = ParseState.CommandStart
elif state == ParseState.CommandStart:
if ch == '{':
state = ParseState.VariableBlock
if startSplitIndex < index - 1:
self.SplitList.append(source[startSplitIndex:index -
1])
startSplitIndex = index - 1
blockStartIndex = index + 1
elif ch == '(':
state = ParseState.EnvBlock
if startSplitIndex < index - 1:
self.SplitList.append(source[startSplitIndex:index -
1])
startSplitIndex = index - 1
blockStartIndex = index + 1
#stringEndSplitIndex = blockStartIndex-2
elif state == ParseState.VariableBlock:
if ch == '}':
state = ParseState.Scanning
self.SplitList.append(source[startSplitIndex:index + 1])
startSplitIndex = index + 1
# Do the report lookup
variableName = (source[blockStartIndex:index])
if not Util.IsValidCStyleName(variableName):
raise FormatStringInvalidVariableNameException(
variableName)
if noVariableResolve:
variableValue = VariableReport(
"*NotDefined*", ["*NotDefined*"],
None) # type: Optional[VariableReport]
else:
variableValue = variableDict.TryGetVariableReport(
variableName) if variableDict is not None else None
if variableValue is None:
raise FormatStringUndefinedVariableNameException(
variableName)
self.VarCommandList.append(
LookupVariableCommand(variableName, variableValue,
len(self.SplitList) - 1))
#stringEndSplitIndex = blockStartIndex
elif state == ParseState.EnvBlock:
if ch == ')':
state = ParseState.Scanning
self.SplitList.append(source[startSplitIndex:index + 1])
startSplitIndex = index + 1
envName = source[blockStartIndex:index]
if not Util.IsValidCStyleName(envName):
raise FormatStringInvalidVariableNameException(envName)
if noEnvVariableResolve:
envValue = "*NotDefined*" # type: Optional[str]
elif environmentVariableResolver is None:
envValue = IOUtil.TryGetEnvironmentVariable(envName)
else:
envValue = environmentVariableResolver(envName)
if envValue is None:
raise FormatStringUndefinedEnvironmentVariableNameException(
envName)
self.EnvCommandList.append(
LookupEnvironmentVariableCommand(
envName, envValue,
len(self.SplitList) - 1))
if startSplitIndex < len(source):
self.SplitList.append(source[startSplitIndex:])
if state != ParseState.Scanning and state != ParseState.CommandStart:
if state == ParseState.VariableBlock:
raise FormatStringVariableMissingTerminationException(
"The string '{0}' is missing a terminating '}}' ".format(
source))
elif state == ParseState.EnvBlock:
raise FormatStringEnvironmentVariableMissingTerminationException(
"The string '{0}' is missing a terminating ')' ".format(
source))
raise FormatStringInvalidException(
"The string '{0}' contained invalid format codes".format(
source))
def __PurifyName(self, variantType: int, variantName: str) -> str:
if variantType == VariantType.Virtual:
variantName = Util.RemoveEnvironmentVariablePadding(variantName)
return variantName
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)
