From f215e02bf85f68d3a6106c2a1f4f7f063f819064 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Thu, 11 Apr 2024 10:17:27 +0200 Subject: Adding upstream version 7.0.14-dfsg. Signed-off-by: Daniel Baumann --- .../BaseTools/Source/Python/UPT/Xml/CommonXml.py | 997 +++++++++++++++++++++ 1 file changed, 997 insertions(+) create mode 100755 src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/UPT/Xml/CommonXml.py (limited to 'src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/UPT/Xml/CommonXml.py') diff --git a/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/UPT/Xml/CommonXml.py b/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/UPT/Xml/CommonXml.py new file mode 100755 index 00000000..8c227442 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/UPT/Xml/CommonXml.py @@ -0,0 +1,997 @@ +## @file +# This file is used to parse a PCD file of .PKG file +# +# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.
+# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# + +''' +CommonXml +''' + +## +# Import Modules +# + +from Core.DistributionPackageClass import DistributionPackageHeaderObject +from Library.StringUtils import ConvertNEToNOTEQ +from Library.StringUtils import ConvertNOTEQToNE +from Library.StringUtils import GetSplitValueList +from Library.StringUtils import GetStringOfList +from Library.Xml.XmlRoutines import XmlElement +from Library.Xml.XmlRoutines import XmlElement2 +from Library.Xml.XmlRoutines import XmlAttribute +from Library.Xml.XmlRoutines import XmlNode +from Library.Xml.XmlRoutines import XmlList +from Library.Xml.XmlRoutines import CreateXmlElement +from Library.UniClassObject import ConvertSpecialUnicodes +from Library.UniClassObject import GetLanguageCode1766 +from Object.POM.CommonObject import FileObject +from Object.POM.CommonObject import MiscFileObject +from Object.POM.CommonObject import UserExtensionObject +from Object.POM.CommonObject import ClonedRecordObject +from Object.POM.CommonObject import LibraryClassObject +from Object.POM.CommonObject import FileNameObject +from Object.POM.ModuleObject import ModuleObject +from Xml.XmlParserMisc import IsRequiredItemListNull +from Xml.XmlParserMisc import GetHelpTextList +import Library.DataType as DataType + +## +# ClonedFromXml +# +class ClonedFromXml(object): + def __init__(self): + self.GUID = '' + self.Version = '' + + def FromXml(self, Item, Key): + self.GUID = XmlElement(Item, '%s/GUID' % Key) + self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version') + if self.GUID == '' and self.Version == '': + return None + ClonedFrom = ClonedRecordObject() + ClonedFrom.SetPackageGuid(self.GUID) + ClonedFrom.SetPackageVersion(self.Version) + return ClonedFrom + + 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 __str__(self): + return "GUID = %s Version = %s" % (self.GUID, self.Version) + + +## +# CommonDefinesXml +# +class CommonDefinesXml(object): + def __init__(self): + self.Usage = '' + self.SupArchList = [] + self.SupModList = [] + self.FeatureFlag = '' + + def FromXml(self, Item, Key): + if Key: + pass + self.Usage = XmlAttribute(Item, 'Usage') + self.SupArchList = \ + [Arch for Arch in GetSplitValueList(XmlAttribute(Item, 'SupArchList'), DataType.TAB_SPACE_SPLIT) if Arch] + self.SupModList = \ + [Mod for Mod in GetSplitValueList(XmlAttribute(Item, 'SupModList'), DataType.TAB_SPACE_SPLIT) if Mod] + self.FeatureFlag = ConvertNOTEQToNE(XmlAttribute(Item, 'FeatureFlag')) + + def ToXml(self): + pass + + def __str__(self): + return "Usage = %s SupArchList = %s SupModList = %s FeatureFlag = %s" \ + % (self.Usage, self.SupArchList, self.SupModList, self.FeatureFlag) + +## +# PromptXml +# +class PromptXml(object): + def __init__(self): + self.Prompt = '' + self.Lang = '' + + def FromXml(self, Item, Key): + if Key: + pass + self.Prompt = XmlElement2(Item, 'Prompt') + self.Lang = XmlAttribute(Item, 'Lang') + + def ToXml(self, Prompt, Key='Prompt'): + if self.Prompt: + pass + return CreateXmlElement('%s' % Key, Prompt.GetString(), [], [['Lang', Prompt.GetLang()]]) + def __str__(self): + return "Prompt = %s Lang = %s" % (self.Prompt, self.Lang) + +## +# HelpTextXml +# +class HelpTextXml(object): + def __init__(self): + self.HelpText = '' + self.Lang = '' + + def FromXml(self, Item, Key): + if Key: + pass + self.HelpText = XmlElement2(Item, 'HelpText') + self.Lang = XmlAttribute(Item, 'Lang') + + def ToXml(self, HelpText, Key='HelpText'): + if self.HelpText: + pass + return CreateXmlElement('%s' % Key, HelpText.GetString(), [], [['Lang', HelpText.GetLang()]]) + def __str__(self): + return "HelpText = %s Lang = %s" % (self.HelpText, self.Lang) + +## +# HeaderXml +# +class HeaderXml(object): + def __init__(self): + self.Name = '' + self.BaseName = '' + self.GUID = '' + self.Version = '' + self.CopyrightList = [] + self.LicenseList = [] + self.AbstractList = [] + self.DescriptionList = [] + + def FromXml(self, Item, Key, IsRequiredCheck=False, IsStandAlongModule=False): + if not Item and IsRequiredCheck: + XmlTreeLevel = [] + if IsStandAlongModule: + XmlTreeLevel = ['DistributionPackage', 'ModuleSurfaceArea'] + else: + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'ModuleSurfaceArea'] + CheckDict = {'Header':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + self.Name = XmlElement(Item, '%s/Name' % Key) + self.BaseName = XmlAttribute(XmlNode(Item, '%s/Name' % Key), 'BaseName') + self.GUID = XmlElement(Item, '%s/GUID' % Key) + self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version') + + for SubItem in XmlList(Item, '%s/Abstract' % Key): + HeaderAbstractLang = XmlAttribute(SubItem, 'Lang') + self.AbstractList.append((HeaderAbstractLang, XmlElement(SubItem, '%s/Abstract' % Key))) + for SubItem in XmlList(Item, '%s/Description' % Key): + HeaderDescriptionLang = XmlAttribute(SubItem, 'Lang') + self.DescriptionList.append((HeaderDescriptionLang, XmlElement(SubItem, '%s/Description' % Key))) + for SubItem in XmlList(Item, '%s/Copyright' % Key): + HeaderCopyrightLang = XmlAttribute(SubItem, 'Lang') + self.CopyrightList.append((HeaderCopyrightLang, XmlElement(SubItem, '%s/Copyright' % Key))) + for SubItem in XmlList(Item, '%s/License' % Key): + HeaderLicenseLang = XmlAttribute(SubItem, 'Lang') + self.LicenseList.append((HeaderLicenseLang, XmlElement(SubItem, '%s/License' % Key))) + ModuleHeader = ModuleObject() + ModuleHeader.SetName(self.Name) + ModuleHeader.SetBaseName(self.BaseName) + ModuleHeader.SetGuid(self.GUID) + ModuleHeader.SetVersion(self.Version) + ModuleHeader.SetCopyright(self.CopyrightList) + ModuleHeader.SetLicense(self.LicenseList) + ModuleHeader.SetAbstract(self.AbstractList) + ModuleHeader.SetDescription(self.DescriptionList) + return ModuleHeader + + 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 __str__(self): + return "Name = %s BaseName = %s GUID = %s Version = %s Copyright = %s \ + License = %s Abstract = %s Description = %s" % \ + (self.Name, self.BaseName, self.GUID, self.Version, self.CopyrightList, \ + self.LicenseList, self.AbstractList, self.DescriptionList) +## +# DistributionPackageHeaderXml +# +class DistributionPackageHeaderXml(object): + def __init__(self): + self.Header = HeaderXml() + self.ReadOnly = '' + self.RePackage = '' + self.Vendor = '' + self.Date = '' + self.Signature = '' + self.XmlSpecification = '' + + def FromXml(self, Item, Key): + if not Item: + return None + self.ReadOnly = XmlAttribute(XmlNode(Item, '%s' % Key), 'ReadOnly') + self.RePackage = XmlAttribute(XmlNode(Item, '%s' % Key), 'RePackage') + self.Vendor = XmlElement(Item, '%s/Vendor' % Key) + self.Date = XmlElement(Item, '%s/Date' % Key) + self.Signature = XmlElement(Item, '%s/Signature' % Key) + self.XmlSpecification = XmlElement(Item, '%s/XmlSpecification' % Key) + self.Header.FromXml(Item, Key) + DistributionPackageHeader = DistributionPackageHeaderObject() + if self.ReadOnly.upper() == 'TRUE': + DistributionPackageHeader.ReadOnly = True + elif self.ReadOnly.upper() == 'FALSE': + DistributionPackageHeader.ReadOnly = False + if self.RePackage.upper() == 'TRUE': + DistributionPackageHeader.RePackage = True + elif self.RePackage.upper() == 'FALSE': + DistributionPackageHeader.RePackage = False + DistributionPackageHeader.Vendor = self.Vendor + DistributionPackageHeader.Date = self.Date + DistributionPackageHeader.Signature = self.Signature + DistributionPackageHeader.XmlSpecification = self.XmlSpecification + DistributionPackageHeader.SetName(self.Header.Name) + DistributionPackageHeader.SetBaseName(self.Header.BaseName) + DistributionPackageHeader.SetGuid(self.Header.GUID) + DistributionPackageHeader.SetVersion(self.Header.Version) + DistributionPackageHeader.SetCopyright(self.Header.CopyrightList) + DistributionPackageHeader.SetLicense(self.Header.LicenseList) + DistributionPackageHeader.SetAbstract(self.Header.AbstractList) + DistributionPackageHeader.SetDescription(self.Header.DescriptionList) + return DistributionPackageHeader + + 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()]) + if DistributionPackageHeader.GetAbstract(): + DPAbstract = DistributionPackageHeader.GetAbstract()[0][1] + else: + DPAbstract = '' + if DistributionPackageHeader.GetDescription(): + DPDescription = DistributionPackageHeader.GetDescription()[0][1] + else: + DPDescription = '' + if DistributionPackageHeader.GetCopyright(): + DPCopyright = DistributionPackageHeader.GetCopyright()[0][1] + else: + DPCopyright = '' + if DistributionPackageHeader.GetLicense(): + DPLicense = DistributionPackageHeader.GetLicense()[0][1] + else: + DPLicense = '' + NodeList = [Element1, + Element2, + ['Vendor', DistributionPackageHeader.Vendor], + ['Date', DistributionPackageHeader.Date], + ['Copyright', DPCopyright], + ['License', DPLicense], + ['Abstract', DPAbstract], + ['Description', DPDescription], + ['Signature', DistributionPackageHeader.Signature], + ['XmlSpecification', \ + DistributionPackageHeader.XmlSpecification], + ] + Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) + return Root + + def __str__(self): + return "ReadOnly = %s RePackage = %s Vendor = %s Date = %s \ + Signature = %s XmlSpecification = %s %s" % \ + (self.ReadOnly, self.RePackage, self.Vendor, self.Date, \ + self.Signature, self.XmlSpecification, self.Header) +## +# PackageHeaderXml +# +class PackageHeaderXml(object): + def __init__(self): + self.Header = HeaderXml() + self.PackagePath = '' + + def FromXml(self, Item, Key, PackageObject2): + if not Item: + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea'] + CheckDict = {'PackageHeader': None, } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + self.PackagePath = XmlElement(Item, '%s/PackagePath' % Key) + self.Header.FromXml(Item, Key) + PackageObject2.SetName(self.Header.Name) + PackageObject2.SetBaseName(self.Header.BaseName) + PackageObject2.SetGuid(self.Header.GUID) + PackageObject2.SetVersion(self.Header.Version) + PackageObject2.SetCopyright(self.Header.CopyrightList) + PackageObject2.SetLicense(self.Header.LicenseList) + PackageObject2.SetAbstract(self.Header.AbstractList) + PackageObject2.SetDescription(self.Header.DescriptionList) + PackageObject2.SetPackagePath(self.PackagePath) + + 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 __str__(self): + return "PackagePath = %s %s" \ + % (self.PackagePath, self.Header) + +## +# MiscellaneousFileXml +# +class MiscellaneousFileXml(object): + def __init__(self): + self.Header = HeaderXml() + self.Files = [] + ## + # This API is used for Package or Module's MiscellaneousFile section + # + def FromXml(self, Item, Key): + if not Item: + return None + self.Header.FromXml(Item, Key) + NewItem = XmlNode(Item, '%s/Header' % Key) + self.Header.FromXml(NewItem, 'Header') + for SubItem in XmlList(Item, '%s/Filename' % Key): + Filename = XmlElement(SubItem, '%s/Filename' % Key) + Executable = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable') + if Executable.upper() == "TRUE": + Executable = True + elif Executable.upper() == "FALSE": + Executable = False + else: + Executable = '' + self.Files.append([Filename, Executable]) + MiscFile = MiscFileObject() + MiscFile.SetCopyright(self.Header.CopyrightList) + MiscFile.SetLicense(self.Header.LicenseList) + MiscFile.SetAbstract(self.Header.AbstractList) + MiscFile.SetDescription(self.Header.DescriptionList) + MiscFileList = [] + for File in self.Files: + FileObj = FileObject() + FileObj.SetURI(File[0]) + FileObj.SetExecutable(File[1]) + MiscFileList.append(FileObj) + MiscFile.SetFileList(MiscFileList) + return MiscFile + ## + # This API is used for DistP's tool section + # + def FromXml2(self, Item, Key): + if Item is None: + return None + NewItem = XmlNode(Item, '%s/Header' % Key) + self.Header.FromXml(NewItem, 'Header') + for SubItem in XmlList(Item, '%s/Filename' % Key): + Filename = XmlElement(SubItem, '%s/Filename' % Key) + Executable = \ + XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable') + OsType = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'OS') + if Executable.upper() == "TRUE": + Executable = True + elif Executable.upper() == "FALSE": + Executable = False + else: + Executable = '' + self.Files.append([Filename, Executable, OsType]) + MiscFile = MiscFileObject() + MiscFile.SetName(self.Header.Name) + MiscFile.SetCopyright(self.Header.CopyrightList) + MiscFile.SetLicense(self.Header.LicenseList) + MiscFile.SetAbstract(self.Header.AbstractList) + MiscFile.SetDescription(self.Header.DescriptionList) + MiscFileList = [] + for File in self.Files: + FileObj = FileObject() + FileObj.SetURI(File[0]) + FileObj.SetExecutable(File[1]) + FileObj.SetOS(File[2]) + MiscFileList.append(FileObj) + MiscFile.SetFileList(MiscFileList) + return MiscFile + + ## + # This API is used for Package or Module's MiscellaneousFile section + # + 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 + ## + # This API is used for DistP's tool section + # + def ToXml2(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 = [['Name', MiscFile.GetName()], + ['Copyright', DPCopyright], + ['License', DPLicense], + ['Abstract', DPAbstract], + ['Description', DPDescription], + ] + 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 __str__(self): + Str = str(self.Header) + for Item in self.Files: + Str = Str + '\n\tFilename:' + str(Item) + return Str +## +# UserExtensionsXml +# +class UserExtensionsXml(object): + def __init__(self): + self.UserId = '' + self.Identifier = '' + self.BinaryAbstractList = [] + self.BinaryDescriptionList = [] + self.BinaryCopyrightList = [] + self.BinaryLicenseList = [] + self.LangDefsList = [] + self.DefineDict = {} + self.BuildOptionDict = {} + self.IncludesDict = {} + self.SourcesDict = {} + self.BinariesDict = {} + self.SupArchList = [] + self.Statement = '' + self.Defines = '' + self.BuildOptions = '' + + def FromXml2(self, Item, Key): + self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId') + self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier') + UserExtension = UserExtensionObject() + UserExtension.SetUserID(self.UserId) + UserExtension.SetIdentifier(self.Identifier) + return UserExtension + + def FromXml(self, Item, Key): + self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId') + self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier') + if self.UserId == DataType.TAB_BINARY_HEADER_USERID \ + and self.Identifier == DataType.TAB_BINARY_HEADER_IDENTIFIER: + for SubItem in XmlList(Item, '%s/BinaryAbstract' % Key): + BinaryAbstractLang = XmlAttribute(SubItem, 'Lang') + self.BinaryAbstractList.append((BinaryAbstractLang, XmlElement(SubItem, '%s/BinaryAbstract' % Key))) + for SubItem in XmlList(Item, '%s/BinaryDescription' % Key): + BinaryDescriptionLang = XmlAttribute(SubItem, 'Lang') + self.BinaryDescriptionList.append((BinaryDescriptionLang, + XmlElement(SubItem, '%s/BinaryDescription' % Key))) + for SubItem in XmlList(Item, '%s/BinaryCopyright' % Key): + BinaryCopyrightLang = XmlAttribute(SubItem, 'Lang') + self.BinaryCopyrightList.append((BinaryCopyrightLang, + XmlElement(SubItem, '%s/BinaryCopyright' % Key))) + for SubItem in XmlList(Item, '%s/BinaryLicense' % Key): + BinaryLicenseLang = XmlAttribute(SubItem, 'Lang') + self.BinaryLicenseList.append((BinaryLicenseLang, + XmlElement(SubItem, '%s/BinaryLicense' % Key))) + + DefineItem = XmlNode(Item, '%s/Define' % Key) + for SubItem in XmlList(DefineItem, 'Define/Statement'): + Statement = XmlElement(SubItem, '%s/Statement' % Key) + self.DefineDict[Statement] = "" + BuildOptionItem = XmlNode(Item, '%s/BuildOption' % Key) + for SubItem in XmlList(BuildOptionItem, 'BuildOption/Statement'): + Statement = XmlElement(SubItem, '%s/Statement' % Key) + Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList') + self.BuildOptionDict[Arch] = Statement + IncludesItem = XmlNode(Item, '%s/Includes' % Key) + for SubItem in XmlList(IncludesItem, 'Includes/Statement'): + Statement = XmlElement(SubItem, '%s/Statement' % Key) + Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList') + self.IncludesDict[Statement] = Arch + SourcesItem = XmlNode(Item, '%s/Sources' % Key) + Tmp = UserExtensionSourceXml() + SourceDict = Tmp.FromXml(SourcesItem, 'Sources') + self.SourcesDict = SourceDict + BinariesItem = XmlNode(Item, '%s/Binaries' % Key) + Tmp = UserExtensionBinaryXml() + BinariesDict = Tmp.FromXml(BinariesItem, 'Binaries') + self.BinariesDict = BinariesDict + self.Statement = XmlElement(Item, 'UserExtensions') + SupArch = XmlAttribute(XmlNode(Item, '%s' % Key), 'SupArchList') + self.SupArchList = [Arch for Arch in GetSplitValueList(SupArch, DataType.TAB_SPACE_SPLIT) if Arch] + UserExtension = UserExtensionObject() + UserExtension.SetUserID(self.UserId) + UserExtension.SetIdentifier(self.Identifier) + UserExtension.SetBinaryAbstract(self.BinaryAbstractList) + UserExtension.SetBinaryDescription(self.BinaryDescriptionList) + UserExtension.SetBinaryCopyright(self.BinaryCopyrightList) + UserExtension.SetBinaryLicense(self.BinaryLicenseList) + UserExtension.SetStatement(self.Statement) + UserExtension.SetSupArchList(self.SupArchList) + UserExtension.SetDefinesDict(self.DefineDict) + UserExtension.SetBuildOptionDict(self.BuildOptionDict) + UserExtension.SetIncludesDict(self.IncludesDict) + UserExtension.SetSourcesDict(self.SourcesDict) + UserExtension.SetBinariesDict(self.BinariesDict) + return UserExtension + + 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) + if UserExtension.GetIdentifier() == DataType.TAB_BINARY_HEADER_IDENTIFIER and \ + UserExtension.GetUserID() == DataType.TAB_BINARY_HEADER_USERID: + for (Lang, Value) in UserExtension.GetBinaryAbstract(): + if Value: + ChildElement = CreateXmlElement('BinaryAbstract', Value, [], [['Lang', Lang]]) + Root.appendChild(ChildElement) + for (Lang, Value) in UserExtension.GetBinaryDescription(): + if Value: + ChildElement = CreateXmlElement('BinaryDescription', Value, [], [['Lang', Lang]]) + Root.appendChild(ChildElement) + for (Lang, Value) in UserExtension.GetBinaryCopyright(): + if Value: + ChildElement = CreateXmlElement('BinaryCopyright', Value, [], []) + Root.appendChild(ChildElement) + for (Lang, Value) in UserExtension.GetBinaryLicense(): + if Value: + ChildElement = CreateXmlElement('BinaryLicense', Value, [], []) + Root.appendChild(ChildElement) + + 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 __str__(self): + Str = "UserId = %s Identifier = %s" % (self.UserId, self.Identifier) + Str = Str + '\n\tDefines:' + str(self.Defines) + Str = Str + '\n\tBuildOptions:' + str(self.BuildOptions) + return Str + +## +# UserExtensionSourceXml +# +class UserExtensionSourceXml(object): + def __init__(self): + self.UserExtensionSource = '' + + def FromXml(self, Item, Key): + if Key: + pass + if self.UserExtensionSource: + pass + Dict = {} + #SourcesItem = XmlNode(Item, '%s/Sources' % Key) + for SubItem in XmlList(Item, 'Sources/SourceFile'): + FileName = XmlElement(SubItem, 'SourceFile/FileName') + Family = XmlElement(SubItem, 'SourceFile/Family') + FeatureFlag = XmlElement(SubItem, 'SourceFile/FeatureFlag') + SupArchStr = XmlElement(SubItem, 'SourceFile/SupArchList') + DictKey = (FileName, Family, FeatureFlag, SupArchStr) + ValueList = [] + for ValueNodeItem in XmlList(SubItem, \ + 'SourceFile/SourceFileOtherAttr'): + TagName = XmlElement(ValueNodeItem, \ + 'SourceFileOtherAttr/TagName') + ToolCode = XmlElement(ValueNodeItem, \ + 'SourceFileOtherAttr/ToolCode') + Comment = XmlElement(ValueNodeItem, \ + 'SourceFileOtherAttr/Comment') + if (TagName == ' ') and (ToolCode == ' ') and (Comment == ' '): + TagName = '' + ToolCode = '' + Comment = '' + ValueList.append((TagName, ToolCode, Comment)) + Dict[DictKey] = ValueList + return Dict + + 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 + +## +# UserExtensionBinaryXml +# +class UserExtensionBinaryXml(object): + def __init__(self): + self.UserExtensionBinary = '' + + def FromXml(self, Item, Key): + if Key: + pass + if self.UserExtensionBinary: + pass + Dict = {} + for SubItem in XmlList(Item, 'Binaries/Binary'): + FileName = XmlElement(SubItem, 'Binary/FileName') + FileType = XmlElement(SubItem, 'Binary/FileType') + FFE = XmlElement(SubItem, 'Binary/FeatureFlag') + SupArch = XmlElement(SubItem, 'Binary/SupArchList') + DictKey = (FileName, FileType, ConvertNOTEQToNE(FFE), SupArch) + ValueList = [] + for ValueNodeItem in XmlList(SubItem, \ + 'Binary/BinaryFileOtherAttr'): + Target = XmlElement(ValueNodeItem, \ + 'BinaryFileOtherAttr/Target') + Family = XmlElement(ValueNodeItem, \ + 'BinaryFileOtherAttr/Family') + TagName = XmlElement(ValueNodeItem, \ + 'BinaryFileOtherAttr/TagName') + Comment = XmlElement(ValueNodeItem, \ + 'BinaryFileOtherAttr/Comment') + if (Target == ' ') and (Family == ' ') and \ + (TagName == ' ') and (Comment == ' '): + Target = '' + Family = '' + TagName = '' + Comment = '' + + ValueList.append((Target, Family, TagName, Comment)) + Dict[DictKey] = ValueList + return Dict + + 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 + +## +# LibraryClassXml +# +class LibraryClassXml(object): + def __init__(self): + self.Keyword = '' + self.HeaderFile = '' + self.RecommendedInstanceGuid = '' + self.RecommendedInstanceVersion = '' + self.CommonDefines = CommonDefinesXml() + self.HelpText = [] + + def FromXml(self, Item, Key): + self.Keyword = XmlAttribute(XmlNode(Item, '%s' % Key), 'Keyword') + if self.Keyword == '': + self.Keyword = XmlElement(Item, '%s/Keyword' % Key) + self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key) + self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key) + for HelpTextItem in XmlList(Item, '%s/HelpText' % Key): + HelpTextObj = HelpTextXml() + HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key) + self.HelpText.append(HelpTextObj) + LibraryClass = LibraryClassObject() + LibraryClass.SetLibraryClass(self.Keyword) + LibraryClass.SetIncludeHeader(self.HeaderFile) + if self.CommonDefines.Usage: + LibraryClass.SetUsage(self.CommonDefines.Usage) + LibraryClass.SetSupArchList(self.CommonDefines.SupArchList) + LibraryClass.SetSupModuleList(self.CommonDefines.SupModList) + LibraryClass.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)) + LibraryClass.SetHelpTextList(GetHelpTextList(self.HelpText)) + return LibraryClass + + def ToXml(self, LibraryClass, Key): + if self.HeaderFile: + pass + AttributeList = \ + [['Keyword', LibraryClass.GetLibraryClass()], + ['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())], + ['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())] + ] + NodeList = [['HeaderFile', LibraryClass.GetIncludeHeader()]] + for Item in LibraryClass.GetHelpTextList(): + Tmp = HelpTextXml() + NodeList.append(Tmp.ToXml(Item)) + Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) + return Root + + def ToXml2(self, LibraryClass, Key): + if self.HeaderFile: + pass + FeatureFlag = ConvertNEToNOTEQ(LibraryClass.GetFeatureFlag()) + AttributeList = \ + [['Usage', LibraryClass.GetUsage()], \ + ['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())], \ + ['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())], \ + ['FeatureFlag', FeatureFlag] + ] + NodeList = [['Keyword', LibraryClass.GetLibraryClass()], ] + for Item in LibraryClass.GetHelpTextList(): + Tmp = HelpTextXml() + NodeList.append(Tmp.ToXml(Item)) + Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) + return Root + + def __str__(self): + Str = "Keyword = %s HeaderFile = %s RecommendedInstanceGuid = %s RecommendedInstanceVersion = %s %s" % \ + (self.Keyword, self.HeaderFile, self.RecommendedInstanceGuid, self.RecommendedInstanceVersion, \ + self.CommonDefines) + for Item in self.HelpText: + Str = Str + "\n\t" + str(Item) + return Str + +## +# FilenameXml +# +class FilenameXml(object): + def __init__(self): + self.FileType = '' + self.Filename = '' + self.CommonDefines = CommonDefinesXml() + + def FromXml(self, Item, Key): + self.FileType = XmlAttribute(Item, 'FileType') + Guid = XmlAttribute(Item, 'GUID') + self.Filename = XmlElement(Item, 'Filename') + self.CommonDefines.FromXml(Item, Key) + FeatureFlag = ConvertNOTEQToNE(self.CommonDefines.FeatureFlag) + Filename = FileNameObject() + # + # Convert File Type + # + if self.FileType == 'UEFI_IMAGE': + self.FileType = 'PE32' + + Filename.SetGuidValue(Guid) + Filename.SetFileType(self.FileType) + Filename.SetFilename(self.Filename) + Filename.SetSupArchList(self.CommonDefines.SupArchList) + Filename.SetFeatureFlag(FeatureFlag) + + return Filename + + def ToXml(self, Filename, Key): + if self.Filename: + pass + AttributeList = [['SupArchList', \ + GetStringOfList(Filename.GetSupArchList())], + ['FileType', Filename.GetFileType()], + ['FeatureFlag', ConvertNEToNOTEQ(Filename.GetFeatureFlag())], + ['GUID', Filename.GetGuidValue()] + ] + Root = CreateXmlElement('%s' % Key, Filename.GetFilename(), [], AttributeList) + + return Root + + def __str__(self): + return "FileType = %s Filename = %s %s" \ + % (self.FileType, self.Filename, self.CommonDefines) -- cgit v1.2.3