def ToXml(self, Header, BootModes, Events, Hobs, Key):
if self.ModuleType:
pass
AttributeList = [
['SupArchList',
GetStringOfList(Header.GetSupArchList())],
]
NodeList = [
['ModuleType', Header.GetModuleType()],
['Path', Header.GetModulePath()],
['PcdIsDriver', Header.GetPcdIsDriver()],
['UefiSpecificationVersion',
Header.GetUefiSpecificationVersion()],
['PiSpecificationVersion',
Header.GetPiSpecificationVersion()],
]
for Item in Header.GetSpecList():
Spec, Version = Item
SpecElem = CreateXmlElement('Specification', Spec, [],
[['Version', Version]])
NodeList.append(SpecElem)
for Item in BootModes:
Tmp = BootModeXml()
NodeList.append(Tmp.ToXml(Item, 'BootMode'))
for Item in Events:
Tmp = EventXml()
NodeList.append(Tmp.ToXml(Item, 'Event'))
for Item in Hobs:
Tmp = HobXml()
NodeList.append(Tmp.ToXml(Item, 'HOB'))
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, PcdError, Key):
if self.Expression:
pass
AttributeList = []
NodeList = []
if PcdError.GetValidValue():
Element1 = \
CreateXmlElement('ValidValueList', PcdError.GetValidValue(), [], \
[['Lang', PcdError.GetValidValueLang()]])
NodeList.append(Element1)
if PcdError.GetValidValueRange():
TansferedRangeStr = self.TransferValidRange2Expr(
PcdError.GetTokenSpaceGuidCName(), PcdError.GetCName(),
PcdError.GetValidValueRange())
Element1 = \
CreateXmlElement('ValidValueRange', \
TansferedRangeStr, [], [])
NodeList.append(Element1)
if PcdError.GetExpression():
NodeList.append(['Expression', PcdError.GetExpression()])
if PcdError.GetErrorNumber():
NodeList.append(['ErrorNumber', PcdError.GetErrorNumber()])
for Item in PcdError.GetErrorMessageList():
Element = \
CreateXmlElement('ErrorMessage', Item[1], [], [['Lang', Item[0]]])
NodeList.append(Element)
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def CreateToolsXml(Map, Root, Tag):
#
# Check if all elements in this section are empty
#
for Key in Map:
if len(Map[Key]) > 0:
break
else:
return
NodeList = [['Name', Map['Name']],
['Copyright', Map['Copyright']],
['License', Map['License']],
['Abstract', Map['Abstract']],
['Description', Map['Description']],
]
HeaderNode = CreateXmlElement('Header', '', NodeList, [])
NodeList = [HeaderNode]
for File in Map['FileList']:
AttrList = []
for Key in File[1]:
AttrList.append([Key, File[1][Key]])
NodeList.append(CreateXmlElement('Filename', File[0], [], AttrList))
Root.appendChild(CreateXmlElement(Tag, '', NodeList, []))
def ToXml(self, Dict, Key):
if self.UserExtensionSource:
pass
SourcesNodeList = []
for Item in Dict:
ValueList = Dict[Item]
(FileName, Family, FeatureFlag, SupArchStr) = Item
SourceFileNodeList = []
SourceFileNodeList.append(["FileName", FileName])
SourceFileNodeList.append(["Family", Family])
SourceFileNodeList.append(["FeatureFlag", FeatureFlag])
SourceFileNodeList.append(["SupArchList", SupArchStr])
for (TagName, ToolCode, Comment) in ValueList:
ValueNodeList = []
if not (TagName or ToolCode or Comment):
TagName = ' '
ToolCode = ' '
Comment = ' '
ValueNodeList.append(["TagName", TagName])
ValueNodeList.append(["ToolCode", ToolCode])
ValueNodeList.append(["Comment", Comment])
ValueNodeXml = CreateXmlElement('SourceFileOtherAttr', '', \
ValueNodeList, [])
SourceFileNodeList.append(ValueNodeXml)
SourceFileNodeXml = CreateXmlElement('SourceFile', '', \
SourceFileNodeList, [])
SourcesNodeList.append(SourceFileNodeXml)
Root = CreateXmlElement('%s' % Key, '', SourcesNodeList, [])
return Root
def ToXml(self, DistributionPackageHeader, Key):
if self.Header:
pass
Element1 = CreateXmlElement('Name', \
DistributionPackageHeader.GetName(), [], \
[['BaseName', \
DistributionPackageHeader.GetBaseName()]])
Element2 = CreateXmlElement('GUID', \
DistributionPackageHeader.GetGuid(), [], \
[['Version', \
DistributionPackageHeader.GetVersion()]])
AttributeList = []
if DistributionPackageHeader.ReadOnly != '':
AttributeList.append(['ReadOnly', str(DistributionPackageHeader.ReadOnly).lower()])
if DistributionPackageHeader.RePackage != '':
AttributeList.append(['RePackage', str(DistributionPackageHeader.RePackage).lower()])
NodeList = [Element1,
Element2,
['Vendor', DistributionPackageHeader.Vendor],
['Date', DistributionPackageHeader.Date],
['Copyright', DistributionPackageHeader.GetCopyright()],
['License', DistributionPackageHeader.GetLicense()],
['Abstract', DistributionPackageHeader.GetAbstract()],
['Description', \
DistributionPackageHeader.GetDescription()],
['Signature', DistributionPackageHeader.Signature],
['XmlSpecification', \
DistributionPackageHeader.XmlSpecification],
]
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, Dict, Key):
if self.UserExtensionBinary:
pass
BinariesNodeList = []
for Item in Dict:
ValueList = Dict[Item]
(FileName, FileType, FeatureFlag, SupArch) = Item
FileNodeList = []
FileNodeList.append(["FileName", FileName])
FileNodeList.append(["FileType", FileType])
FileNodeList.append(["FeatureFlag", ConvertNEToNOTEQ(FeatureFlag)])
FileNodeList.append(["SupArchList", SupArch])
for (Target, Family, TagName, Comment) in ValueList:
ValueNodeList = []
if not (Target or Family or TagName or Comment):
Target = ' '
Family = ' '
TagName = ' '
Comment = ' '
ValueNodeList.append(["Target", Target])
ValueNodeList.append(["Family", Family])
ValueNodeList.append(["TagName", TagName])
ValueNodeList.append(["Comment", Comment])
ValueNodeXml = CreateXmlElement('BinaryFileOtherAttr', '', \
ValueNodeList, [])
FileNodeList.append(ValueNodeXml)
FileNodeXml = CreateXmlElement('Binary', '', FileNodeList, [])
BinariesNodeList.append(FileNodeXml)
Root = CreateXmlElement('%s' % Key, '', BinariesNodeList, [])
return Root
def ToXml(self, ClonedFrom, Key):
if self.GUID:
pass
Element1 = CreateXmlElement('GUID', ClonedFrom.GetPackageGuid(), [],
[['Version', ClonedFrom.GetPackageVersion()]])
AttributeList = []
NodeList = [Element1]
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, BinaryFile, Key):
if self.FileNames:
pass
NodeList = []
FilenameList = BinaryFile.GetFileNameList()
SupportArch = None
for Filename in FilenameList:
Tmp = FilenameXml()
NodeList.append(Tmp.ToXml(Filename, 'Filename'))
SupportArch = Filename.SupArchList
AsBuildList = BinaryFile.GetAsBuiltList()
PatchPcdValueList = AsBuildList.GetPatchPcdList()
PcdExList = AsBuildList.GetPcdExList()
LibGuidVerList = AsBuildList.GetLibraryInstancesList()
BuildFlagList = AsBuildList.GetBuildFlagsList()
AsBuiltNodeList = []
for Pcd in PatchPcdValueList:
if IsMatchArch(Pcd.SupArchList, SupportArch):
Tmp = PcdEntryXml()
AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PatchPcdValue'))
for Pcd in PcdExList:
if IsMatchArch(Pcd.SupArchList, SupportArch):
Tmp = PcdEntryXml()
AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PcdExValue'))
GuiVerElemList = []
for LibGuidVer in LibGuidVerList:
if LibGuidVer.GetLibGuid() and IsMatchArch(
LibGuidVer.GetSupArchList(), SupportArch):
GuiVerElem = \
CreateXmlElement('GUID', LibGuidVer.GetLibGuid(), [], [['Version', LibGuidVer.GetLibVersion()]])
GuiVerElemList.append(GuiVerElem)
if len(GuiVerElemList) > 0:
LibGuidVerElem = CreateXmlElement('LibraryInstances', '',
GuiVerElemList, [])
AsBuiltNodeList.append(LibGuidVerElem)
for BuildFlag in BuildFlagList:
if IsMatchArch(BuildFlag.GetSupArchList(), SupportArch):
for Item in BuildFlag.GetAsBuildList():
Tmp = BuildFlagXml()
Elem = CreateXmlElement('BuildFlags', ''.join(Item), [],
[])
AsBuiltNodeList.append(Elem)
if len(AsBuiltNodeList) > 0:
Element = CreateXmlElement('AsBuilt', '', AsBuiltNodeList, [])
NodeList.append(Element)
Root = CreateXmlElement('%s' % Key, '', NodeList, [])
return Root
def ToXml(self, UserExtension, Key):
if self.UserId:
pass
AttributeList = [['UserId', str(UserExtension.GetUserID())],
['Identifier', str(UserExtension.GetIdentifier())],
['SupArchList', \
GetStringOfList(UserExtension.GetSupArchList())],
]
Root = CreateXmlElement('%s' % Key, UserExtension.GetStatement(), [], \
AttributeList)
NodeList = []
DefineDict = UserExtension.GetDefinesDict()
if DefineDict:
for Item in DefineDict.keys():
NodeList.append(CreateXmlElement\
('Statement', Item, [], []))
DefineElement = CreateXmlElement('Define', '', NodeList, [])
Root.appendChild(DefineElement)
NodeList = []
BuildOptionDict = UserExtension.GetBuildOptionDict()
if BuildOptionDict:
for Item in BuildOptionDict.keys():
NodeList.append(CreateXmlElement\
('Statement', BuildOptionDict[Item], [], \
[['SupArchList', Item]]))
BuildOptionElement = \
CreateXmlElement('BuildOption', '', NodeList, [])
Root.appendChild(BuildOptionElement)
NodeList = []
IncludesDict = UserExtension.GetIncludesDict()
if IncludesDict:
for Item in IncludesDict.keys():
NodeList.append(CreateXmlElement\
('Statement', Item, [], \
[['SupArchList', IncludesDict[Item]]]))
IncludesElement = CreateXmlElement('Includes', '', NodeList, [])
Root.appendChild(IncludesElement)
NodeList = []
SourcesDict = UserExtension.GetSourcesDict()
if SourcesDict:
Tmp = UserExtensionSourceXml()
Root.appendChild(Tmp.ToXml(SourcesDict, 'Sources'))
NodeList = []
BinariesDict = UserExtension.GetBinariesDict()
if BinariesDict:
Tmp = UserExtensionBinaryXml()
Root.appendChild(Tmp.ToXml(BinariesDict, 'Binaries'))
return Root
def ToXml(self, PackageDependency, Key):
if self.Guid:
pass
AttributeList = [['SupArchList', GetStringOfList(PackageDependency.GetSupArchList())],
['FeatureFlag', ConvertNEToNOTEQ(PackageDependency.GetFeatureFlag())], ]
Element1 = CreateXmlElement('GUID', PackageDependency.GetGuid(), [],
[['Version', PackageDependency.GetVersion()]])
NodeList = [['Description', PackageDependency.GetPackage()], Element1, ]
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, BinaryFile, Key):
if self.FileNames:
pass
NodeList = []
FilenameList = BinaryFile.GetFileNameList()
for Filename in FilenameList:
Tmp = FilenameXml()
NodeList.append(Tmp.ToXml(Filename, 'Filename'))
if GlobalData.gIS_BINARY_INF:
AsBuildList = BinaryFile.GetAsBuiltList()
PatchPcdValueList = AsBuildList.GetPatchPcdList()
PcdExList = AsBuildList.GetPcdExList()
LibGuidVerList = AsBuildList.GetLibraryInstancesList()
BuildFlagList = AsBuildList.GetBuildFlagsList()
AsBuiltNodeList = []
for Pcd in PatchPcdValueList:
Tmp = PcdEntryXml()
AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PatchPcdValue'))
for Pcd in PcdExList:
Tmp = PcdEntryXml()
AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PcdExValue'))
GuiVerElemList = []
for LibGuidVer in LibGuidVerList:
GuiVerElem = \
CreateXmlElement('GUID', LibGuidVer.GetLibGuid(), [], [['Version', LibGuidVer.GetLibVersion()]])
GuiVerElemList.append(GuiVerElem)
if len(GuiVerElemList) > 0:
LibGuidVerElem = CreateXmlElement('LibraryInstances', '',
GuiVerElemList, [])
AsBuiltNodeList.append(LibGuidVerElem)
for BuildFlag in BuildFlagList:
Tmp = BuildFlagXml()
Elem = CreateXmlElement('BuildFlags', ''.join(BuildFlag), [],
[])
AsBuiltNodeList.append(Elem)
if len(AsBuiltNodeList) > 0:
Element = CreateXmlElement('AsBuilt', '', AsBuiltNodeList, [])
NodeList.append(Element)
Root = CreateXmlElement('%s' % Key, '', NodeList, [])
return Root
def ToXml(self, MiscFile, Key):
if self.Header:
pass
if MiscFile:
if MiscFile.GetAbstract():
DPAbstract = MiscFile.GetAbstract()[0][1]
else:
DPAbstract = ''
if MiscFile.GetDescription():
DPDescription = MiscFile.GetDescription()[0][1]
else:
DPDescription = ''
if MiscFile.GetCopyright():
DPCopyright = MiscFile.GetCopyright()[0][1]
else:
DPCopyright = ''
if MiscFile.GetLicense():
DPLicense = MiscFile.GetLicense()[0][1]
else:
DPLicense = ''
NodeList = [
['Copyright', DPCopyright],
['License', DPLicense],
['Abstract', DPAbstract],
['Description', DPDescription],
]
for File in MiscFile.GetFileList():
NodeList.append\
(CreateXmlElement\
('Filename', File.GetURI(), [], \
[['Executable', str(File.GetExecutable()).lower()]]))
Root = CreateXmlElement('%s' % Key, '', NodeList, [])
return Root
def ToXml(self, PackageIncludeHeader, Key):
if self.HeaderFile:
pass
AttributeList = [['SupArchList', GetStringOfList(PackageIncludeHeader.GetSupArchList())], \
['SupModList', GetStringOfList(PackageIncludeHeader.GetSupModuleList())], ]
HeaderFileNode = CreateXmlElement('HeaderFile', PackageIncludeHeader.FilePath, [], AttributeList)
NodeList = [HeaderFileNode]
for Item in PackageIncludeHeader.GetHelpTextList():
Tmp = HelpTextXml()
NodeList.append(Tmp.ToXml(Item))
Root = CreateXmlElement('%s' % Key, '', NodeList, [])
return Root
def ToXml(self, Header, Key):
if self.GUID:
pass
Element1 = CreateXmlElement('Name', Header.GetName(), [], [['BaseName', Header.GetBaseName()]])
Element2 = CreateXmlElement('GUID', Header.GetGuid(), [], [['Version', Header.GetVersion()]])
AttributeList = []
NodeList = [Element1,
Element2,
['Copyright', Header.GetCopyright()],
['License', Header.GetLicense()],
['Abstract', Header.GetAbstract()],
['Description', Header.GetDescription()],
]
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml4(self, PcdEntry, Key):
if self.PcdCName:
pass
DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
AttributeList = []
NodeList = [['TokenSpaceGuidValue',
PcdEntry.GetTokenSpaceGuidValue()],
['PcdCName', PcdEntry.GetCName()],
['Token', PcdEntry.GetToken()],
['DatumType', PcdEntry.GetDatumType()],
['MaxDatumSize',
PcdEntry.GetMaxDatumSize()], ['Value', DefaultValue],
['Offset', PcdEntry.GetOffset()]]
for Item in PcdEntry.GetHelpTextList():
Tmp = HelpTextXml()
NodeList.append(Tmp.ToXml(Item))
for Item in PcdEntry.GetPcdErrorsList():
Tmp = PcdErrorXml()
NodeList.append(Tmp.ToXml(Item, 'PcdError'))
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, GuidProtocolPpi, Key):
if self.Mode == 'Package':
AttributeList = \
[['SupArchList', \
GetStringOfList(GuidProtocolPpi.GetSupArchList())],
]
NodeList = [['CName', GuidProtocolPpi.GetCName()],
['GuidValue', GuidProtocolPpi.GetGuid()],
]
else:
AttributeList = \
[['Usage', GetStringOfList(GuidProtocolPpi.GetUsage())], \
['Notify', str(GuidProtocolPpi.GetNotify()).lower()], \
['SupArchList', \
GetStringOfList(GuidProtocolPpi.GetSupArchList())], \
['FeatureFlag', ConvertNEToNOTEQ(GuidProtocolPpi.GetFeatureFlag())]
]
NodeList = [['CName', GuidProtocolPpi.GetCName()],
]
for Item in GuidProtocolPpi.GetHelpTextList():
Tmp = HelpTextXml()
NodeList.append(Tmp.ToXml(Item))
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml3(self, PcdEntry, Key):
if self.PcdCName:
pass
DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue())
AttributeList = \
[['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \
['PcdUsage', PcdEntry.GetValidUsage()], \
['PcdItemType', PcdEntry.GetItemType()], \
['FeatureFlag', ConvertNEToNOTEQ(PcdEntry.GetFeatureFlag())],
]
NodeList = [
['CName', PcdEntry.GetCName()],
['TokenSpaceGuidCName',
PcdEntry.GetTokenSpaceGuidCName()],
['DefaultValue', DefaultValue],
]
for Item in PcdEntry.GetHelpTextList():
Tmp = HelpTextXml()
NodeList.append(Tmp.ToXml(Item))
for Item in PcdEntry.GetPcdErrorsList():
Tmp = PcdErrorXml()
NodeList.append(Tmp.ToXml(Item, 'PcdError'))
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, IndustryStandardHeader, Key):
if self.HeaderFile:
pass
AttributeList = []
NodeList = [['HeaderFile', IndustryStandardHeader.GetFilePath()]]
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, BuildFlag, Key):
if self.Target:
pass
AttributeList = []
NodeList = []
NodeList.append(['BuildFlags', BuildFlag])
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, SourceFile, Key):
if self.SourceFile:
pass
FeatureFlag = ConvertNEToNOTEQ(SourceFile.GetFeatureFlag())
AttributeList = [['SupArchList', GetStringOfList(SourceFile.GetSupArchList())],
['Family', SourceFile.GetFamily()],
['FeatureFlag', FeatureFlag], ]
Root = CreateXmlElement('%s' % Key, SourceFile.GetSourceFile(), [], AttributeList)
return Root
def ToXml(self, PackageObject2, Key):
if self.PackagePath:
pass
Element1 = CreateXmlElement('Name', PackageObject2.GetName(), [], \
[['BaseName', PackageObject2.GetBaseName()]])
Element2 = CreateXmlElement('GUID', PackageObject2.GetGuid(), [], \
[['Version', PackageObject2.GetVersion()]])
NodeList = [Element1, Element2]
UNIPackageAbrstractList = []
UNIPackageDescriptionList = []
# Get Abstract and Description from Uni File
# if the Uni File exists
if PackageObject2.UniFileClassObject is not None:
UniStrDict = PackageObject2.UniFileClassObject.OrderedStringList
for Lang in UniStrDict:
for StringDefClassObject in UniStrDict[Lang]:
if not StringDefClassObject.StringValue:
continue
if StringDefClassObject.StringName == DataType.TAB_DEC_PACKAGE_ABSTRACT:
UNIPackageAbrstractList.append(
(GetLanguageCode1766(Lang),
ConvertSpecialUnicodes(
StringDefClassObject.StringValue)))
if StringDefClassObject.StringName == DataType.TAB_DEC_PACKAGE_DESCRIPTION:
UNIPackageDescriptionList.append(
(GetLanguageCode1766(Lang),
ConvertSpecialUnicodes(
StringDefClassObject.StringValue)))
# Get Abstract and Description from DEC File Header
for (Lang, Value) in PackageObject2.GetCopyright():
if Value:
NodeList.append(
CreateXmlElement(DataType.TAB_HEADER_COPYRIGHT, Value, [],
[]))
for (Lang, Value) in PackageObject2.GetLicense():
if Value:
NodeList.append(
CreateXmlElement(DataType.TAB_HEADER_LICENSE, Value, [],
[]))
for (Lang,
Value) in PackageObject2.GetAbstract() + UNIPackageAbrstractList:
if Value:
NodeList.append(
CreateXmlElement(DataType.TAB_HEADER_ABSTRACT, Value, [],
[['Lang', Lang]]))
for (Lang, Value
) in PackageObject2.GetDescription() + UNIPackageDescriptionList:
if Value:
NodeList.append(
CreateXmlElement(DataType.TAB_HEADER_DESCRIPTION, Value,
[], [['Lang', Lang]]))
NodeList.append(['PackagePath', PackageObject2.GetPackagePath()])
AttributeList = []
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, PackageObject2, Key):
if self.PackagePath:
pass
Element1 = \
CreateXmlElement('Name', PackageObject2.GetName(), [], \
[['BaseName', PackageObject2.GetBaseName()]])
Element2 = CreateXmlElement('GUID', PackageObject2.GetGuid(), [], \
[['Version', PackageObject2.GetVersion()]])
AttributeList = []
NodeList = [Element1,
Element2,
['Copyright', PackageObject2.GetCopyright()],
['License', PackageObject2.GetLicense()],
['Abstract', PackageObject2.GetAbstract()],
['Description', PackageObject2.GetDescription()],
['PackagePath', PackageObject2.GetPackagePath()],
]
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, Filename, Key):
if self.Filename:
pass
AttributeList = [['SupArchList', \
GetStringOfList(Filename.GetSupArchList())],
['FileType', Filename.GetFileType()],
['FeatureFlag', ConvertNEToNOTEQ(Filename.GetFeatureFlag())],
]
Root = CreateXmlElement('%s' % Key, Filename.GetFilename(), [], AttributeList)
return Root
def CreateHeaderXml(DistMap, Root):
Element1 = CreateXmlElement('Name', DistMap['Name'],
[], [['BaseName', DistMap['BaseName']]])
Element2 = CreateXmlElement('GUID', DistMap['GUID'],
[], [['Version', DistMap['Version']]])
AttributeList = [['ReadOnly', DistMap['ReadOnly']],
['RePackage', DistMap['RePackage']]]
NodeList = [Element1,
Element2,
['Vendor', DistMap['Vendor']],
['Date', DistMap['Date']],
['Copyright', DistMap['Copyright']],
['License', DistMap['License']],
['Abstract', DistMap['Abstract']],
['Description', DistMap['Description']],
['Signature', DistMap['Signature']],
['XmlSpecification', DistMap['XmlSpecification']],
]
Root.appendChild(CreateXmlElement('DistributionHeader', '',
NodeList, AttributeList))
def ToXml(self, BootMode, Key):
if self.HelpText:
pass
AttributeList = [['Usage', BootMode.GetUsage()], ]
NodeList = [['SupportedBootModes', BootMode.GetSupportedBootModes()]]
for Item in BootMode.GetHelpTextList():
Tmp = HelpTextXml()
NodeList.append(Tmp.ToXml(Item, 'HelpText'))
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, Header, Key):
if self.GUID:
pass
Element1 = CreateXmlElement(
'Name', Header.GetName(), [],
[['BaseName', Header.GetBaseName()]])
Element2 = CreateXmlElement(
'GUID', Header.GetGuid(), [],
[['Version', Header.GetVersion()]])
NodeList = [
Element1,
Element2,
]
UNIInfAbstractList = []
UNIInfDescriptionList = []
# Get Abstract and Description from Uni File
# if the Uni File exists
if Header.UniFileClassObject is not None:
UniStrDict = Header.UniFileClassObject.OrderedStringList
for Lang in UniStrDict:
for StringDefClassObject in UniStrDict[Lang]:
if not StringDefClassObject.StringValue:
continue
if StringDefClassObject.StringName == DataType.TAB_INF_ABSTRACT:
UNIInfAbstractList.append(
(GetLanguageCode1766(Lang),
ConvertSpecialUnicodes(
StringDefClassObject.StringValue)))
if StringDefClassObject.StringName == DataType.TAB_INF_DESCRIPTION:
UNIInfDescriptionList.append(
(GetLanguageCode1766(Lang),
ConvertSpecialUnicodes(
StringDefClassObject.StringValue)))
# Get Abstract and Description from INF File Header
for (Lang, Value) in Header.GetCopyright():
if Value:
NodeList.append(CreateXmlElement('Copyright', Value, [], []))
for (Lang, Value) in Header.GetLicense():
if Value:
NodeList.append(CreateXmlElement('License', Value, [], []))
for (Lang, Value) in Header.GetAbstract() + UNIInfAbstractList:
if Value:
NodeList.append(
CreateXmlElement('Abstract', Value, [], [['Lang', Lang]]))
for (Lang, Value) in Header.GetDescription() + UNIInfDescriptionList:
if Value:
NodeList.append(
CreateXmlElement('Description', Value, [],
[['Lang', Lang]]))
AttributeList = []
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, Depex, Key):
if self.HelpText:
pass
AttributeList = [['SupArchList', GetStringOfList(Depex.GetSupArchList())],
['SupModList', Depex.GetModuleType()]]
NodeList = [['Expression', Depex.GetDepex()]]
if Depex.GetHelpText():
Tmp = HelpTextXml()
NodeList.append(Tmp.ToXml(Depex.GetHelpText(), 'HelpText'))
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml(self, Hob, Key):
if self.Name:
pass
AttributeList = [['HobType', Hob.GetHobType()],
['Usage', Hob.GetUsage()],
['SupArchList', GetStringOfList(Hob.GetSupArchList())], ]
NodeList = []
for Item in Hob.GetHelpTextList():
Tmp = HelpTextXml()
NodeList.append(Tmp.ToXml(Item, 'HelpText'))
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
def ToXml2(self, MiscFile, Key):
if self.Header:
pass
if MiscFile:
NodeList = [['Name', MiscFile.GetName()],
['Copyright', MiscFile.GetCopyright()],
['License', MiscFile.GetLicense()],
['Abstract', MiscFile.GetAbstract()],
['Description', MiscFile.GetDescription()],
]
HeaderNode = CreateXmlElement('Header', '', NodeList, [])
NodeList = [HeaderNode]
for File in MiscFile.GetFileList():
NodeList.append\
(CreateXmlElement\
('Filename', File.GetURI(), [], \
[['Executable', str(File.GetExecutable()).lower()], \
['OS', File.GetOS()]]))
Root = CreateXmlElement('%s' % Key, '', NodeList, [])
return Root
def ToXml(self, Event, Key):
if self.HelpText:
pass
AttributeList = [['EventType', Event.GetEventType()],
['Usage', Event.GetUsage()],
]
NodeList = []
for Item in Event.GetHelpTextList():
Tmp = HelpTextXml()
NodeList.append(Tmp.ToXml(Item, 'HelpText'))
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)
return Root
