def __ResolveGeneratorVariableReport(self, report: PackageGeneratorVariableReportInfo) -> GeneratorVariableReport:
variabelReport = GeneratorVariableReport(self.Log, True)
for variableReport in report.VariableReport:
variabelReport.Add(variableReport.Name, variableReport.Options, variableReport.LinkTargetName)
for defaultOptionKey, defaultOptionValue in report.DefaultOptions.items():
variabelReport.SetDefaultOptionIndex(defaultOptionKey, defaultOptionValue)
return variabelReport
def __init__(self, variableReport: GeneratorVariableReport) -> None:
super().__init__()
self.VariableReportList = [
JsonPackageVariableReport(report)
for report in variableReport.GetVariableReportList()
]
self.DefaultOptions = variableReport.SYS_GetDefaultOptions(
) # type: Dict[str, int]
def GenerateVariableReport(log: Log, generatorName: str, package: Package) -> GeneratorVariableReport:
variableReport = GeneratorVariableReport(log)
# Add all the package variants
for variantEntry in package.ResolvedAllVariantDict.values():
variantEntryOptions = [option.Name for option in variantEntry.Options]
variableReport.Add(variantEntry.Name, variantEntryOptions)
# Gradle names for debug and release building
variableReport.Add(LocalMagicBuildVariants.GradleBuildConfig, ['assembleDebug', 'assembleRelease'], ToolAddedVariant.CONFIG)
# make builds default to release
#variableReport.SetDefaultOption(ToolAddedVariant.CONFIG, ToolAddedVariantConfigOption.Release)
return variableReport
def CreateLookupDict(
varCommandList: List[LookupVariableCommand],
generatorVariableReport: GeneratorVariableReport
) -> Tuple[Dict[str, LookupVariableCommand], List[LookupVariableCommand]]:
""" Returns
- Dict -> which is a lookup dict that maps variable names to their lookup command
- List -> a list of all LookupVariableCommand that are linked to something
"""
resultDict = {} # type: Dict[str, LookupVariableCommand]
linkedCommands = [] # type: List[LookupVariableCommand]
for varCommand in varCommandList:
resultDict[varCommand.Name] = varCommand
if varCommand.Report.LinkTargetName is not None:
linkedCommands.append(varCommand)
# Check if all linked commands have a 'command' to chain to, if not create a virtual one
for varCommand in linkedCommands:
linkedName = varCommand.Report.LinkTargetName
if linkedName is None:
raise Exception("entry.Report.LinkTargetName can not be None")
if linkedName not in resultDict:
variableValue = generatorVariableReport.TryGetVariableReport(
linkedName)
if variableValue is None:
raise FormatStringUndefinedVariableNameException(linkedName)
resultDict[linkedName] = LookupVariableCommand(
linkedName, variableValue, -1)
return (resultDict, linkedCommands)
def GenerateVariableReport(log: Log, generatorName: str,
package: Package) -> GeneratorVariableReport:
variableReport = GeneratorVariableReport(log)
# Add all the package variants
for variantEntry in package.ResolvedAllVariantDict.values():
variantEntryOptions = [
option.Name for option in variantEntry.Options
]
variableReport.Add(variantEntry.Name, variantEntryOptions)
# The make files generate executable files in debug mode with the postfix '_d'
variableReport.Add(LocalMagicBuildVariants.GeneratorExeFileExtension,
['_d', ''], ToolAddedVariant.CONFIG)
# make builds default to release
variableReport.SetDefaultOption(ToolAddedVariant.CONFIG,
ToolAddedVariantConfigOption.Release)
return variableReport
def _GenerateConfigVariableReport(
log: Log, generatorName: str, topLevelPackage: Package,
configVariantOptions: List[str]) -> GeneratorVariableReport:
variableReport = GeneratorVariableReport(
log, configVariantOptions=configVariantOptions)
# Add all the package variants
for variantEntry in topLevelPackage.ResolvedAllVariantDict.values():
variantEntryOptions = [
option.Name for option in variantEntry.Options
]
variableReport.Add(variantEntry.Name, variantEntryOptions)
# CMake names for debug and release building
variableReport.Add(LocalMagicBuildVariants.CMakeBuildConfig,
['Debug', 'Release'], ToolAddedVariant.CONFIG)
# make builds default to release
variableReport.SetDefaultOption(ToolAddedVariant.CONFIG,
ToolAddedVariantConfigOption.Release)
return variableReport
def Evaluate(condition: str, validVariableDict: Dict[str, object],
source: str) -> bool:
variableReport = GeneratorVariableReport()
for variableKey, variableValue in validVariableDict.items():
if isinstance(variableValue, str):
variableReport.Add(variableKey,
["'{0}'".format(variableValue)])
elif isinstance(variableValue, bool):
variableReport.Add(variableKey, ["{0}".format(variableValue)])
else:
raise Exception("Not supported")
processedCondition = ReportVariableFormatter.Format(
condition, variableReport, {})
# Do some validation on the condition to ensure it only contains the elements we want and support
astRootNode = EvaluateConditionInterpreter.__Parse(
processedCondition, condition, source)
nodeVisitor = EvaluateConditionNodeVisitor(source, processedCondition)
nodeVisitor.visit(astRootNode)
return EvaluateConditionInterpreter.__DoEvaluate(
astRootNode, validVariableDict)
def _GenerateVariableReport(
log: Log, generatorName: str, package: Package,
configVariantOptions: List[str],
isMasterBuild: bool) -> GeneratorVariableReport:
variableReport = GeneratorVariableReport(
log, configVariantOptions=configVariantOptions)
# Add all the package variants
for variantEntry in package.ResolvedAllVariantDict.values():
variantEntryOptions = [
option.Name for option in variantEntry.Options
]
variableReport.Add(variantEntry.Name, variantEntryOptions)
# The make files generate executable files in debug mode with the postfix '_d'
exeFileExtensionOptionList = ['_d', '']
# This is a bit ugly as we just assume coverage will be last
if ToolAddedVariantConfigOption.Coverage in configVariantOptions:
exeFileExtensionOptionList.append('_c')
variableReport.Add(LocalMagicBuildVariants.GeneratorExeFileExtension,
exeFileExtensionOptionList, ToolAddedVariant.CONFIG)
# CMake names for debug and release building
variableReport.Add(LocalMagicBuildVariants.CMakeBuildConfig,
['Debug', 'Release'], ToolAddedVariant.CONFIG)
# make builds default to release
variableReport.SetDefaultOption(ToolAddedVariant.CONFIG,
ToolAddedVariantConfigOption.Release)
return variableReport
def Format(
strFormat: str,
generatorVariableReport: GeneratorVariableReport,
userVariantSettingDict: Dict[str, str],
environmentVariableResolveMethod:
FormatStringEnvironmentVariableResolveMethod = FormatStringEnvironmentVariableResolveMethod
.Lookup
) -> str:
environmentVariableResolver = TryGetEnvironmentVariableResolveMethod(
environmentVariableResolveMethod)
parsedFormatString = ParsedFormatString(strFormat,
generatorVariableReport,
environmentVariableResolver)
sourceVariableDict, linkedVariables = CreateLookupDict(
parsedFormatString.VarCommandList, generatorVariableReport)
linkedCommandDict = GetLinkedCommandList(linkedVariables,
sourceVariableDict)
variableList = [] # type: List[LookupVariableCommand]
variableOptionIndices = [] # type: List[int]
# the ordering of the sourceVariableDict.values is pretty random, but it doesnt matter
for command in sourceVariableDict.values():
if command.Report.LinkTargetName is None:
variableList.append(command)
if command.Name in userVariantSettingDict:
userDefinedOptionName = userVariantSettingDict[
command.Name]
if userDefinedOptionName not in command.Report.Options:
raise InvalidVariableOptionNameException(
command.Name, userDefinedOptionName,
str(command.Report.Options))
variableOptionIndex = command.Report.Options.index(
userDefinedOptionName)
else:
defaultOptionIndex = generatorVariableReport.TryGetDefaultOptionIndex(
command.Name)
variableOptionIndex = 0 if defaultOptionIndex is None else defaultOptionIndex
variableOptionIndices.append(variableOptionIndex)
elif command.Name in userVariantSettingDict:
raise Exception(
"A linked variable '{0}' was found in the user feature list, this indicates a internal error"
.format(command.Name))
# Substitute the (env) variables with their values
scratchpadFormatList = parsedFormatString.SplitList # type: List[str]
return GetFormattedString(scratchpadFormatList, variableList,
variableOptionIndices,
parsedFormatString.EnvCommandList,
linkedCommandDict)
def __AddCustomVariables(self, variableReport: GeneratorVariableReport,
projectInfo: ToolConfigProjectInfo) -> None:
variableReport.Add(
'TopProjectRoot',
[projectInfo.TopProjectContext.Location.ResolvedPath])
def GetBuildDir(projectInfo: ToolConfigProjectInfo, buildDir: str) -> str:
variableReport = GeneratorVariableReport()
BuildUtil.AddCustomVariables(variableReport, projectInfo)
return ReportVariableFormatter.Format(buildDir, variableReport, {})
