From af1a266670d040d2f4083ff309d732d648afba2a Mon Sep 17 00:00:00 2001 From: Angelos Mouzakitis Date: Tue, 10 Oct 2023 14:33:42 +0000 Subject: Add submodule dependency files Change-Id: Iaf8d18082d3991dec7c0ebbea540f092188eb4ec --- .../BaseTools/Source/Python/UPT/Xml/CommonXml.py | 997 +++++++++++++++++++ .../Source/Python/UPT/Xml/GuidProtocolPpiXml.py | 278 ++++++ .../BaseTools/Source/Python/UPT/Xml/IniToXml.py | 496 ++++++++++ .../Source/Python/UPT/Xml/ModuleSurfaceAreaXml.py | 1003 ++++++++++++++++++++ .../Source/Python/UPT/Xml/PackageSurfaceAreaXml.py | 402 ++++++++ .../edk2/BaseTools/Source/Python/UPT/Xml/PcdXml.py | 555 +++++++++++ .../BaseTools/Source/Python/UPT/Xml/XmlParser.py | 926 ++++++++++++++++++ .../Source/Python/UPT/Xml/XmlParserMisc.py | 95 ++ .../BaseTools/Source/Python/UPT/Xml/__init__.py | 14 + 9 files changed, 4766 insertions(+) create mode 100644 roms/edk2/BaseTools/Source/Python/UPT/Xml/CommonXml.py create mode 100644 roms/edk2/BaseTools/Source/Python/UPT/Xml/GuidProtocolPpiXml.py create mode 100644 roms/edk2/BaseTools/Source/Python/UPT/Xml/IniToXml.py create mode 100644 roms/edk2/BaseTools/Source/Python/UPT/Xml/ModuleSurfaceAreaXml.py create mode 100644 roms/edk2/BaseTools/Source/Python/UPT/Xml/PackageSurfaceAreaXml.py create mode 100644 roms/edk2/BaseTools/Source/Python/UPT/Xml/PcdXml.py create mode 100644 roms/edk2/BaseTools/Source/Python/UPT/Xml/XmlParser.py create mode 100644 roms/edk2/BaseTools/Source/Python/UPT/Xml/XmlParserMisc.py create mode 100644 roms/edk2/BaseTools/Source/Python/UPT/Xml/__init__.py (limited to 'roms/edk2/BaseTools/Source/Python/UPT/Xml') diff --git a/roms/edk2/BaseTools/Source/Python/UPT/Xml/CommonXml.py b/roms/edk2/BaseTools/Source/Python/UPT/Xml/CommonXml.py new file mode 100644 index 000000000..cfadacf4a --- /dev/null +++ b/roms/edk2/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) diff --git a/roms/edk2/BaseTools/Source/Python/UPT/Xml/GuidProtocolPpiXml.py b/roms/edk2/BaseTools/Source/Python/UPT/Xml/GuidProtocolPpiXml.py new file mode 100644 index 000000000..d6645fc23 --- /dev/null +++ b/roms/edk2/BaseTools/Source/Python/UPT/Xml/GuidProtocolPpiXml.py @@ -0,0 +1,278 @@ +## @file +# This file is used to parse a xml file of .PKG file +# +# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.
+# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# + +''' +GuidProtocolPpiXml +''' +from Library.StringUtils import ConvertNEToNOTEQ +from Library.StringUtils import ConvertNOTEQToNE +from Library.StringUtils import GetStringOfList +from Library.Xml.XmlRoutines import XmlElement +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 Object.POM.CommonObject import GuidObject +from Object.POM.CommonObject import ProtocolObject +from Object.POM.CommonObject import PpiObject + +from Xml.CommonXml import CommonDefinesXml +from Xml.CommonXml import HelpTextXml + +from Xml.XmlParserMisc import GetHelpTextList + +## +#GUID/Protocol/Ppi Common +# +class GuidProtocolPpiXml(object): + def __init__(self, Mode): + self.UiName = '' + self.GuidTypes = '' + self.Notify = '' + self.CName = '' + self.GuidValue = '' + self.CommonDefines = CommonDefinesXml() + self.HelpText = [] + # + # Guid/Ppi/Library, internal used for indicate return object for + # FromXml + # + self.Type = '' + # + # there are slightly different field between package and module + # + self.Mode = Mode + self.GuidType = '' + self.VariableName = '' + + def FromXml(self, Item, Key): + self.UiName = XmlAttribute(XmlNode(Item, '%s' % Key), 'UiName') + self.GuidType = XmlAttribute(XmlNode(Item, '%s' % Key), 'GuidType') + self.Notify = XmlAttribute(XmlNode(Item, '%s' % Key), 'Notify') + self.CName = XmlElement(Item, '%s/CName' % Key) + self.GuidValue = XmlElement(Item, '%s/GuidValue' % Key) + self.VariableName = XmlElement(Item, '%s/VariableName' % 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) + + if self.Type == 'Guid': + GuidProtocolPpi = GuidObject() + elif self.Type == 'Protocol': + GuidProtocolPpi = ProtocolObject() + else: + GuidProtocolPpi = PpiObject() + GuidProtocolPpi.SetHelpTextList(GetHelpTextList(self.HelpText)) + + return GuidProtocolPpi + + def ToXml(self, GuidProtocolPpi, Key): + if self.GuidValue: + pass + AttributeList = \ + [['Usage', GetStringOfList(GuidProtocolPpi.GetUsage())], \ + ['UiName', GuidProtocolPpi.GetName()], \ + ['GuidType', GetStringOfList(GuidProtocolPpi.GetGuidTypeList())], \ + ['Notify', str(GuidProtocolPpi.GetNotify()).lower()], \ + ['SupArchList', GetStringOfList(GuidProtocolPpi.GetSupArchList())], \ + ['SupModList', GetStringOfList(GuidProtocolPpi.GetSupModuleList())], \ + ['FeatureFlag', ConvertNEToNOTEQ(GuidProtocolPpi.GetFeatureFlag())] + ] + NodeList = [['CName', GuidProtocolPpi.GetCName()], + ['GuidValue', GuidProtocolPpi.GetGuid()], + ['VariableName', GuidProtocolPpi.VariableName] + ] + for Item in GuidProtocolPpi.GetHelpTextList(): + Tmp = HelpTextXml() + NodeList.append(Tmp.ToXml(Item)) + Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) + + return Root + + def __str__(self): + Str = \ + "UiName = %s Notify = %s GuidTypes = %s CName = %s GuidValue = %s %s" \ + % (self.UiName, self.Notify, self.GuidTypes, self.CName, \ + self.GuidValue, self.CommonDefines) + for Item in self.HelpText: + Str = Str + "\n\t" + str(Item) + return Str +## +#GUID Xml +# +class GuidXml(GuidProtocolPpiXml): + def __init__(self, Mode): + GuidProtocolPpiXml.__init__(self, Mode) + self.Type = 'Guid' + + def FromXml(self, Item, Key): + GuidProtocolPpi = GuidProtocolPpiXml.FromXml(self, Item, Key) + + if self.Mode == 'Package': + + GuidProtocolPpi.SetSupArchList(self.CommonDefines.SupArchList) + GuidProtocolPpi.SetSupModuleList(self.CommonDefines.SupModList) + GuidProtocolPpi.SetCName(self.CName) + GuidProtocolPpi.SetGuid(self.GuidValue) + else: + GuidProtocolPpi.SetUsage(self.CommonDefines.Usage) + if self.GuidType: + GuidProtocolPpi.SetGuidTypeList([self.GuidType]) + GuidProtocolPpi.SetSupArchList(self.CommonDefines.SupArchList) + GuidProtocolPpi.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)) + GuidProtocolPpi.SetCName(self.CName) + GuidProtocolPpi.SetVariableName(self.VariableName) + return GuidProtocolPpi + + def ToXml(self, GuidProtocolPpi, Key): + if self.Mode == 'Package': + AttributeList = \ + [['GuidType', \ + GetStringOfList(GuidProtocolPpi.GetGuidTypeList())], \ + ['SupArchList', \ + GetStringOfList(GuidProtocolPpi.GetSupArchList())], \ + ['SupModList', \ + GetStringOfList(GuidProtocolPpi.GetSupModuleList())], + ] + NodeList = [['CName', GuidProtocolPpi.GetCName()], + ['GuidValue', GuidProtocolPpi.GetGuid()], + ] + else: + AttributeList = \ + [['Usage', GetStringOfList(GuidProtocolPpi.GetUsage())], \ + ['GuidType', GetStringOfList(GuidProtocolPpi.GetGuidTypeList())],\ + ['SupArchList', \ + GetStringOfList(GuidProtocolPpi.GetSupArchList())], \ + ['FeatureFlag', ConvertNEToNOTEQ(GuidProtocolPpi.GetFeatureFlag())] + ] + NodeList = [['CName', GuidProtocolPpi.GetCName()], + ['VariableName', GuidProtocolPpi.GetVariableName()] + ] + + for Item in GuidProtocolPpi.GetHelpTextList(): + Tmp = HelpTextXml() + NodeList.append(Tmp.ToXml(Item)) + Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) + + return Root +## +#Protocol Xml +# +class ProtocolXml(GuidProtocolPpiXml): + def __init__(self, Mode): + GuidProtocolPpiXml.__init__(self, Mode) + self.Type = 'Protocol' + + def FromXml(self, Item, Key): + GuidProtocolPpi = GuidProtocolPpiXml.FromXml(self, Item, Key) + if self.Mode == 'Package': + GuidProtocolPpi.SetFeatureFlag(self.CommonDefines.FeatureFlag) + GuidProtocolPpi.SetSupArchList(self.CommonDefines.SupArchList) + GuidProtocolPpi.SetSupModuleList(self.CommonDefines.SupModList) + GuidProtocolPpi.SetCName(self.CName) + GuidProtocolPpi.SetGuid(self.GuidValue) + else: + GuidProtocolPpi.SetUsage(self.CommonDefines.Usage) + if self.Notify.upper() == "TRUE": + GuidProtocolPpi.SetNotify(True) + elif self.Notify.upper() == "FALSE": + GuidProtocolPpi.SetNotify(False) + else: + GuidProtocolPpi.SetNotify('') + GuidProtocolPpi.SetSupArchList(self.CommonDefines.SupArchList) + GuidProtocolPpi.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)) + GuidProtocolPpi.SetCName(self.CName) + + return GuidProtocolPpi + + def ToXml(self, GuidProtocolPpi, Key): + if self.Mode == 'Package': + AttributeList = \ + [['SupArchList', \ + GetStringOfList(GuidProtocolPpi.GetSupArchList())], \ + ['SupModList', \ + GetStringOfList(GuidProtocolPpi.GetSupModuleList())], \ + ['FeatureFlag', GuidProtocolPpi.GetFeatureFlag()] + ] + 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 +## +#Ppi Xml +# +class PpiXml(GuidProtocolPpiXml): + def __init__(self, Mode): + GuidProtocolPpiXml.__init__(self, Mode) + self.Type = 'Ppi' + + def FromXml(self, Item, Key): + GuidProtocolPpi = GuidProtocolPpiXml.FromXml(self, Item, Key) + if self.Mode == 'Package': + GuidProtocolPpi.SetSupArchList(self.CommonDefines.SupArchList) + GuidProtocolPpi.SetSupModuleList(self.CommonDefines.SupModList) + GuidProtocolPpi.SetCName(self.CName) + GuidProtocolPpi.SetGuid(self.GuidValue) + else: + GuidProtocolPpi.SetUsage(self.CommonDefines.Usage) + if self.Notify.upper() == "TRUE": + GuidProtocolPpi.SetNotify(True) + elif self.Notify.upper() == "FALSE": + GuidProtocolPpi.SetNotify(False) + else: + GuidProtocolPpi.SetNotify('') + GuidProtocolPpi.SetSupArchList(self.CommonDefines.SupArchList) + GuidProtocolPpi.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)) + GuidProtocolPpi.SetCName(self.CName) + + return GuidProtocolPpi + + 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 diff --git a/roms/edk2/BaseTools/Source/Python/UPT/Xml/IniToXml.py b/roms/edk2/BaseTools/Source/Python/UPT/Xml/IniToXml.py new file mode 100644 index 000000000..3dc400131 --- /dev/null +++ b/roms/edk2/BaseTools/Source/Python/UPT/Xml/IniToXml.py @@ -0,0 +1,496 @@ +## @file +# This file is for converting package information data file to xml file. +# +# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.
+# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# + +''' +IniToXml +''' + +import os.path +import re +from time import strftime +from time import localtime + +import Logger.Log as Logger +from Logger.ToolError import UPT_INI_PARSE_ERROR +from Logger.ToolError import FILE_NOT_FOUND +from Library.Xml.XmlRoutines import CreateXmlElement +from Library.DataType import TAB_VALUE_SPLIT +from Library.DataType import TAB_EQUAL_SPLIT +from Library.DataType import TAB_SECTION_START +from Library.DataType import TAB_SECTION_END +from Logger import StringTable as ST +from Library.StringUtils import ConvertSpecialChar +from Library.ParserValidate import IsValidPath +from Library import GlobalData + +## log error: +# +# @param error: error +# @param File: File +# @param Line: Line +# +def IniParseError(Error, File, Line): + Logger.Error("UPT", UPT_INI_PARSE_ERROR, File=File, + Line=Line, ExtraData=Error) + +## __ValidatePath +# +# @param Path: Path to be checked +# +def __ValidatePath(Path, Root): + Path = Path.strip() + if os.path.isabs(Path) or not IsValidPath(Path, Root): + return False, ST.ERR_FILELIST_LOCATION % (Root, Path) + return True, '' + +## ValidateMiscFile +# +# @param Filename: File to be checked +# +def ValidateMiscFile(Filename): + Root = GlobalData.gWORKSPACE + return __ValidatePath(Filename, Root) + +## ValidateToolsFile +# +# @param Filename: File to be checked +# +def ValidateToolsFile(Filename): + Valid, Cause = False, '' + if not Valid and 'EDK_TOOLS_PATH' in os.environ: + Valid, Cause = __ValidatePath(Filename, os.environ['EDK_TOOLS_PATH']) + if not Valid: + Valid, Cause = __ValidatePath(Filename, GlobalData.gWORKSPACE) + return Valid, Cause + +## ParseFileList +# +# @param Line: Line +# @param Map: Map +# @param CurrentKey: CurrentKey +# @param PathFunc: Path validate function +# +def ParseFileList(Line, Map, CurrentKey, PathFunc): + FileList = ["", {}] + TokenList = Line.split(TAB_VALUE_SPLIT) + if len(TokenList) > 0: + Path = TokenList[0].strip().replace('\\', '/') + if not Path: + return False, ST.ERR_WRONG_FILELIST_FORMAT + Valid, Cause = PathFunc(Path) + if not Valid: + return Valid, Cause + FileList[0] = TokenList[0].strip() + for Token in TokenList[1:]: + Attr = Token.split(TAB_EQUAL_SPLIT) + if len(Attr) != 2 or not Attr[0].strip() or not Attr[1].strip(): + return False, ST.ERR_WRONG_FILELIST_FORMAT + + Key = Attr[0].strip() + Val = Attr[1].strip() + if Key not in ['OS', 'Executable']: + return False, ST.ERR_UNKNOWN_FILELIST_ATTR % Key + + if Key == 'OS' and Val not in ["Win32", "Win64", "Linux32", + "Linux64", "OS/X32", "OS/X64", + "GenericWin", "GenericNix"]: + return False, ST.ERR_FILELIST_ATTR % 'OS' + elif Key == 'Executable' and Val not in ['true', 'false']: + return False, ST.ERR_FILELIST_ATTR % 'Executable' + FileList[1][Key] = Val + + Map[CurrentKey].append(FileList) + return True, '' + +## Create header XML file +# +# @param DistMap: DistMap +# @param Root: 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)) + +## Create tools XML file +# +# @param Map: Map +# @param Root: Root +# @param Tag: Tag +# +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, [])) + +## ValidateValues +# +# @param Key: Key +# @param Value: Value +# @param SectionName: SectionName +# +def ValidateValues(Key, Value, SectionName): + if SectionName == 'DistributionHeader': + Valid, Cause = ValidateRegValues(Key, Value) + if not Valid: + return Valid, Cause + Valid = __ValidateDistHeader(Key, Value) + if not Valid: + return Valid, ST.ERR_VALUE_INVALID % (Key, SectionName) + else: + Valid = __ValidateOtherHeader(Key, Value) + if not Valid: + return Valid, ST.ERR_VALUE_INVALID % (Key, SectionName) + return True, '' + +## ValidateRegValues +# +# @param Key: Key +# @param Value: Value +# +def ValidateRegValues(Key, Value): + ValidateMap = { + 'ReadOnly' : + ('true|false', ST.ERR_BOOLEAN_VALUE % (Key, Value)), + 'RePackage' : + ('true|false', ST.ERR_BOOLEAN_VALUE % (Key, Value)), + 'GUID' : + ('[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}' + '-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}', + ST.ERR_GUID_VALUE % Value), + 'Version' : ('[0-9]+(\.[0-9]+)?', ST.ERR_VERSION_VALUE % \ + (Key, Value)), + 'XmlSpecification' : ('1\.1', ST.ERR_VERSION_XMLSPEC % Value) + } + if Key not in ValidateMap: + return True, '' + Elem = ValidateMap[Key] + Match = re.compile(Elem[0]).match(Value) + if Match and Match.start() == 0 and Match.end() == len(Value): + return True, '' + return False, Elem[1] + +## __ValidateDistHeaderName +# +# @param Name: Name +# +def __ValidateDistHeaderName(Name): + if len(Name) < 1: + return False + + for Char in Name: + if ord(Char) < 0x20 or ord(Char) >= 0x7f: + return False + return True + +## __ValidateDistHeaderBaseName +# +# @param BaseName: BaseName +# +def __ValidateDistHeaderBaseName(BaseName): + if not BaseName: + return False +# if CheckLen and len(BaseName) < 2: +# return False + if not BaseName[0].isalnum() and BaseName[0] != '_': + return False + for Char in BaseName[1:]: + if not Char.isalnum() and Char not in '-_': + return False + return True + +## __ValidateDistHeaderAbstract +# +# @param Abstract: Abstract +# +def __ValidateDistHeaderAbstract(Abstract): + return '\t' not in Abstract and len(Abstract.splitlines()) == 1 + +## __ValidateOtherHeaderAbstract +# +# @param Abstract: Abstract +# +def __ValidateOtherHeaderAbstract(Abstract): + return __ValidateDistHeaderAbstract(Abstract) + +## __ValidateDistHeader +# +# @param Key: Key +# @param Value: Value +# +def __ValidateDistHeader(Key, Value): + ValidateMap = { + 'Name' : __ValidateDistHeaderName, + 'BaseName' : __ValidateDistHeaderBaseName, + 'Abstract' : __ValidateDistHeaderAbstract, + 'Vendor' : __ValidateDistHeaderAbstract + } + return not (Value and Key in ValidateMap and not ValidateMap[Key](Value)) + +## __ValidateOtherHeader +# +# @param Key: Key +# @param Value: Value +# +def __ValidateOtherHeader(Key, Value): + ValidateMap = { + 'Name' : __ValidateDistHeaderName, + 'Abstract' : __ValidateOtherHeaderAbstract + } + return not (Value and Key in ValidateMap and not ValidateMap[Key](Value)) + +## Convert ini file to xml file +# +# @param IniFile +# +def IniToXml(IniFile): + if not os.path.exists(IniFile): + Logger.Error("UPT", FILE_NOT_FOUND, ST.ERR_TEMPLATE_NOTFOUND % IniFile) + + DistMap = {'ReadOnly' : '', 'RePackage' : '', 'Name' : '', + 'BaseName' : '', 'GUID' : '', 'Version' : '', 'Vendor' : '', + 'Date' : '', 'Copyright' : '', 'License' : '', 'Abstract' : '', + 'Description' : '', 'Signature' : '', 'XmlSpecification' : '' + } + + ToolsMap = {'Name' : '', 'Copyright' : '', 'License' : '', + 'Abstract' : '', 'Description' : '', 'FileList' : []} + # + # Only FileList is a list: [['file1', {}], ['file2', {}], ...] + # + MiscMap = {'Name' : '', 'Copyright' : '', 'License' : '', + 'Abstract' : '', 'Description' : '', 'FileList' : []} + + SectionMap = { + 'DistributionHeader' : DistMap, + 'ToolsHeader' : ToolsMap, + 'MiscellaneousFilesHeader' : MiscMap + } + + PathValidator = { + 'ToolsHeader' : ValidateToolsFile, + 'MiscellaneousFilesHeader' : ValidateMiscFile + } + + ParsedSection = [] + + SectionName = '' + CurrentKey = '' + PreMap = None + Map = None + FileContent = ConvertSpecialChar(open(IniFile, 'r').readlines()) + LastIndex = 0 + for Index in range(0, len(FileContent)): + LastIndex = Index + Line = FileContent[Index].strip() + if Line == '' or Line.startswith(';'): + continue + if Line[0] == TAB_SECTION_START and Line[-1] == TAB_SECTION_END: + CurrentKey = '' + SectionName = Line[1:-1].strip() + if SectionName not in SectionMap: + IniParseError(ST.ERR_SECTION_NAME_INVALID % SectionName, + IniFile, Index+1) + + if SectionName in ParsedSection: + IniParseError(ST.ERR_SECTION_REDEFINE % SectionName, + IniFile, Index+1) + else: + ParsedSection.append(SectionName) + + Map = SectionMap[SectionName] + continue + if not Map: + IniParseError(ST.ERR_SECTION_NAME_NONE, IniFile, Index+1) + TokenList = Line.split(TAB_EQUAL_SPLIT, 1) + TempKey = TokenList[0].strip() + # + # Value spanned multiple or same keyword appears more than one time + # + if len(TokenList) < 2 or TempKey not in Map: + if CurrentKey == '': + IniParseError(ST.ERR_KEYWORD_INVALID % TempKey, + IniFile, Index+1) + elif CurrentKey == 'FileList': + # + # Special for FileList + # + Valid, Cause = ParseFileList(Line, Map, CurrentKey, + PathValidator[SectionName]) + if not Valid: + IniParseError(Cause, IniFile, Index+1) + + else: + # + # Multiple lines for one key such as license + # Or if string on the left side of '=' is not a keyword + # + Map[CurrentKey] = ''.join([Map[CurrentKey], '\n', Line]) + Valid, Cause = ValidateValues(CurrentKey, + Map[CurrentKey], SectionName) + if not Valid: + IniParseError(Cause, IniFile, Index+1) + continue + + if (TokenList[1].strip() == ''): + IniParseError(ST.ERR_EMPTY_VALUE, IniFile, Index+1) + + # + # A keyword found + # + CurrentKey = TempKey + if Map[CurrentKey]: + IniParseError(ST.ERR_KEYWORD_REDEFINE % CurrentKey, + IniFile, Index+1) + + if id(Map) != id(PreMap) and Map['Copyright']: + PreMap = Map + Copyright = Map['Copyright'].lower() + Pos = Copyright.find('copyright') + if Pos == -1: + IniParseError(ST.ERR_COPYRIGHT_CONTENT, IniFile, Index) + if not Copyright[Pos + len('copyright'):].lstrip(' ').startswith('('): + IniParseError(ST.ERR_COPYRIGHT_CONTENT, IniFile, Index) + + if CurrentKey == 'FileList': + Valid, Cause = ParseFileList(TokenList[1], Map, CurrentKey, + PathValidator[SectionName]) + if not Valid: + IniParseError(Cause, IniFile, Index+1) + else: + Map[CurrentKey] = TokenList[1].strip() + Valid, Cause = ValidateValues(CurrentKey, + Map[CurrentKey], SectionName) + if not Valid: + IniParseError(Cause, IniFile, Index+1) + + if id(Map) != id(PreMap) and Map['Copyright'] and 'copyright' not in Map['Copyright'].lower(): + IniParseError(ST.ERR_COPYRIGHT_CONTENT, IniFile, LastIndex) + + # + # Check mandatory keys + # + CheckMdtKeys(DistMap, IniFile, LastIndex, + (('ToolsHeader', ToolsMap), ('MiscellaneousFilesHeader', MiscMap)) + ) + + return CreateXml(DistMap, ToolsMap, MiscMap, IniFile) + + +## CheckMdtKeys +# +# @param MdtDistKeys: All mandatory keys +# @param DistMap: Dist content +# @param IniFile: Ini file +# @param LastIndex: Last index of Ini file +# @param Maps: Tools and Misc section name and map. (('section_name', map),*) +# +def CheckMdtKeys(DistMap, IniFile, LastIndex, Maps): + MdtDistKeys = ['Name', 'GUID', 'Version', 'Vendor', 'Copyright', 'License', 'Abstract', 'XmlSpecification'] + for Key in MdtDistKeys: + if Key not in DistMap or DistMap[Key] == '': + IniParseError(ST.ERR_KEYWORD_MANDATORY % Key, IniFile, LastIndex+1) + + if '.' not in DistMap['Version']: + DistMap['Version'] = DistMap['Version'] + '.0' + + DistMap['Date'] = str(strftime("%Y-%m-%dT%H:%M:%S", localtime())) + + # + # Check Tools Surface Area according to UPT Spec + # {0,} + #
...
{0,1} + # ... {1,} + # + #
+ # xs:normalizedString {1} + # xs:string {0,1} + # xs:string {0,1} + # xs:normalizedString {0,1} + # xs:string {0,1} + #
+ # + for Item in Maps: + Map = Item[1] + NonEmptyKey = 0 + for Key in Map: + if Map[Key]: + NonEmptyKey += 1 + + if NonEmptyKey > 0 and not Map['FileList']: + IniParseError(ST.ERR_KEYWORD_MANDATORY % (Item[0] + '.FileList'), IniFile, LastIndex+1) + + if NonEmptyKey > 0 and not Map['Name']: + IniParseError(ST.ERR_KEYWORD_MANDATORY % (Item[0] + '.Name'), IniFile, LastIndex+1) + +## CreateXml +# +# @param DistMap: Dist Content +# @param ToolsMap: Tools Content +# @param MiscMap: Misc Content +# @param IniFile: Ini File +# +def CreateXml(DistMap, ToolsMap, MiscMap, IniFile): + Attrs = [['xmlns', 'http://www.uefi.org/2011/1.1'], + ['xmlns:xsi', 'http:/www.w3.org/2001/XMLSchema-instance'], + ] + Root = CreateXmlElement('DistributionPackage', '', [], Attrs) + CreateHeaderXml(DistMap, Root) + CreateToolsXml(ToolsMap, Root, 'Tools') + CreateToolsXml(MiscMap, Root, 'MiscellaneousFiles') + + FileAndExt = IniFile.rsplit('.', 1) + if len(FileAndExt) > 1: + FileName = FileAndExt[0] + '.xml' + else: + FileName = IniFile + '.xml' + File = open(FileName, 'w') + + try: + File.write(Root.toprettyxml(indent = ' ')) + finally: + File.close() + return FileName + diff --git a/roms/edk2/BaseTools/Source/Python/UPT/Xml/ModuleSurfaceAreaXml.py b/roms/edk2/BaseTools/Source/Python/UPT/Xml/ModuleSurfaceAreaXml.py new file mode 100644 index 000000000..741da9080 --- /dev/null +++ b/roms/edk2/BaseTools/Source/Python/UPT/Xml/ModuleSurfaceAreaXml.py @@ -0,0 +1,1003 @@ +## @file +# This file is used to parse a Module file of .PKG file +# +# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.
+# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# + +''' +ModuleSurfaceAreaXml +''' +from xml.dom import minidom + +from Library.StringUtils import ConvertNEToNOTEQ +from Library.StringUtils import ConvertNOTEQToNE +from Library.StringUtils import GetStringOfList +from Library.StringUtils import IsMatchArch +from Library.Xml.XmlRoutines import XmlElement +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 Object.POM.CommonObject import GuidVersionObject +from Object.POM.ModuleObject import BootModeObject +from Object.POM.ModuleObject import DepexObject +from Object.POM.ModuleObject import ModuleObject +from Object.POM.ModuleObject import EventObject +from Object.POM.ModuleObject import HobObject +from Object.POM.ModuleObject import SourceFileObject +from Object.POM.ModuleObject import PackageDependencyObject +from Object.POM.ModuleObject import ExternObject +from Object.POM.ModuleObject import BinaryFileObject +from Object.POM.ModuleObject import AsBuiltObject +from Object.POM.ModuleObject import BinaryBuildFlagObject +from Xml.CommonXml import ClonedFromXml +from Xml.CommonXml import HeaderXml +from Xml.CommonXml import HelpTextXml +from Xml.CommonXml import CommonDefinesXml +from Xml.CommonXml import LibraryClassXml +from Xml.CommonXml import UserExtensionsXml +from Xml.CommonXml import MiscellaneousFileXml +from Xml.CommonXml import FilenameXml +from Xml.GuidProtocolPpiXml import GuidXml +from Xml.GuidProtocolPpiXml import ProtocolXml +from Xml.GuidProtocolPpiXml import PpiXml +from Xml.PcdXml import PcdEntryXml +from Xml.XmlParserMisc import GetHelpTextList +from Library import GlobalData +from Library.Misc import GetSplitValueList + +## BinaryFileXml +# +# represent the following XML item +# +# +# +# xs:anyURI +# {1,} +# ... {0,} +# {1,} +# +class BinaryFileXml(object): + def __init__(self): + self.FileNames = [] + self.AsBuiltList = [] + self.PatchPcdValues = '' + self.PcdExValues = '' + self.LibraryInstances = '' + self.BuildFlags = '' + + def FromXml(self, Item, Key): + if self.FileNames: + pass + BinaryFile = BinaryFileObject() + FilenameList = [] + SupArchList = ['COMMON'] + for SubItem in XmlList(Item, '%s/Filename' % Key): + Axml = FilenameXml() + Bxml = Axml.FromXml(SubItem, 'Filename') + FilenameList.append(Bxml) + BinaryFile.SetFileNameList(FilenameList) + for FileName in FilenameList: + if FileName.GetSupArchList(): + SupArchList = FileName.GetSupArchList() + BinaryFile.SetSupArchList(SupArchList) + if GlobalData.gIS_BINARY_INF: + AsBuiltList = [] + for AsBuiltItem in XmlList(Item, '%s/AsBuilt' % Key): + AsBuilt = AsBuiltObject() + + PatchPcdValueList = [] + for SubItem in XmlList(AsBuiltItem, 'AsBuilt/PatchPcdValue'): + Axml = PcdEntryXml() + Bxml = Axml.FromXml(SubItem, 'PatchPcdValue') + PatchPcdValueList.append(Bxml) + AsBuilt.SetPatchPcdList(PatchPcdValueList) + PcdExValueList = [] + for SubItem in XmlList(AsBuiltItem, 'AsBuilt/PcdExValue'): + Axml = PcdEntryXml() + Bxml = Axml.FromXml(SubItem, 'PcdExValue') + PcdExValueList.append(Bxml) + AsBuilt.SetPcdExList(PcdExValueList) + LibraryList = [] + for SubItem in XmlList(Item, '%s/AsBuilt/LibraryInstances/GUID' % Key): + GuidVerObj = GuidVersionObject() + GUID = XmlElement(SubItem, 'GUID') + Version = XmlAttribute(XmlNode(SubItem, 'GUID'), 'Version') + GuidVerObj.SetGuid(GUID) + GuidVerObj.SetVersion(Version) + LibraryList.append(GuidVerObj) + if XmlList(Item, '%s/AsBuilt/LibraryInstances' % Key) and not LibraryList: + LibraryList = [None] + AsBuilt.SetLibraryInstancesList(LibraryList) + BuildFlagList = [] + for SubItem in XmlList(Item, '%s/AsBuilt/BuildFlags' % Key): + BuildFlag = BuildFlagXml() + BuildFlagList.append(BuildFlag.FromXml2(SubItem, 'BuildFlags')) + AsBuilt.SetBuildFlagsList(BuildFlagList) + AsBuiltList.append(AsBuilt) + BinaryFile.SetAsBuiltList(AsBuiltList) + return BinaryFile + + 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 __str__(self): + Str = "BinaryFiles:" + for Item in self.FileNames: + Str = Str + '\n\t' + str(Item) + for Item in self.PatchPcdValues: + Str = Str + '\n\t' + str(Item) + for Item in self.PcdExValues: + Str = Str + '\n\t' + str(Item) + for Item in self.LibraryInstances: + Str = Str + '\n\t' + str(Item) + for Item in self.BuildFlags: + Str = Str + '\n\t' + str(Item) + return Str + +## +# PackageXml +# +class PackageXml(object): + def __init__(self): + self.Description = '' + self.Guid = '' + self.Version = '' + self.CommonDefines = CommonDefinesXml() + + def FromXml(self, Item, Key): + self.Description = XmlElement(Item, '%s/Description' % Key) + self.Guid = XmlElement(Item, '%s/GUID' % Key) + self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version') + self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key) + + PackageDependency = PackageDependencyObject() + PackageDependency.SetPackage(self.Description) + PackageDependency.SetGuid(self.Guid) + PackageDependency.SetVersion(self.Version) + PackageDependency.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)) + PackageDependency.SetSupArchList(self.CommonDefines.SupArchList) + + return PackageDependency + + 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 __str__(self): + Str = "Description = %s Guid = %s Version = %s %s" \ + % (self.Description, self.Guid, self.Version, self.CommonDefines) + return Str +## +# ExternXml +# +class ExternXml(object): + def __init__(self): + self.CommonDefines = CommonDefinesXml() + self.EntryPoint = '' + self.UnloadImage = '' + self.Constructor = '' + self.Destructor = '' + self.SupModList = '' + self.SupArchList = '' + self.HelpText = [] + + def FromXml(self, Item, Key): + self.CommonDefines.FromXml(Item, Key) + self.EntryPoint = XmlElement(Item, '%s/EntryPoint' % Key) + self.UnloadImage = XmlElement(Item, '%s/UnloadImage' % Key) + self.Constructor = XmlElement(Item, '%s/Constructor' % Key) + self.Destructor = XmlElement(Item, '%s/Destructor' % Key) + + Extern = ExternObject() + Extern.SetEntryPoint(self.EntryPoint) + Extern.SetUnloadImage(self.UnloadImage) + Extern.SetConstructor(self.Constructor) + Extern.SetDestructor(self.Destructor) + if self.CommonDefines.SupModList: + Extern.SetSupModList(self.CommonDefines.SupModList) + if self.CommonDefines.SupArchList: + Extern.SetSupArchList(self.CommonDefines.SupArchList) + return Extern + + def ToXml(self, Extern, Key): + if self.HelpText: + pass + + NodeList = [] + if Extern.GetEntryPoint(): + NodeList.append(['EntryPoint', Extern.GetEntryPoint()]) + if Extern.GetUnloadImage(): + NodeList.append(['UnloadImage', Extern.GetUnloadImage()]) + if Extern.GetConstructor(): + NodeList.append(['Constructor', Extern.GetConstructor()]) + if Extern.GetDestructor(): + NodeList.append(['Destructor', Extern.GetDestructor()]) + Root = CreateXmlElement('%s' % Key, '', NodeList, []) + + return Root + + def __str__(self): + Str = "EntryPoint = %s UnloadImage = %s Constructor = %s Destructor = %s %s" \ + % (self.EntryPoint, self.UnloadImage, self.Constructor, self.Destructor, self.CommonDefines) + for Item in self.HelpText: + Str = Str + '\n\t' + str(Item) + return Str +## +# DepexXml +# +class DepexXml(object): + def __init__(self): + self.CommonDefines = CommonDefinesXml() + self.Expression = None + self.HelpText = [] + + def FromXml(self, Item, Key): + if not Item: + return None + self.CommonDefines.FromXml(Item, Key) + self.Expression = XmlElement(Item, '%s/Expression' % Key) + for HelpTextItem in XmlList(Item, '%s/HelpText' % Key): + HelpTextObj = HelpTextXml() + HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key) + self.HelpText.append(HelpTextObj) + + Depex = DepexObject() + Depex.SetDepex(self.Expression) + Depex.SetModuleType(self.CommonDefines.SupModList) + Depex.SetSupArchList(self.CommonDefines.SupArchList) + Depex.SetFeatureFlag(self.CommonDefines.FeatureFlag) + Depex.SetHelpTextList(GetHelpTextList(self.HelpText)) + + return Depex + + 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 __str__(self): + Str = "Expression = %s" % (self.Expression) + for Item in self.HelpText: + Str = Str + '\n\t' + str(Item) + return Str + +## +# BootModeXml +# +class BootModeXml(object): + def __init__(self): + self.SupportedBootModes = '' + self.CommonDefines = CommonDefinesXml() + self.HelpText = [] + + def FromXml(self, Item, Key): + self.SupportedBootModes = \ + XmlElement(Item, '%s/SupportedBootModes' % Key) + self.CommonDefines.FromXml(Item, Key) + for HelpTextItem in XmlList(Item, '%s/HelpText' % Key): + HelpTextObj = HelpTextXml() + HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key) + self.HelpText.append(HelpTextObj) + + BootMode = BootModeObject() + BootMode.SetSupportedBootModes(self.SupportedBootModes) + BootMode.SetUsage(self.CommonDefines.Usage) + BootMode.SetHelpTextList(GetHelpTextList(self.HelpText)) + + return BootMode + + 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 __str__(self): + Str = "SupportedBootModes = %s %s" % (self.SupportedBootModes, self.CommonDefines) + for Item in self.HelpText: + Str = Str + '\n\t' + str(Item) + return Str +## +# EventXml +# +class EventXml(object): + def __init__(self): + self.EventType = '' + self.Name = '' + self.CommonDefines = CommonDefinesXml() + self.HelpText = [] + + def FromXml(self, Item, Key): + self.EventType = XmlAttribute(XmlNode(Item, '%s' % Key), 'EventType') + self.Name = XmlElement(Item, '%s' % Key) + self.CommonDefines.FromXml(Item, Key) + for HelpTextItem in XmlList(Item, '%s/HelpText' % Key): + HelpTextObj = HelpTextXml() + HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key) + self.HelpText.append(HelpTextObj) + + Event = EventObject() + Event.SetEventType(self.EventType) + Event.SetUsage(self.CommonDefines.Usage) + Event.SetHelpTextList(GetHelpTextList(self.HelpText)) + + return Event + + 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 + + def __str__(self): + Str = "EventType = %s %s" % (self.EventType, self.CommonDefines) + for Item in self.HelpText: + Str = Str + '\n\t' + str(Item) + return Str +## +# HobXml +# +class HobXml(object): + def __init__(self): + self.HobType = '' + self.Name = '' + self.CommonDefines = CommonDefinesXml() + self.HelpText = [] + + def FromXml(self, Item, Key): + self.HobType = XmlAttribute(XmlNode(Item, '%s' % Key), 'HobType') + self.Name = XmlElement(Item, '%s' % Key) + self.CommonDefines.FromXml(Item, Key) + for HelpTextItem in XmlList(Item, '%s/HelpText' % Key): + HelpTextObj = HelpTextXml() + HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key) + self.HelpText.append(HelpTextObj) + + Hob = HobObject() + Hob.SetHobType(self.HobType) + Hob.SetSupArchList(self.CommonDefines.SupArchList) + Hob.SetUsage(self.CommonDefines.Usage) + Hob.SetHelpTextList(GetHelpTextList(self.HelpText)) + + return Hob + + 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 __str__(self): + Str = "HobType = %s %s" % (self.HobType, self.CommonDefines) + for Item in self.HelpText: + Str = Str + '\n\t' + str(Item) + return Str + +## +# SourceFileXml +# +class SourceFileXml(object): + def __init__(self): + self.SourceFile = '' + self.ToolChainFamily = '' + self.FileType = '' + self.CommonDefines = CommonDefinesXml() + + def FromXml(self, Item, Key): + self.ToolChainFamily = XmlAttribute(Item, 'Family') + self.SourceFile = XmlElement(Item, 'Filename') + self.CommonDefines.FromXml(Item, Key) + + self.CommonDefines.FeatureFlag = ConvertNOTEQToNE(self.CommonDefines.FeatureFlag) + + SourceFile = SourceFileObject() + SourceFile.SetSourceFile(self.SourceFile) + SourceFile.SetFamily(self.ToolChainFamily) + SourceFile.SetSupArchList(self.CommonDefines.SupArchList) + SourceFile.SetFeatureFlag(self.CommonDefines.FeatureFlag) + + return SourceFile + + 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 + +## +# ModulePropertyXml +# +class ModulePropertyXml(object): + def __init__(self): + self.CommonDefines = CommonDefinesXml() + self.ModuleType = '' + self.Path = '' + self.PcdIsDriver = '' + self.UefiSpecificationVersion = '' + self.PiSpecificationVersion = '' + self.SpecificationList = [] + self.SpecificationVersion = '' + self.BootModes = [] + self.Events = [] + self.HOBs = [] + + def FromXml(self, Item, Key, Header=None): + self.CommonDefines.FromXml(Item, Key) + self.ModuleType = XmlElement(Item, '%s/ModuleType' % Key) + self.Path = XmlElement(Item, '%s/Path' % Key) + self.PcdIsDriver = XmlElement(Item, '%s/PcdIsDriver' % Key) + self.UefiSpecificationVersion = XmlElement(Item, '%s/UefiSpecificationVersion' % Key) + self.PiSpecificationVersion = XmlElement(Item, '%s/PiSpecificationVersion' % Key) + for SubItem in XmlList(Item, '%s/Specification' % Key): + Specification = XmlElement(SubItem, '/Specification') + Version = XmlAttribute(XmlNode(SubItem, '/Specification'), 'Version') + self.SpecificationList.append((Specification, Version)) + for SubItem in XmlList(Item, '%s/BootMode' % Key): + Axml = BootModeXml() + BootMode = Axml.FromXml(SubItem, 'BootMode') + self.BootModes.append(BootMode) + for SubItem in XmlList(Item, '%s/Event' % Key): + Axml = EventXml() + Event = Axml.FromXml(SubItem, 'Event') + self.Events.append(Event) + for SubItem in XmlList(Item, '%s/HOB' % Key): + Axml = HobXml() + Hob = Axml.FromXml(SubItem, 'HOB') + self.HOBs.append(Hob) + + if Header is None: + Header = ModuleObject() + + Header.SetModuleType(self.ModuleType) + Header.SetSupArchList(self.CommonDefines.SupArchList) + Header.SetModulePath(self.Path) + + Header.SetPcdIsDriver(self.PcdIsDriver) + Header.SetUefiSpecificationVersion(self.UefiSpecificationVersion) + Header.SetPiSpecificationVersion(self.PiSpecificationVersion) + Header.SetSpecList(self.SpecificationList) + + return Header, self.BootModes, self.Events, self.HOBs + + + 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 __str__(self): + Str = "ModuleType = %s Path = %s PcdIsDriver = %s UefiSpecificationVersion = %s PiSpecificationVersion = %s \ + Specification = %s SpecificationVersion = %s %s" % \ + (self.ModuleType, self.Path, self.PcdIsDriver, \ + self.UefiSpecificationVersion, self.PiSpecificationVersion, \ + self.SpecificationList, self.SpecificationVersion, self.CommonDefines) + for Item in self.BootModes: + Str = Str + '\n\t' + str(Item) + for Item in self.Events: + Str = Str + '\n\t' + str(Item) + for Item in self.HOBs: + Str = Str + '\n\t' + str(Item) + return Str + +## +# ModuleXml +# +class ModuleSurfaceAreaXml(object): + def __init__(self, Package=''): + self.Module = None + # + # indicate the package that this module resides in + # + self.Package = Package + + def FromXml2(self, Item, Module): + if self.Module: + pass + # + # PeiDepex + # + PeiDepexList = [] + for SubItem in XmlList(Item, '/ModuleSurfaceArea/PeiDepex'): + Tmp = DepexXml() + Depex = Tmp.FromXml(XmlNode(SubItem, 'PeiDepex'), 'PeiDepex') + PeiDepexList.append(Depex) + Module.SetPeiDepex(PeiDepexList) + + # + # DxeDepex + # + DxeDepexList = [] + for SubItem in XmlList(Item, '/ModuleSurfaceArea/DxeDepex'): + Tmp = DepexXml() + Depex = Tmp.FromXml(XmlNode(SubItem, 'DxeDepex'), 'DxeDepex') + DxeDepexList.append(Depex) + Module.SetDxeDepex(DxeDepexList) + + # + # SmmDepex + # + SmmDepexList = [] + for SubItem in XmlList(Item, '/ModuleSurfaceArea/SmmDepex'): + Tmp = DepexXml() + Depex = Tmp.FromXml(XmlNode(SubItem, 'SmmDepex'), 'SmmDepex') + SmmDepexList.append(Depex) + Module.SetSmmDepex(SmmDepexList) + + # + # MiscellaneousFile + Tmp = MiscellaneousFileXml() + MiscFileList = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles') + if MiscFileList: + Module.SetMiscFileList([MiscFileList]) + else: + Module.SetMiscFileList([]) + + # + # UserExtensions + # + for Item in XmlList(Item, '/ModuleSurfaceArea/UserExtensions'): + Tmp = UserExtensionsXml() + UserExtension = Tmp.FromXml(Item, 'UserExtensions') + Module.SetUserExtensionList(Module.GetUserExtensionList() + [UserExtension]) + + return Module + + def FromXml(self, Item, Key, IsStandAlongModule=False): + IsBinaryModule = XmlAttribute(Item, 'BinaryModule') + # + # Header + # + Tmp = HeaderXml() + Module = Tmp.FromXml(XmlNode(Item, '/%s/Header' % Key), 'Header', True, IsStandAlongModule) + Module.SetBinaryModule(IsBinaryModule) + + if IsBinaryModule: + GlobalData.gIS_BINARY_INF = True + + # + # ModuleProperties + # + Tmp = ModulePropertyXml() + (Module, BootModes, Events, HOBs) = \ + Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ModuleProperties'), 'ModuleProperties', Module) + Module.SetBootModeList(BootModes) + Module.SetEventList(Events) + Module.SetHobList(HOBs) + # + # ClonedFrom + # + Tmp = ClonedFromXml() + ClonedFrom = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ClonedFrom'), 'ClonedFrom') + if ClonedFrom: + Module.SetClonedFrom(ClonedFrom) + + # + # LibraryClass + # + for SubItem in XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass'): + Tmp = LibraryClassXml() + LibraryClass = Tmp.FromXml(SubItem, 'LibraryClass') + Module.SetLibraryClassList(Module.GetLibraryClassList() + [LibraryClass]) + + if XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions') and \ + not XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass'): + Module.SetLibraryClassList([None]) + + # + # SourceFiles + # + for SubItem in XmlList(Item, '/ModuleSurfaceArea/SourceFiles/Filename'): + Tmp = SourceFileXml() + SourceFile = Tmp.FromXml(SubItem, 'Filename') + Module.SetSourceFileList(Module.GetSourceFileList() + [SourceFile]) + + if XmlList(Item, '/ModuleSurfaceArea/SourceFiles') and \ + not XmlList(Item, '/ModuleSurfaceArea/SourceFiles/Filename') : + Module.SetSourceFileList([None]) + + # + # BinaryFile + # + for SubItem in XmlList(Item, '/ModuleSurfaceArea/BinaryFiles/BinaryFile'): + Tmp = BinaryFileXml() + BinaryFile = Tmp.FromXml(SubItem, 'BinaryFile') + Module.SetBinaryFileList(Module.GetBinaryFileList() + [BinaryFile]) + + if XmlList(Item, '/ModuleSurfaceArea/BinaryFiles') and \ + not XmlList(Item, '/ModuleSurfaceArea/BinaryFiles/BinaryFile') : + Module.SetBinaryFileList([None]) + # + # PackageDependencies + # + for SubItem in XmlList(Item, '/ModuleSurfaceArea/PackageDependencies/Package'): + Tmp = PackageXml() + PackageDependency = Tmp.FromXml(SubItem, 'Package') + Module.SetPackageDependencyList(Module.GetPackageDependencyList() + [PackageDependency]) + + if XmlList(Item, '/ModuleSurfaceArea/PackageDependencies') and \ + not XmlList(Item, '/ModuleSurfaceArea/PackageDependencies/Package'): + Module.SetPackageDependencyList([None]) + + # + # Guid + # + for SubItem in XmlList(Item, '/ModuleSurfaceArea/Guids/GuidCName'): + Tmp = GuidXml('Module') + GuidProtocolPpi = Tmp.FromXml(SubItem, 'GuidCName') + Module.SetGuidList(Module.GetGuidList() + [GuidProtocolPpi]) + + if XmlList(Item, '/ModuleSurfaceArea/Guids') and not XmlList(Item, '/ModuleSurfaceArea/Guids/GuidCName'): + Module.SetGuidList([None]) + + # + # Protocol + # + for SubItem in XmlList(Item, '/ModuleSurfaceArea/Protocols/Protocol'): + Tmp = ProtocolXml('Module') + GuidProtocolPpi = Tmp.FromXml(SubItem, 'Protocol') + Module.SetProtocolList(Module.GetProtocolList() + [GuidProtocolPpi]) + + if XmlList(Item, '/ModuleSurfaceArea/Protocols') and not XmlList(Item, '/ModuleSurfaceArea/Protocols/Protocol'): + Module.SetProtocolList([None]) + + # + # Ppi + # + for SubItem in XmlList(Item, '/ModuleSurfaceArea/PPIs/Ppi'): + Tmp = PpiXml('Module') + GuidProtocolPpi = Tmp.FromXml(SubItem, 'Ppi') + Module.SetPpiList(Module.GetPpiList() + [GuidProtocolPpi]) + + if XmlList(Item, '/ModuleSurfaceArea/PPIs') and not XmlList(Item, '/ModuleSurfaceArea/PPIs/Ppi'): + Module.SetPpiList([None]) + + # + # Extern + # + for SubItem in XmlList(Item, '/ModuleSurfaceArea/Externs/Extern'): + Tmp = ExternXml() + Extern = Tmp.FromXml(SubItem, 'Extern') + Module.SetExternList(Module.GetExternList() + [Extern]) + + if XmlList(Item, '/ModuleSurfaceArea/Externs') and not XmlList(Item, '/ModuleSurfaceArea/Externs/Extern'): + Module.SetExternList([None]) + + if not Module.GetBinaryModule(): + # + # PcdCoded + # + for SubItem in XmlList(Item, '/ModuleSurfaceArea/PcdCoded/PcdEntry'): + Tmp = PcdEntryXml() + PcdEntry = Tmp.FromXml3(SubItem, 'PcdEntry') + Module.SetPcdList(Module.GetPcdList() + [PcdEntry]) + + if XmlList(Item, '/ModuleSurfaceArea/PcdCoded') and \ + not XmlList(Item, '/ModuleSurfaceArea/PcdCoded/PcdEntry'): + Module.SetPcdList([None]) + + Module = self.FromXml2(Item, Module) + # + # return the module object + # + self.Module = Module + return self.Module + + def ToXml(self, Module): + if self.Package: + pass + # + # Create root node of module surface area + # + DomModule = minidom.Document().createElement('ModuleSurfaceArea') + if Module.GetBinaryModule(): + DomModule.setAttribute('BinaryModule', 'true') + + # + # Header + # + Tmp = HeaderXml() + DomModule.appendChild(Tmp.ToXml(Module, 'Header')) + # + # ModuleProperties + # + Tmp = ModulePropertyXml() + DomModule.appendChild(Tmp.ToXml(Module, Module.GetBootModeList(), Module.GetEventList(), Module.GetHobList(), \ + 'ModuleProperties')) + # + # ClonedFrom + # + Tmp = ClonedFromXml() + if Module.GetClonedFrom(): + DomModule.appendChild(Tmp.ToXml(Module.GetClonedFrom(), 'ClonedFrom')) + # + # LibraryClass + # + LibraryClassNode = CreateXmlElement('LibraryClassDefinitions', '', [], []) + for LibraryClass in Module.GetLibraryClassList(): + Tmp = LibraryClassXml() + LibraryClassNode.appendChild(Tmp.ToXml2(LibraryClass, 'LibraryClass')) + DomModule.appendChild(LibraryClassNode) + # + # SourceFile + # + SourceFileNode = CreateXmlElement('SourceFiles', '', [], []) + for SourceFile in Module.GetSourceFileList(): + Tmp = SourceFileXml() + SourceFileNode.appendChild(Tmp.ToXml(SourceFile, 'Filename')) + DomModule.appendChild(SourceFileNode) + # + # BinaryFile + # + BinaryFileNode = CreateXmlElement('BinaryFiles', '', [], []) + for BinaryFile in Module.GetBinaryFileList(): + Tmp = BinaryFileXml() + BinaryFileNode.appendChild(Tmp.ToXml(BinaryFile, 'BinaryFile')) + DomModule.appendChild(BinaryFileNode) + # + # PackageDependencies + # + PackageDependencyNode = CreateXmlElement('PackageDependencies', '', [], []) + for PackageDependency in Module.GetPackageDependencyList(): + Tmp = PackageXml() + PackageDependencyNode.appendChild(Tmp.ToXml(PackageDependency, 'Package')) + DomModule.appendChild(PackageDependencyNode) + + # + # Guid + # + GuidProtocolPpiNode = CreateXmlElement('Guids', '', [], []) + for GuidProtocolPpi in Module.GetGuidList(): + Tmp = GuidXml('Module') + GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'GuidCName')) + DomModule.appendChild(GuidProtocolPpiNode) + + # + # Protocol + # + GuidProtocolPpiNode = CreateXmlElement('Protocols', '', [], []) + for GuidProtocolPpi in Module.GetProtocolList(): + Tmp = ProtocolXml('Module') + GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Protocol')) + DomModule.appendChild(GuidProtocolPpiNode) + + # + # Ppi + # + GuidProtocolPpiNode = CreateXmlElement('PPIs', '', [], []) + for GuidProtocolPpi in Module.GetPpiList(): + Tmp = PpiXml('Module') + GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Ppi')) + DomModule.appendChild(GuidProtocolPpiNode) + # + # Extern + # + ExternNode = CreateXmlElement('Externs', '', [], []) + for Extern in Module.GetExternList(): + Tmp = ExternXml() + ExternNode.appendChild(Tmp.ToXml(Extern, 'Extern')) + DomModule.appendChild(ExternNode) + # + # PcdCoded + # + PcdEntryNode = CreateXmlElement('PcdCoded', '', [], []) + for PcdEntry in Module.GetPcdList(): + Tmp = PcdEntryXml() + PcdEntryNode.appendChild(Tmp.ToXml3(PcdEntry, 'PcdEntry')) + DomModule.appendChild(PcdEntryNode) + + # + # PeiDepex + # + if Module.GetPeiDepex(): + for Item in Module.GetPeiDepex(): + Tmp = DepexXml() + DomModule.appendChild(Tmp.ToXml(Item, 'PeiDepex')) + + # + # DxeDepex + # + if Module.GetDxeDepex(): + for Item in Module.GetDxeDepex(): + Tmp = DepexXml() + DomModule.appendChild(Tmp.ToXml(Item, 'DxeDepex')) + + # + # SmmDepex + # + if Module.GetSmmDepex(): + for Item in Module.GetSmmDepex(): + Tmp = DepexXml() + DomModule.appendChild(Tmp.ToXml(Item, 'SmmDepex')) + + # + # MiscellaneousFile + # + if Module.GetMiscFileList(): + Tmp = MiscellaneousFileXml() + DomModule.appendChild(Tmp.ToXml(Module.GetMiscFileList()[0], 'MiscellaneousFiles')) + # + # UserExtensions + # + if Module.GetUserExtensionList(): + for UserExtension in Module.GetUserExtensionList(): + Tmp = UserExtensionsXml() + DomModule.appendChild(Tmp.ToXml(UserExtension, 'UserExtensions')) + + return DomModule + +## +# BuildFlagXml used to generate BuildFlag for +# +class BuildFlagXml(object): + def __init__(self): + self.Target = '' + self.TagName = '' + self.Family = '' + self.AsBuiltFlags = '' + + def FromXml(self, Item, Key): + self.Target = XmlElement(Item, '%s/Target' % Key) + self.TagName = XmlElement(Item, '%s/TagName' % Key) + self.Family = XmlElement(Item, '%s/Family' % Key) + + BuildFlag = BinaryBuildFlagObject() + + BuildFlag.SetTarget(self.Target) + BuildFlag.SetTagName(self.TagName) + BuildFlag.SetFamily(self.Family) + + return BuildFlag + + # + # For AsBuild INF usage + # + def FromXml2(self, Item, Key): + self.AsBuiltFlags = XmlElement(Item, '%s' % Key) + + LineList = GetSplitValueList(self.AsBuiltFlags, '\n') + ReturnLine = '' + Count = 0 + for Line in LineList: + if Count == 0: + ReturnLine = "# " + Line + else: + ReturnLine = ReturnLine + '\n' + '# ' + Line + Count += 1 + + BuildFlag = BinaryBuildFlagObject() + BuildFlag.SetAsBuiltOptionFlags(ReturnLine) + + return BuildFlag + + def ToXml(self, BuildFlag, Key): + if self.Target: + pass + AttributeList = [] + NodeList = [] + NodeList.append(['BuildFlags', BuildFlag]) + + Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) + return Root diff --git a/roms/edk2/BaseTools/Source/Python/UPT/Xml/PackageSurfaceAreaXml.py b/roms/edk2/BaseTools/Source/Python/UPT/Xml/PackageSurfaceAreaXml.py new file mode 100644 index 000000000..103939023 --- /dev/null +++ b/roms/edk2/BaseTools/Source/Python/UPT/Xml/PackageSurfaceAreaXml.py @@ -0,0 +1,402 @@ +## @file +# This file is used to parse a Package file of .PKG file +# +# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.
+# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# + +''' +PackageSurfaceAreaXml +''' +from xml.dom import minidom + +from Library.StringUtils import GetStringOfList +from Library.Xml.XmlRoutines import XmlElement +from Library.Xml.XmlRoutines import XmlNode +from Library.Xml.XmlRoutines import XmlList +from Library.Xml.XmlRoutines import CreateXmlElement +from Object.POM.CommonObject import IncludeObject +from Object.POM.CommonObject import TextObject +from Object.POM.PackageObject import PackageObject +from Xml.CommonXml import ClonedFromXml +from Xml.CommonXml import PackageHeaderXml +from Xml.CommonXml import HelpTextXml +from Xml.CommonXml import CommonDefinesXml +from Xml.CommonXml import LibraryClassXml +from Xml.CommonXml import UserExtensionsXml +from Xml.CommonXml import MiscellaneousFileXml +from Xml.GuidProtocolPpiXml import GuidXml +from Xml.GuidProtocolPpiXml import ProtocolXml +from Xml.GuidProtocolPpiXml import PpiXml +from Xml.ModuleSurfaceAreaXml import ModuleSurfaceAreaXml +from Xml.PcdXml import PcdEntryXml + +## +# IndustryStandardHeaderXml +# +class IndustryStandardHeaderXml(object): + def __init__(self): + self.HeaderFile = '' + self.HelpText = [] + + def FromXml(self, Item, Key): + self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key) + for HelpTextItem in XmlList(Item, '%s/HelpText' % Key): + HelpTextObj = HelpTextXml() + HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key) + self.HelpText.append(HelpTextObj) + + Include = IncludeObject() + Include.SetFilePath(self.HeaderFile) + HelpTxt = TextObject() + HelpTxt.SetString(self.HelpText) + Include.SetHelpText(HelpTxt) + + return Include + + def ToXml(self, IndustryStandardHeader, Key): + if self.HeaderFile: + pass + AttributeList = [] + NodeList = [['HeaderFile', IndustryStandardHeader.GetFilePath()]] + Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) + + return Root + + def __str__(self): + Str = "HeaderFile = %s" % (self.HeaderFile) + for Item in self.HelpText: + Str = Str + "\n\t" + str(Item) + return Str +## +# PackageIncludeHeaderXml +# +class PackageIncludeHeaderXml(object): + def __init__(self): + self.HeaderFile = '' + self.CommonDefines = CommonDefinesXml() + self.HelpText = [] + + def FromXml(self, Item, Key): + self.HeaderFile = XmlElement(Item, '%s/HeaderFile' % Key) + self.CommonDefines.FromXml(XmlNode(Item, '%s/HeaderFile' % Key), 'HeaderFile') + for HelpTextItem in XmlList(Item, '%s/HelpText' % Key): + HelpTextObj = HelpTextXml() + HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key) + self.HelpText.append(HelpTextObj) + + Include = IncludeObject() + Include.SetFilePath(self.HeaderFile) + Include.SetSupArchList(self.CommonDefines.SupArchList) + HelpTxt = TextObject() + HelpTxt.SetString(self.HelpText) + Include.SetHelpText(HelpTxt) + + return Include + + 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 __str__(self): + Str = "HeaderFile = %s\n\t%s" % (self.HeaderFile, self.CommonDefines) + for Item in self.HelpText: + Str = Str + "\n\t" + str(Item) + return Str + +## +# PcdCheckXml +# +class PcdCheckXml(object): + def __init__(self): + self.PcdCheck = '' + + def FromXml(self, Item, Key): + if Key: + pass + self.PcdCheck = XmlElement(Item, 'PcdCheck') + + return self.PcdCheck + + def ToXml(self, PcdCheck, Key): + if self.PcdCheck: + pass + Root = CreateXmlElement('%s' % Key, PcdCheck, [], []) + return Root + + def __str__(self): + return "PcdCheck = %s" % (self.PcdCheck) + +## +# PackageSurfaceAreaXml +# +class PackageSurfaceAreaXml(object): + def __init__(self): + self.Package = None + + def FromXml(self, Item, Key): + if Key: + pass + # + # Create a package object + # + Package = PackageObject() + # + # Header + # + Tmp = PackageHeaderXml() + Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/Header'), 'Header', Package) + # + # ClonedFrom + # + Tmp = ClonedFromXml() + if XmlNode(Item, '/PackageSurfaceArea/ClonedFrom'): + ClonedFrom = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/ClonedFrom'), 'ClonedFrom') + Package.SetClonedFromList([ClonedFrom]) + # + # LibraryClass + # + + for SubItem in XmlList(Item, '/PackageSurfaceArea/LibraryClassDeclarations/LibraryClass'): + Tmp = LibraryClassXml() + LibraryClass = Tmp.FromXml(SubItem, 'LibraryClass') + Package.SetLibraryClassList(Package.GetLibraryClassList() + [LibraryClass]) + + if XmlList(Item, '/PackageSurfaceArea/LibraryClassDeclarations') and \ + not XmlList(Item, '/PackageSurfaceArea/LibraryClassDeclarations/LibraryClass'): + Package.SetLibraryClassList([None]) + + # + # IndustryStandardHeader + # + for SubItem in XmlList(Item, '/PackageSurfaceArea/IndustryStandardIncludes/IndustryStandardHeader'): + Tmp = IndustryStandardHeaderXml() + Include = Tmp.FromXml(SubItem, 'IndustryStandardHeader') + Package.SetStandardIncludeFileList(Package.GetStandardIncludeFileList() + [Include]) + + if XmlList(Item, '/PackageSurfaceArea/IndustryStandardIncludes') and \ + not XmlList(Item, '/PackageSurfaceArea/IndustryStandardIncludes/IndustryStandardHeader'): + Package.SetStandardIncludeFileList([None]) + + + # + # PackageHeader + # + for SubItem in XmlList(Item, '/PackageSurfaceArea/PackageIncludes/PackageHeader'): + Tmp = PackageIncludeHeaderXml() + Include = Tmp.FromXml(SubItem, 'PackageHeader') + Package.SetPackageIncludeFileList(Package.GetPackageIncludeFileList() + [Include]) + + if XmlList(Item, '/PackageSurfaceArea/PackageIncludes') and not \ + XmlList(Item, '/PackageSurfaceArea/PackageIncludes/PackageHeader'): + Package.SetPackageIncludeFileList([None]) + + # + # Guid + # + for SubItem in XmlList(Item, '/PackageSurfaceArea/GuidDeclarations/Entry'): + Tmp = GuidXml('Package') + GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry') + Package.SetGuidList(Package.GetGuidList() + [GuidProtocolPpi]) + + if XmlList(Item, '/PackageSurfaceArea/GuidDeclarations') and not \ + XmlList(Item, '/PackageSurfaceArea/GuidDeclarations/Entry'): + Package.SetGuidList([None]) + + # + # Protocol + # + for SubItem in XmlList(Item, '/PackageSurfaceArea/ProtocolDeclarations/Entry'): + Tmp = ProtocolXml('Package') + GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry') + Package.SetProtocolList(Package.GetProtocolList() + [GuidProtocolPpi]) + + if XmlList(Item, '/PackageSurfaceArea/ProtocolDeclarations') and not \ + XmlList(Item, '/PackageSurfaceArea/ProtocolDeclarations/Entry'): + Package.SetProtocolList([None]) + + # + # Ppi + # + for SubItem in XmlList(Item, '/PackageSurfaceArea/PpiDeclarations/Entry'): + Tmp = PpiXml('Package') + GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry') + Package.SetPpiList(Package.GetPpiList() + [GuidProtocolPpi]) + + if XmlList(Item, '/PackageSurfaceArea/PpiDeclarations') and not \ + XmlList(Item, '/PackageSurfaceArea/PpiDeclarations/Entry'): + Package.SetPpiList([None]) + + # + # PcdEntry + # + for SubItem in XmlList(Item, '/PackageSurfaceArea/PcdDeclarations/PcdEntry'): + Tmp = PcdEntryXml() + PcdEntry = Tmp.FromXml2(SubItem, 'PcdEntry') + Package.SetPcdList(Package.GetPcdList() + [PcdEntry]) + + # + # Get PcdErrorCommentDict from PcdError in PcdEntry Node + # + for PcdErrorObj in PcdEntry.GetPcdErrorsList(): + PcdErrorMessageList = PcdErrorObj.GetErrorMessageList() + if PcdErrorMessageList: + Package.PcdErrorCommentDict[(PcdEntry.GetTokenSpaceGuidCName(), PcdErrorObj.GetErrorNumber())] = \ + PcdErrorMessageList + + + if XmlList(Item, '/PackageSurfaceArea/PcdDeclarations') and not \ + XmlList(Item, '/PackageSurfaceArea/PcdDeclarations/PcdEntry'): + Package.SetPcdList([None]) + + # + # PcdCheck + # + for SubItem in XmlList(Item, '/PackageSurfaceArea/PcdRelationshipChecks/PcdCheck'): + Tmp = PcdCheckXml() + PcdCheck = Tmp.FromXml(SubItem, 'PcdCheck') + Package.PcdChecks.append(PcdCheck) + + # + # Modules + # + for SubItem in XmlList(Item, '/PackageSurfaceArea/Modules/ModuleSurfaceArea'): + Tmp = ModuleSurfaceAreaXml() + Module = Tmp.FromXml(SubItem, 'ModuleSurfaceArea') + ModuleDictKey = (Module.GetGuid(), Module.GetVersion(), Module.GetName(), Module.GetModulePath()) + Package.ModuleDict[ModuleDictKey] = Module + # + # MiscellaneousFile + # + Tmp = MiscellaneousFileXml() + MiscFileList = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles') + if MiscFileList: + Package.SetMiscFileList([MiscFileList]) + else: + Package.SetMiscFileList([]) + + # + # UserExtensions + # + for Item in XmlList(Item, '/PackageSurfaceArea/UserExtensions'): + Tmp = UserExtensionsXml() + UserExtension = Tmp.FromXml(Item, 'UserExtensions') + Package.UserExtensionList.append(UserExtension) + + self.Package = Package + return self.Package + + def ToXml(self, Package): + if self.Package: + pass + # + # Create PackageSurfaceArea node + # + DomPackage = minidom.Document().createElement('PackageSurfaceArea') + # + # Header + # + Tmp = PackageHeaderXml() + DomPackage.appendChild(Tmp.ToXml(Package, 'Header')) + # + # ClonedFrom + # + Tmp = ClonedFromXml() + if Package.GetClonedFromList() != []: + DomPackage.appendChild(Tmp.ToXml(Package.GetClonedFromList[0], 'ClonedFrom')) + # + # LibraryClass + # + LibraryClassNode = CreateXmlElement('LibraryClassDeclarations', '', [], []) + for LibraryClass in Package.GetLibraryClassList(): + Tmp = LibraryClassXml() + LibraryClassNode.appendChild(Tmp.ToXml(LibraryClass, 'LibraryClass')) + DomPackage.appendChild(LibraryClassNode) + # + # IndustryStandardHeader + # + IndustryStandardHeaderNode = CreateXmlElement('IndustryStandardIncludes', '', [], []) + for Include in Package.GetStandardIncludeFileList(): + Tmp = IndustryStandardHeaderXml() + IndustryStandardHeaderNode.appendChild(Tmp.ToXml(Include, 'IndustryStandardHeader')) + DomPackage.appendChild(IndustryStandardHeaderNode) + # + # PackageHeader + # + PackageIncludeHeaderNode = CreateXmlElement('PackageIncludes', '', [], []) + for Include in Package.GetPackageIncludeFileList(): + Tmp = PackageIncludeHeaderXml() + PackageIncludeHeaderNode.appendChild(Tmp.ToXml(Include, 'PackageHeader')) + DomPackage.appendChild(PackageIncludeHeaderNode) + ModuleNode = CreateXmlElement('Modules', '', [], []) + for Module in Package.GetModuleDict().values(): + Tmp = ModuleSurfaceAreaXml() + ModuleNode.appendChild(Tmp.ToXml(Module)) + DomPackage.appendChild(ModuleNode) + # + # Guid + # + GuidProtocolPpiNode = CreateXmlElement('GuidDeclarations', '', [], []) + for GuidProtocolPpi in Package.GetGuidList(): + Tmp = GuidXml('Package') + GuidProtocolPpiNode.appendChild(Tmp.ToXml\ + (GuidProtocolPpi, 'Entry')) + DomPackage.appendChild(GuidProtocolPpiNode) + # + # Protocol + # + GuidProtocolPpiNode = \ + CreateXmlElement('ProtocolDeclarations', '', [], []) + for GuidProtocolPpi in Package.GetProtocolList(): + Tmp = ProtocolXml('Package') + GuidProtocolPpiNode.appendChild\ + (Tmp.ToXml(GuidProtocolPpi, 'Entry')) + DomPackage.appendChild(GuidProtocolPpiNode) + # + # Ppi + # + GuidProtocolPpiNode = CreateXmlElement('PpiDeclarations', '', [], []) + for GuidProtocolPpi in Package.GetPpiList(): + Tmp = PpiXml('Package') + GuidProtocolPpiNode.appendChild\ + (Tmp.ToXml(GuidProtocolPpi, 'Entry')) + DomPackage.appendChild(GuidProtocolPpiNode) + # + # PcdEntry + # + PcdEntryNode = CreateXmlElement('PcdDeclarations', '', [], []) + for PcdEntry in Package.GetPcdList(): + Tmp = PcdEntryXml() + PcdEntryNode.appendChild(Tmp.ToXml2(PcdEntry, 'PcdEntry')) + DomPackage.appendChild(PcdEntryNode) + + # + # MiscellaneousFile + # + Tmp = MiscellaneousFileXml() + if Package.GetMiscFileList(): + DomPackage.appendChild(Tmp.ToXml(Package.GetMiscFileList()[0], 'MiscellaneousFiles')) + + # + # UserExtensions + # + if Package.GetUserExtensionList(): + for UserExtension in Package.GetUserExtensionList(): + Tmp = UserExtensionsXml() + DomPackage.appendChild(Tmp.ToXml(UserExtension, 'UserExtensions')) + + return DomPackage diff --git a/roms/edk2/BaseTools/Source/Python/UPT/Xml/PcdXml.py b/roms/edk2/BaseTools/Source/Python/UPT/Xml/PcdXml.py new file mode 100644 index 000000000..bbcee45a0 --- /dev/null +++ b/roms/edk2/BaseTools/Source/Python/UPT/Xml/PcdXml.py @@ -0,0 +1,555 @@ +## @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 +# + +''' +PcdXml +''' + +## +# Import Modules +# + +from Library.Xml.XmlRoutines import XmlElement +from Library.Xml.XmlRoutines import XmlAttribute +from Library.Xml.XmlRoutines import XmlNode +from Library.Xml.XmlRoutines import CreateXmlElement +from Library.Xml.XmlRoutines import XmlList +from Library.StringUtils import GetStringOfList +from Library.StringUtils import ConvertNEToNOTEQ +from Library.StringUtils import ConvertNOTEQToNE +from Library import GlobalData +from Object.POM.CommonObject import PcdObject +from Object.POM.CommonObject import PcdErrorObject +from Xml.CommonXml import HelpTextXml +from Xml.CommonXml import PromptXml +from Xml.CommonXml import CommonDefinesXml +from Xml.XmlParserMisc import GetHelpTextList +from Xml.XmlParserMisc import GetPromptList +import re + +## +# PcdErrorXml +# +class PcdErrorXml(object): + def __init__(self): + self.ValidValueList = '' + self.ValidValueListLang = '' + self.ValidValueRange = '' + self.Expression = '' + self.ErrorNumber = '' + self.ErrorMessage = [] + + def FromXml(self, Item, Key): + self.ValidValueList = XmlElement(Item, '%s/ValidValueList' % Key) + self.ValidValueListLang = \ + XmlAttribute(XmlNode(Item, '%s/ValidValueList' % Key), 'Lang') + self.ValidValueRange = self.TransferValidEpxr2ValidRange(XmlElement(Item, '%s/ValidValueRange' % Key)) + self.Expression = XmlElement(Item, '%s/Expression' % Key) + self.ErrorNumber = XmlElement(Item, '%s/ErrorNumber' % Key) + for ErrMsg in XmlList(Item, '%s/ErrorMessage' % Key): + ErrorMessageString = XmlElement(ErrMsg, 'ErrorMessage') + ErrorMessageLang = \ + XmlAttribute(XmlNode(ErrMsg, 'ErrorMessage'), 'Lang') + self.ErrorMessage.append((ErrorMessageLang, ErrorMessageString)) + + Error = PcdErrorObject() + Error.SetValidValue(self.ValidValueList) + Error.SetValidValueLang(self.ValidValueListLang) + Error.SetValidValueRange(self.ValidValueRange) + Error.SetExpression(self.Expression) + Error.SetErrorNumber(self.ErrorNumber) + Error.SetErrorMessageList(self.ErrorMessage) + + return Error + + 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 TransferValidRange2Expr(self, TokenSpaceGuidCName, CName, ValidRange): + if self.Expression: + pass + INT_RANGE_PATTERN1 = '[\t\s]*[0-9]+[\t\s]*-[\t\s]*[0-9]+' + INT_RANGE_PATTERN2 = '[\t\s]*(LT|GT|LE|GE|XOR|EQ)[\t\s]+\d+[\t\s]*' + HEX_RANGE_PATTERN1 = \ + '[\t\s]*0[xX][a-fA-F0-9]+[\t\s]*-[\t\s]*0[xX][a-fA-F0-9]+' + HEX_RANGE_PATTERN2 = '[\t\s]*(LT|GT|LE|GE|XOR|EQ)[\t\s]+0[xX][a-fA-F0-9]+[\t\s]*' + IntMatch1 = re.compile(INT_RANGE_PATTERN1) + IntMatch2 = re.compile(INT_RANGE_PATTERN2) + HexMatch1 = re.compile(HEX_RANGE_PATTERN1) + HexMatch2 = re.compile(HEX_RANGE_PATTERN2) + PcdName = '.'.join([TokenSpaceGuidCName, CName]) + HexMatchedList = [] + IntMatchedList = [] + # + # Convert HEX2 format range + # + if HexMatch2: + for MatchObj in HexMatch2.finditer(ValidRange): + MatchStr = MatchObj.group() + TransferedRangeStr = ' '.join(['', PcdName, MatchStr.strip()]) + ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr) + # + # Convert INT2 format range + # + if IntMatch2: + for MatchObj in IntMatch2.finditer(ValidRange): + MatchStr = MatchObj.group() + TransferedRangeStr = ' '.join(['', PcdName, MatchStr.strip()]) + ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr) + # + # Convert HEX1 format range + # + if HexMatch1: + HexMatchedList += HexMatch1.findall(ValidRange) + + for MatchStr in HexMatchedList: + RangeItemList = MatchStr.strip().split('-') + TransferedRangeStr = '(%s GE %s) AND (%s LE %s)' % \ + (PcdName, RangeItemList[0].strip(), PcdName, RangeItemList[1].strip()) + ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr) + # + # Convert INT1 format range + # + if IntMatch1: + IntMatchedList += IntMatch1.findall(ValidRange) + + for MatchStr in IntMatchedList: + RangeItemList = MatchStr.strip().split('-') + TransferedRangeStr = '(%s GE %s) AND (%s LE %s)' % \ + (PcdName, RangeItemList[0].strip(), PcdName, RangeItemList[1].strip()) + ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr) + + return ValidRange + + def TransferValidEpxr2ValidRange(self, ValidRangeExpr): + if self.Expression: + pass + + PCD_PATTERN = \ + '[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*\.[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*' + IntPattern1 = \ + '[\t\s]*\([\t\s]*'+PCD_PATTERN+'[\t\s]+GE[\t\s]+\d+[\t\s]*\)[\t\s]+AND[\t\s]+\([\t\s]*'+\ + PCD_PATTERN+'[\t\s]+LE[\t\s]+\d+[\t\s]*\)' + IntPattern1 = IntPattern1.replace(' ', '') + IntPattern2 = '[\t\s]*'+PCD_PATTERN+'[\t\s]+(LT|GT|LE|GE|XOR|EQ)[\t\s]+\d+[\t\s]*' + + HexPattern1 = \ + '[\t\s]*\([\t\s]*'+PCD_PATTERN+'[\t\s]+GE[\t\s]+0[xX][0-9a-fA-F]+[\t\s]*\)[\t\s]+AND[\t\s]+\([\t\s]*'+\ + PCD_PATTERN+'[\t\s]+LE[\t\s]+0[xX][0-9a-fA-F]+[\t\s]*\)' + HexPattern1 = HexPattern1.replace(' ', '') + HexPattern2 = '[\t\s]*'+PCD_PATTERN+'[\t\s]+(LT|GT|LE|GE|XOR|EQ)[\t\s]+0[xX][0-9a-zA-Z]+[\t\s]*' + + # + # Do the Hex1 conversion + # + HexMatchedList = re.compile(HexPattern1).findall(ValidRangeExpr) + HexRangeDict = {} + for HexMatchedItem in HexMatchedList: + # + # To match items on both sides of '-' + # + RangeItemList = re.compile('[\t\s]*0[xX][0-9a-fA-F]+[\t\s]*').findall(HexMatchedItem) + if RangeItemList and len(RangeItemList) == 2: + HexRangeDict[HexMatchedItem] = RangeItemList + + for Key in HexRangeDict.keys(): + MaxItem = MixItem = '' + if int(HexRangeDict[Key][0], 16) > int(HexRangeDict[Key][1], 16): + MaxItem = HexRangeDict[Key][0] + MixItem = HexRangeDict[Key][1] + else: + MaxItem = HexRangeDict[Key][1] + MixItem = HexRangeDict[Key][0] + + Range = ' %s - %s' % (MixItem.strip(), MaxItem.strip()) + ValidRangeExpr = ValidRangeExpr.replace(Key, Range) + # + # Do the INT1 conversion + # + IntRangeDict = {} + IntMatchList = re.compile(IntPattern1).findall(ValidRangeExpr) + for MatchedItem in IntMatchList: + # + # To match items on both sides of '-' + # + RangeItemList = re.compile('[\t\s]*\d+[\t\s]*').findall(MatchedItem) + if RangeItemList and len(RangeItemList) == 2: + IntRangeDict[MatchedItem] = RangeItemList + + for Key in IntRangeDict.keys(): + MaxItem = MixItem = '' + if int(IntRangeDict[Key][0]) > int(IntRangeDict[Key][1]): + MaxItem = IntRangeDict[Key][0] + MixItem = IntRangeDict[Key][1] + else: + MaxItem = IntRangeDict[Key][1] + MixItem = IntRangeDict[Key][0] + + Range = ' %s - %s' % (MixItem.strip(), MaxItem.strip()) + ValidRangeExpr = ValidRangeExpr.replace(Key, Range) + # + # Do the HEX2 conversion + # + for MatchObj in re.compile(HexPattern2).finditer(ValidRangeExpr): + MatchStr = MatchObj.group() + Range = re.compile(PCD_PATTERN).sub(' ', MatchStr) + ValidRangeExpr = ValidRangeExpr.replace(MatchStr, Range) + # + # Do the INT2 conversion + # + for MatchObj in re.compile(IntPattern2).finditer(ValidRangeExpr): + MatchStr = MatchObj.group() + Range = re.compile(PCD_PATTERN).sub(' ', MatchStr) + ValidRangeExpr = ValidRangeExpr.replace(MatchStr, Range) + + return ValidRangeExpr + + + + def __str__(self): + return "ValidValueList = %s ValidValueListLang = %s ValidValueRange \ + = %s Expression = %s ErrorNumber = %s %s" % \ + (self.ValidValueList, self.ValidValueListLang, self.ValidValueRange, \ + self.Expression, self.ErrorNumber, self.ErrorMessage) + +## +# PcdEntryXml +# +class PcdEntryXml(object): + def __init__(self): + self.PcdItemType = '' + self.PcdUsage = '' + self.TokenSpaceGuidCName = '' + self.TokenSpaceGuidValue = '' + self.Token = '' + self.CName = '' + self.PcdCName = '' + self.DatumType = '' + self.ValidUsage = '' + self.DefaultValue = '' + self.MaxDatumSize = '' + self.Value = '' + self.Offset = '' + self.CommonDefines = CommonDefinesXml() + self.Prompt = [] + self.HelpText = [] + self.PcdError = [] + + ## + # AsBuilt will use FromXml + # + def FromXml(self, Item, Key): + self.PcdItemType = \ + XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdItemType') + self.PcdUsage = XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdUsage') + self.TokenSpaceGuidCName = \ + XmlElement(Item, '%s/TokenSpaceGuidCname' % Key) + self.TokenSpaceGuidValue = \ + XmlElement(Item, '%s/TokenSpaceGuidValue' % Key) + self.Token = XmlElement(Item, '%s/Token' % Key) + self.CName = XmlElement(Item, '%s/CName' % Key) + self.PcdCName = XmlElement(Item, '%s/PcdCName' % Key) + self.DatumType = XmlElement(Item, '%s/DatumType' % Key) + self.ValidUsage = XmlElement(Item, '%s/ValidUsage' % Key) + if not GlobalData.gIS_BINARY_INF: + self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key) + else: + self.DefaultValue = XmlElement(Item, '%s/Value' % Key) + self.MaxDatumSize = XmlElement(Item, '%s/MaxDatumSize' % Key) + self.Value = XmlElement(Item, '%s/Value' % Key) + self.Offset = XmlElement(Item, '%s/Offset' % 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) + for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key): + PcdErrorObjXml = PcdErrorXml() + PcdErrorObj = PcdErrorObjXml.FromXml(PcdErrorItem, 'PcdError') + self.PcdError.append(PcdErrorObj) + + self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue) + + PcdEntry = PcdObject() + PcdEntry.SetSupArchList(self.CommonDefines.SupArchList) + PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName) + PcdEntry.SetTokenSpaceGuidValue(self.TokenSpaceGuidValue) + PcdEntry.SetToken(self.Token) + PcdEntry.SetOffset(self.Offset) + PcdEntry.SetCName(self.CName) + PcdEntry.SetPcdCName(self.PcdCName) + PcdEntry.SetDatumType(self.DatumType) + PcdEntry.SetValidUsage(self.ValidUsage) + PcdEntry.SetDefaultValue(self.DefaultValue) + PcdEntry.SetMaxDatumSize(self.MaxDatumSize) + PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)) + PcdEntry.SetItemType(self.PcdItemType) + + PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText)) + PcdEntry.SetPcdErrorsList(self.PcdError) + + return PcdEntry + ## + # Package will use FromXml2 + # + def FromXml2(self, Item, Key): + self.TokenSpaceGuidCName = \ + XmlElement(Item, '%s/TokenSpaceGuidCname' % Key) + self.Token = XmlElement(Item, '%s/Token' % Key) + self.CName = XmlElement(Item, '%s/CName' % Key) + self.DatumType = XmlElement(Item, '%s/DatumType' % Key) + self.ValidUsage = XmlElement(Item, '%s/ValidUsage' % Key) + self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key) + self.MaxDatumSize = XmlElement(Item, '%s/MaxDatumSize' % Key) + self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key) + for PromptItem in XmlList(Item, '%s/Prompt' % Key): + PromptObj = PromptXml() + PromptObj.FromXml(PromptItem, '%s/Prompt' % Key) + self.Prompt.append(PromptObj) + for HelpTextItem in XmlList(Item, '%s/HelpText' % Key): + HelpTextObj = HelpTextXml() + HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key) + self.HelpText.append(HelpTextObj) + for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key): + PcdErrorObjXml = PcdErrorXml() + PcdErrorObj = PcdErrorObjXml.FromXml(PcdErrorItem, 'PcdError') + self.PcdError.append(PcdErrorObj) + + self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue) + + PcdEntry = PcdObject() + PcdEntry.SetSupArchList(self.CommonDefines.SupArchList) + PcdEntry.SetSupModuleList(self.CommonDefines.SupModList) + PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName) + PcdEntry.SetToken(self.Token) + PcdEntry.SetCName(self.CName) + PcdEntry.SetDatumType(self.DatumType) + PcdEntry.SetValidUsage(self.ValidUsage) + PcdEntry.SetDefaultValue(self.DefaultValue) + PcdEntry.SetMaxDatumSize(self.MaxDatumSize) + PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)) + + PcdEntry.SetPromptList(GetPromptList(self.Prompt)) + PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText)) + PcdEntry.SetPcdErrorsList(self.PcdError) + + return PcdEntry + + ## + # Module will use FromXml3 + # + def FromXml3(self, Item, Key): + self.PcdItemType = \ + XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdItemType') + self.PcdUsage = XmlAttribute(XmlNode(Item, '%s' % Key), 'PcdUsage') + self.TokenSpaceGuidCName = \ + XmlElement(Item, '%s/TokenSpaceGuidCName' % Key) + self.CName = XmlElement(Item, '%s/CName' % Key) + self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % 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) + for PcdErrorItem in XmlList(Item, '%s/PcdError' % Key): + PcdErrorObj = PcdErrorXml() + PcdErrorObj.FromXml(PcdErrorItem, 'PcdError') + self.PcdError.append(PcdErrorObj) + + self.DefaultValue = ConvertNOTEQToNE(self.DefaultValue) + + PcdEntry = PcdObject() + PcdEntry.SetSupArchList(self.CommonDefines.SupArchList) + PcdEntry.SetTokenSpaceGuidCName(self.TokenSpaceGuidCName) + PcdEntry.SetCName(self.CName) + PcdEntry.SetValidUsage(self.PcdUsage) + PcdEntry.SetDefaultValue(self.DefaultValue) + PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)) + PcdEntry.SetItemType(self.PcdItemType) + + PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText)) + PcdEntry.SetPcdErrorsList(self.PcdError) + + return PcdEntry + + def ToXml(self, PcdEntry, Key): + if self.PcdCName: + pass + + DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue()) + + AttributeList = \ + [['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \ + ['PcdUsage', PcdEntry.GetValidUsage()], \ + ['PcdItemType', PcdEntry.GetItemType()], \ + ['FeatureFlag', PcdEntry.GetFeatureFlag()], + ] + NodeList = [['TokenSpaceGuidCname', PcdEntry.GetTokenSpaceGuidCName()], + ['TokenSpaceGuidValue', PcdEntry.GetTokenSpaceGuidValue()], + ['Token', PcdEntry.GetToken()], + ['CName', PcdEntry.GetCName()], + ['DatumType', PcdEntry.GetDatumType()], + ['ValidUsage', GetStringOfList(PcdEntry.GetValidUsage())], + ['DefaultValue', DefaultValue], + ['MaxDatumSize', PcdEntry.GetMaxDatumSize()], + ['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 + ## + # Package will use ToXml2 + # + def ToXml2(self, PcdEntry, Key): + if self.PcdCName: + pass + + DefaultValue = ConvertNEToNOTEQ(PcdEntry.GetDefaultValue()) + + AttributeList = \ + [['SupArchList', GetStringOfList(PcdEntry.GetSupArchList())], \ + ['SupModList', GetStringOfList(PcdEntry.GetSupModuleList())] + ] + NodeList = [['TokenSpaceGuidCname', PcdEntry.GetTokenSpaceGuidCName()], + ['Token', PcdEntry.GetToken()], + ['CName', PcdEntry.GetCName()], + ['DatumType', PcdEntry.GetDatumType()], + ['ValidUsage', GetStringOfList(PcdEntry.GetValidUsage())], + ['DefaultValue', DefaultValue], + ['MaxDatumSize', PcdEntry.GetMaxDatumSize()], + ] + for Item in PcdEntry.GetPromptList(): + Tmp = PromptXml() + NodeList.append(Tmp.ToXml(Item)) + + 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 + ## + # Module will use ToXml3 + # + 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 + + ## + # AsBuild Module will use ToXml4 + # + 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 __str__(self): + Str = \ + ('PcdItemType = %s PcdUsage = %s TokenSpaceGuidCName = %s \ + TokenSpaceGuidValue = %s Token = %s CName = %s PcdCName = %s \ + DatumType = %s ValidUsage = %s DefaultValue = %s MaxDatumSize = %s \ + Value = %s Offset = %s %s') % \ + (self.PcdItemType, self.PcdUsage, self.TokenSpaceGuidCName, \ + self.TokenSpaceGuidValue, self.Token, self.CName, self.PcdCName, \ + self.DatumType, self.ValidUsage, self.DefaultValue, \ + self.MaxDatumSize, self.Value, self.Offset, self.CommonDefines) + for Item in self.HelpText: + Str = Str + "\n\t" + str(Item) + for Item in self.PcdError: + Str = Str + "\n\tPcdError:" + str(Item) + return Str diff --git a/roms/edk2/BaseTools/Source/Python/UPT/Xml/XmlParser.py b/roms/edk2/BaseTools/Source/Python/UPT/Xml/XmlParser.py new file mode 100644 index 000000000..8e22a280f --- /dev/null +++ b/roms/edk2/BaseTools/Source/Python/UPT/Xml/XmlParser.py @@ -0,0 +1,926 @@ +## @file +# This file is used to parse a xml file of .PKG file +# +# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.
+# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# + +''' +XmlParser +''' + +## +# Import Modules +# +import re + +from Library.Xml.XmlRoutines import XmlNode +from Library.Xml.XmlRoutines import CreateXmlElement +from Library.Xml.XmlRoutines import XmlList +from Library.Xml.XmlRoutines import XmlParseFile +from Core.DistributionPackageClass import DistributionPackageClass +from Object.POM.ModuleObject import DepexObject +from Library.ParserValidate import IsValidInfMoudleType +from Library.ParserValidate import IsValidInstallPath +from Library.Misc import IsEqualList +from Library.Misc import Sdict + +from Logger.StringTable import ERR_XML_INVALID_VARIABLENAME +from Logger.StringTable import ERR_XML_INVALID_LIB_SUPMODLIST +from Logger.StringTable import ERR_XML_INVALID_EXTERN_SUPARCHLIST +from Logger.StringTable import ERR_XML_INVALID_EXTERN_SUPMODLIST +from Logger.StringTable import ERR_XML_INVALID_EXTERN_SUPMODLIST_NOT_LIB +from Logger.StringTable import ERR_FILE_NAME_INVALIDE +from Logger.ToolError import PARSER_ERROR +from Logger.ToolError import FORMAT_INVALID + +from Xml.CommonXml import DistributionPackageHeaderXml +from Xml.CommonXml import MiscellaneousFileXml +from Xml.CommonXml import UserExtensionsXml +from Xml.XmlParserMisc import ConvertVariableName +from Xml.XmlParserMisc import IsRequiredItemListNull +from Xml.ModuleSurfaceAreaXml import ModuleSurfaceAreaXml +from Xml.PackageSurfaceAreaXml import PackageSurfaceAreaXml + +import Logger.Log as Logger + +## +# DistributionPackageXml +# +class DistributionPackageXml(object): + def __init__(self): + self.DistP = DistributionPackageClass() + self.Pkg = '' + + ## ValidateDistributionPackage + # + # Check if any required item is missing in DistributionPackage + # + def ValidateDistributionPackage(self): + XmlTreeLevel = ['DistributionPackage'] + if self.DistP: + # + # Check DistributionPackage -> DistributionHeader + # + XmlTreeLevel = ['DistributionPackage', ''] + CheckDict = {'DistributionHeader':self.DistP.Header } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + if self.DistP.Header: + DpHeader = self.DistP.Header + XmlTreeLevel = ['DistributionPackage', 'DistributionHeader'] + CheckDict = Sdict() + if DpHeader.GetAbstract(): + DPAbstract = DpHeader.GetAbstract()[0][1] + else: + DPAbstract = '' + if DpHeader.GetCopyright(): + DPCopyright = DpHeader.GetCopyright()[0][1] + else: + DPCopyright = '' + if DpHeader.GetLicense(): + DPLicense = DpHeader.GetLicense()[0][1] + else: + DPLicense = '' + + CheckDict['Name'] = DpHeader.GetName() + CheckDict['GUID'] = DpHeader.GetGuid() + CheckDict['Version'] = DpHeader.GetVersion() + CheckDict['Copyright'] = DPCopyright + CheckDict['License'] = DPLicense + CheckDict['Abstract'] = DPAbstract + CheckDict['Vendor'] = DpHeader.GetVendor() + CheckDict['Date'] = DpHeader.GetDate() + CheckDict['XmlSpecification'] = DpHeader.GetXmlSpecification() + + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + else: + XmlTreeLevel = ['DistributionPackage', 'DistributionHeader'] + CheckDict = CheckDict = {'DistributionHeader': '', } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check Each Package + # + for Key in self.DistP.PackageSurfaceArea: + ValidatePackageSurfaceArea(self.DistP.PackageSurfaceArea[Key]) + + # + # Check Each Module + # + for Key in self.DistP.ModuleSurfaceArea: + ValidateMS(self.DistP.ModuleSurfaceArea[Key], ['DistributionPackage', 'ModuleSurfaceArea']) + + # + # Check Each Tool + # + if self.DistP.Tools: + XmlTreeLevel = ['DistributionPackage', 'Tools', 'Header'] + CheckDict = {'Name': self.DistP.Tools.GetName(), } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + if not self.DistP.Tools.GetFileList(): + XmlTreeLevel = ['DistributionPackage', 'Tools'] + CheckDict = {'FileName': None, } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + for Item in self.DistP.Tools.GetFileList(): + XmlTreeLevel = ['DistributionPackage', 'Tools'] + CheckDict = {'FileName': Item.GetURI(), } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check Each Misc File + # + if self.DistP.MiscellaneousFiles: + XmlTreeLevel = ['DistributionPackage', 'MiscellaneousFiles', 'Header'] + CheckDict = {'Name': self.DistP.MiscellaneousFiles.GetName(), } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + if not self.DistP.MiscellaneousFiles.GetFileList(): + XmlTreeLevel = ['DistributionPackage', 'MiscellaneousFiles'] + CheckDict = {'FileName': None, } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + for Item in self.DistP.MiscellaneousFiles.GetFileList(): + XmlTreeLevel = ['DistributionPackage', 'MiscellaneousFiles'] + CheckDict = {'FileName': Item.GetURI(), } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check Each Distribution Level User Extension + # + for Item in self.DistP.UserExtensions: + XmlTreeLevel = ['DistributionPackage', 'UserExtensions'] + CheckDict = {'UserId': Item.GetUserID(), } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + + def FromXml(self, Filename=None): + if Filename is not None: + self.DistP = DistributionPackageClass() + # + # Load to XML + # + self.Pkg = XmlParseFile(Filename) + + # + # Parse Header information + # + Tmp = DistributionPackageHeaderXml() + DistributionPackageHeader = \ + Tmp.FromXml(XmlNode(self.Pkg, '/DistributionPackage/DistributionHeader'), 'DistributionHeader') + self.DistP.Header = DistributionPackageHeader + # + # Parse each PackageSurfaceArea + # + for Item in XmlList(self.Pkg, '/DistributionPackage/PackageSurfaceArea'): + Psa = PackageSurfaceAreaXml() + Package = Psa.FromXml(Item, 'PackageSurfaceArea') + self.DistP.PackageSurfaceArea[(Package.GetGuid(), \ + Package.GetVersion(), \ + Package.GetPackagePath())] = \ + Package + # + # Parse each ModuleSurfaceArea + # + for Item in XmlList(self.Pkg, '/DistributionPackage/ModuleSurfaceArea'): + Msa = ModuleSurfaceAreaXml() + Module = Msa.FromXml(Item, 'ModuleSurfaceArea', True) + ModuleKey = (Module.GetGuid(), Module.GetVersion(), Module.GetName(), Module.GetModulePath()) + self.DistP.ModuleSurfaceArea[ModuleKey] = Module + + # + # Parse Tools + # + Tmp = MiscellaneousFileXml() + self.DistP.Tools = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/Tools'), 'Tools') + + # + # Parse MiscFiles + # + Tmp = MiscellaneousFileXml() + self.DistP.MiscellaneousFiles = \ + Tmp.FromXml2(XmlNode(self.Pkg, \ + '/DistributionPackage/MiscellaneousFiles'), \ + 'MiscellaneousFiles') + + # + # Parse UserExtensions + # + for Item in XmlList(self.Pkg, '/DistributionPackage/UserExtensions'): + Tmp = UserExtensionsXml() + self.DistP.UserExtensions.append(Tmp.FromXml2(Item, 'UserExtensions')) + + # + # Check Required Items for XML + # + self.ValidateDistributionPackage() + + return self.DistP + + def ToXml(self, DistP): + if self.DistP: + pass + if DistP is not None: + # + # Parse DistributionPackageHeader + # + Attrs = [['xmlns', 'http://www.uefi.org/2011/1.1'], + ['xmlns:xsi', 'http:/www.w3.org/2001/XMLSchema-instance'], + ] + Root = CreateXmlElement('DistributionPackage', '', [], Attrs) + + Tmp = DistributionPackageHeaderXml() + Root.appendChild(Tmp.ToXml(DistP.Header, 'DistributionHeader')) + # + # Parse each PackageSurfaceArea + # + for Package in DistP.PackageSurfaceArea.values(): + Psa = PackageSurfaceAreaXml() + DomPackage = Psa.ToXml(Package) + Root.appendChild(DomPackage) + # + # Parse each ModuleSurfaceArea + # + for Module in DistP.ModuleSurfaceArea.values(): + Msa = ModuleSurfaceAreaXml() + DomModule = Msa.ToXml(Module) + Root.appendChild(DomModule) + # + # Parse Tools + # + Tmp = MiscellaneousFileXml() + ToolNode = Tmp.ToXml2(DistP.Tools, 'Tools') + if ToolNode is not None: + Root.appendChild(ToolNode) + # + # Parse MiscFiles + # + Tmp = MiscellaneousFileXml() + MiscFileNode = Tmp.ToXml2(DistP.MiscellaneousFiles, + 'MiscellaneousFiles') + if MiscFileNode is not None: + Root.appendChild(MiscFileNode) + + XmlContent = Root.toprettyxml(indent=' ') + + + # + # Remove empty element + # + XmlContent = re.sub(r'[\s\r\n]*<[^<>=]*/>', '', XmlContent) + + # + # Remove empty help text element + # + XmlContent = re.sub(r'[\s\r\n]*', '', + XmlContent) + + # + # Remove SupArchList="COMMON" or "common" + # + XmlContent = \ + re.sub(r'[\s\r\n]*SupArchList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*COMMON' + '[\s\r\n]*"', '', XmlContent) + XmlContent = \ + re.sub(r'[\s\r\n]*SupArchList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*common' + '[\s\r\n]*"', '', XmlContent) + # + # Remove COMMON + # + XmlContent = \ + re.sub(r'[\s\r\n]*[\s\r\n]*COMMON[\s\r\n]*' + '[\s\r\n]*', '', XmlContent) + + # + # Remove common + # + XmlContent = \ + re.sub(r'[\s\r\n]*[\s\r\n]*' + 'common[\s\r\n]*[\s\r\n]*', '', XmlContent) + + # + # Remove SupModList="COMMON" or "common" + # + XmlContent = \ + re.sub(r'[\s\r\n]*SupModList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*COMMON' + '[\s\r\n]*"', '', XmlContent) + XmlContent = \ + re.sub(r'[\s\r\n]*SupModList[\s\r\n]*=[\s\r\n]*"[\s\r\n]*common' + '[\s\r\n]*"', '', XmlContent) + + return XmlContent + + return '' + +## ValidateMS +# +# Check if any required item is missing in ModuleSurfaceArea +# +# @param Module: The ModuleSurfaceArea to be checked +# @param XmlTreeLevel: The top level of Module +# +def ValidateMS(Module, TopXmlTreeLevel): + ValidateMS1(Module, TopXmlTreeLevel) + ValidateMS2(Module, TopXmlTreeLevel) + ValidateMS3(Module, TopXmlTreeLevel) + +## ValidateMS1 +# +# Check if any required item is missing in ModuleSurfaceArea +# +# @param Module: The ModuleSurfaceArea to be checked +# @param XmlTreeLevel: The top level of Module +# +def ValidateMS1(Module, TopXmlTreeLevel): + # + # Check Guids -> GuidCName + # + XmlTreeLevel = TopXmlTreeLevel + ['Guids'] + for Item in Module.GetGuidList(): + if Item is None: + CheckDict = {'GuidCName':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = TopXmlTreeLevel + ['Guids', 'GuidCName'] + for Item in Module.GetGuidList(): + CheckDict = {'CName':Item.GetCName(), + 'GuidType':Item.GetGuidTypeList(), + 'Usage':Item.GetUsage()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + if Item.GetVariableName(): + Result = ConvertVariableName(Item.GetVariableName()) + if Result is None: + Msg = "->".join(Node for Node in XmlTreeLevel) + ErrorMsg = ERR_XML_INVALID_VARIABLENAME % (Item.GetVariableName(), Item.GetCName(), Msg) + Logger.Error('\nUPT', PARSER_ERROR, ErrorMsg, RaiseError=True) + else: + Item.SetVariableName(Result) + + # + # Check Protocols -> Protocol + # + XmlTreeLevel = TopXmlTreeLevel + ['Protocols'] + for Item in Module.GetProtocolList(): + if Item is None: + CheckDict = {'Protocol':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = TopXmlTreeLevel + ['Protocols', 'Protocol'] + for Item in Module.GetProtocolList(): + CheckDict = {'CName':Item.GetCName(), + 'Usage':Item.GetUsage()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check PPIs -> Ppi + # + XmlTreeLevel = TopXmlTreeLevel + ['PPIs'] + for Item in Module.GetPpiList(): + if Item is None: + CheckDict = {'Ppi':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = TopXmlTreeLevel + ['PPIs', 'Ppi'] + for Item in Module.GetPpiList(): + CheckDict = {'CName':Item.GetCName(), + 'Usage':Item.GetUsage()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check PcdCoded -> Entry + # + XmlTreeLevel = TopXmlTreeLevel + ['PcdCoded'] + for Item in Module.GetPcdList(): + if Item is None: + CheckDict = {'PcdEntry':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = TopXmlTreeLevel + ['PcdCoded', 'PcdEntry'] + for Item in Module.GetPcdList(): + CheckDict = {'TokenSpaceGuidCname':Item.GetTokenSpaceGuidCName(), + 'CName':Item.GetCName(), + 'PcdUsage':Item.GetValidUsage(), + 'PcdItemType':Item.GetItemType()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check Externs -> Extern + # + XmlTreeLevel = TopXmlTreeLevel + ['Externs'] + for Item in Module.GetExternList(): + if Item is None: + CheckDict = {'Extern':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # If SupArchList is used to identify different EntryPoint, UnloadImage, Constructor/Destructor elements and + # that SupArchList does not match ModuleSurfaceArea.ModuleProperties:SupArchList, the tool must exit gracefully, + # informing the user that the EDK II Build system does not support different EntryPoint, UnloadImage, + # Constructor or Destructor elements based on Architecture type. Two SupArchList attributes are considered + # identical if it lists the same CPU architectures in any order. + # + for Item in Module.GetExternList(): + if len(Item.SupArchList) > 0: + if not IsEqualList(Item.SupArchList, Module.SupArchList): + Logger.Error('\nUPT', + PARSER_ERROR, + ERR_XML_INVALID_EXTERN_SUPARCHLIST % (str(Item.SupArchList), str(Module.SupArchList)), + RaiseError=True) + + # + # Check DistributionPackage -> ModuleSurfaceArea -> UserExtensions + # + XmlTreeLevel = TopXmlTreeLevel + ['UserExtensions'] + for Item in Module.GetUserExtensionList(): + CheckDict = {'UserId':Item.GetUserID(), 'Identifier':Item.GetIdentifier()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check DistributionPackage -> PackageSurfaceArea -> MiscellaneousFiles -> Filename + # + XmlTreeLevel = TopXmlTreeLevel + ['MiscellaneousFiles'] + for Item in Module.GetMiscFileList(): + if not Item.GetFileList(): + CheckDict = {'Filename': '', } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + for File in Item.GetFileList(): + CheckDict = {'Filename': File.GetURI(), } + +## ValidateMS2 +# +# Check if any required item is missing in ModuleSurfaceArea +# +# @param Module: The ModuleSurfaceArea to be checked +# @param XmlTreeLevel: The top level of Module +# +def ValidateMS2(Module, TopXmlTreeLevel): + # + # Check Header + # + XmlTreeLevel = TopXmlTreeLevel + ['Header'] + CheckDict = Sdict() + CheckDict['Name'] = Module.GetName() + CheckDict['BaseName'] = Module.GetBaseName() + CheckDict['GUID'] = Module.GetGuid() + CheckDict['Version'] = Module.GetVersion() + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check ModuleProperties + # + XmlTreeLevel = TopXmlTreeLevel + ['ModuleProperties'] + CheckDict = {'ModuleType':Module.GetModuleType(), + 'Path':Module.GetModulePath()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + if not IsValidInstallPath(Module.GetModulePath()): + Logger.Error("UPT", FORMAT_INVALID, ERR_FILE_NAME_INVALIDE % Module.GetModulePath()) + + # + # Check ModuleProperties->BootMode + # + XmlTreeLevel = TopXmlTreeLevel + ['ModuleProperties'] + ['BootMode'] + for Item in Module.GetBootModeList(): + CheckDict = {'Usage':Item.GetUsage(), + 'SupportedBootModes':Item.GetSupportedBootModes()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check ModuleProperties->Event + # + XmlTreeLevel = TopXmlTreeLevel + ['ModuleProperties'] + ['Event'] + for Item in Module.GetEventList(): + CheckDict = {'Usage':Item.GetUsage(), + 'EventType':Item.GetEventType()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check ModuleProperties->Hob + # + XmlTreeLevel = TopXmlTreeLevel + ['ModuleProperties'] + ['HOB'] + for Item in Module.GetHobList(): + CheckDict = {'Usage':Item.GetUsage(), + 'HobType':Item.GetHobType()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # The UDP Specification supports the module type of UEFI_RUNTIME_DRIVER, which is not present in the EDK II INF + # File Specification v. 1.23, so UPT must perform the following translation that include the generation of a + # [Depex] section. + # + if Module.ModuleType == "UEFI_RUNTIME_DRIVER": + Module.ModuleType = "DXE_RUNTIME_DRIVER" + DxeObj = DepexObject() + DxeObj.SetDepex("gEfiBdsArchProtocolGuid AND \ngEfiCpuArchProtocolGuid AND\n" + \ + "gEfiMetronomeArchProtocolGuid AND \ngEfiMonotonicCounterArchProtocolGuid AND\n" + \ + "gEfiRealTimeClockArchProtocolGuid AND \ngEfiResetArchProtocolGuid AND\n" + \ + "gEfiRuntimeArchProtocolGuid AND \ngEfiSecurityArchProtocolGuid AND\n" + \ + "gEfiTimerArchProtocolGuid AND \ngEfiVariableWriteArchProtocolGuid AND\n" + \ + "gEfiVariableArchProtocolGuid AND \ngEfiWatchdogTimerArchProtocolGuid") + DxeObj.SetModuleType(['DXE_RUNTIME_DRIVER']) + Module.PeiDepex = [] + Module.DxeDepex = [] + Module.SmmDepex = [] + Module.DxeDepex.append(DxeObj) + + # + # Check LibraryClassDefinitions -> LibraryClass + # + XmlTreeLevel = TopXmlTreeLevel + ['LibraryClassDefinitions'] + for Item in Module.GetLibraryClassList(): + if Item is None: + CheckDict = {'LibraryClass':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = TopXmlTreeLevel + ['LibraryClassDefinitions', 'LibraryClass'] + + IsLibraryModule = False + LibrarySupModList = [] + for Item in Module.GetLibraryClassList(): + CheckDict = {'Keyword':Item.GetLibraryClass(), + 'Usage':Item.GetUsage()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + # + # If the LibraryClass:SupModList is not "UNDEFINED" the LIBRARY_CLASS entry must have the list + # appended using the format: + # LIBRARY_CLASS = ["|" ] + # + # Edk2ModuleTypeList ::= [" " ]{0,} + # ::= {"BASE"} {"SEC"} {"PEI_CORE"} {"PEIM"} + # {"DXE_CORE"} {"DXE_DRIVER"} {"SMM_CORE"} + # {"DXE_SMM_DRIVER"} {"DXE_RUNTIME_DRIVER"} + # {"DXE_SAL_DRIVER"} {"UEFI_DRIVER"} + # {"UEFI_APPLICATION"} {"USER_DEFINED"} + # + if len(Item.SupModuleList) > 0: + for SupModule in Item.SupModuleList: + if not IsValidInfMoudleType(SupModule): + Logger.Error('\nUPT', + PARSER_ERROR, + ERR_XML_INVALID_LIB_SUPMODLIST % (Item.LibraryClass, str(SupModule)), + RaiseError=True) + + if Item.Usage == 'PRODUCES' or Item.Usage == 'SOMETIMES_PRODUCES': + IsLibraryModule = True + LibrarySupModList = Item.SupModuleList + + + # + # For Library modules (indicated by a LIBRARY_CLASS statement in the [Defines] section) + # If the SupModList attribute of the CONSTRUCTOR or DESTRUCTOR element does not match the Supported Module + # Types listed after "LIBRARY_CLASS = |", the tool should gracefully exit with an error message + # stating that there is a conflict in the module types the CONSTRUCTOR/DESTRUCTOR is to be used with and + # the Module types this Library supports. + # + if IsLibraryModule: + for Item in Module.GetExternList(): + if Item.Constructor or Item.Destructor: + if hasattr(Item, 'SupModList') and len(Item.SupModList) > 0 and \ + not IsEqualList(Item.SupModList, LibrarySupModList): + Logger.Error('\nUPT', + PARSER_ERROR, + ERR_XML_INVALID_EXTERN_SUPMODLIST % (str(Item.SupModList), str(LibrarySupModList)), + RaiseError=True) + + # + # If the module is not a library module, the MODULE_TYPE listed in the ModuleSurfaceArea.Header must match the + # SupModList attribute. If these conditions cannot be met, the tool must exit gracefully, informing the user + # that the EDK II Build system does not currently support the features required by this Module. + # + if not IsLibraryModule: + for Item in Module.GetExternList(): + if hasattr(Item, 'SupModList') and len(Item.SupModList) > 0 and \ + not IsEqualList(Item.SupModList, [Module.ModuleType]): + Logger.Error('\nUPT', + PARSER_ERROR, + ERR_XML_INVALID_EXTERN_SUPMODLIST_NOT_LIB % (str(Module.ModuleType), str(Item.SupModList)), + RaiseError=True) + # + # Check SourceFiles + # + XmlTreeLevel = TopXmlTreeLevel + ['SourceFiles'] + for Item in Module.GetSourceFileList(): + if Item is None: + CheckDict = {'Filename':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = TopXmlTreeLevel + ['SourceFiles'] + for Item in Module.GetSourceFileList(): + CheckDict = {'Filename':Item.GetSourceFile()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + for ItemCount in range(len(Module.GetBinaryFileList())): + Item = Module.GetBinaryFileList()[ItemCount] + if Item and len(Item.FileNamList) > 0 and Item.FileNamList[0].FileType == 'FREEFORM': + Item.FileNamList[0].FileType = 'SUBTYPE_GUID' + Module.GetBinaryFileList()[ItemCount] = Item + +## ValidateMS3 +# +# Check if any required item is missing in ModuleSurfaceArea +# +# @param Module: The ModuleSurfaceArea to be checked +# @param XmlTreeLevel: The top level of Module +# +def ValidateMS3(Module, TopXmlTreeLevel): + # + # Check PackageDependencies -> Package + # + XmlTreeLevel = TopXmlTreeLevel + ['PackageDependencies'] + for Item in Module.GetPackageDependencyList(): + if Item is None: + CheckDict = {'Package':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = TopXmlTreeLevel + ['PackageDependencies', 'Package'] + for Item in Module.GetPackageDependencyList(): + CheckDict = {'GUID':Item.GetGuid()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check BinaryFiles -> BinaryFile + # + for Item in Module.GetBinaryFileList(): + if Item is None: + XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles'] + CheckDict = {'BinaryFile':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + if not Item.GetFileNameList(): + XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile'] + CheckDict = {'Filename':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile'] + for File in Item.GetFileNameList(): + CheckDict = {'Filename':File.GetFilename(), + 'FileType':File.GetFileType()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + for AsBuilt in Item.GetAsBuiltList(): + # + # Check LibInstance + # + if len(AsBuilt.LibraryInstancesList) == 1 and not AsBuilt.LibraryInstancesList[0]: + CheckDict = {'GUID':''} + XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt', 'LibraryInstances'] + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + for LibItem in AsBuilt.LibraryInstancesList: + CheckDict = {'Guid':LibItem.Guid, + 'Version':LibItem.Version} + XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt', 'LibraryInstances'] + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check PatchPcd + # + for PatchPcdItem in AsBuilt.PatchPcdList: + CheckDict = {'TokenSpaceGuidValue':PatchPcdItem.TokenSpaceGuidValue, + 'PcdCName':PatchPcdItem.PcdCName, + 'Token':PatchPcdItem.Token, + 'DatumType':PatchPcdItem.DatumType, + 'Value':PatchPcdItem.DefaultValue, + 'Offset':PatchPcdItem.Offset} + XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt', 'PatchPcdValue'] + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + # + # Check PcdError + # + for PcdErrorItem in PatchPcdItem.PcdErrorsList: + CheckDict = {'ErrorNumber':PcdErrorItem.ErrorNumber} + XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt', + 'PatchPcdValue', 'PcdError'] + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + # + # Check PcdEx + # + for PcdExItem in AsBuilt.PcdExValueList: + CheckDict = {'TokenSpaceGuidValue':PcdExItem.TokenSpaceGuidValue, + 'Token':PcdExItem.Token, + 'DatumType':PcdExItem.DatumType} + XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt', 'PcdExValue'] + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + # + # Check PcdError + # + for PcdErrorItem in PcdExItem.PcdErrorsList: + CheckDict = {'ErrorNumber':PcdErrorItem.ErrorNumber} + XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt', + 'PcdExValue', 'PcdError'] + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + # + # Check SmmDepex + # + XmlTreeLevel = TopXmlTreeLevel + ['SmmDepex'] + for Item in Module.GetSmmDepex(): + CheckDict = {'Expression':Item.GetDepex()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check PeiDepex + # + XmlTreeLevel = TopXmlTreeLevel + ['PeiDepex'] + for Item in Module.GetPeiDepex(): + CheckDict = {'Expression':Item.GetDepex()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check DxeDepex + # + XmlTreeLevel = TopXmlTreeLevel + ['DxeDepex'] + for Item in Module.GetDxeDepex(): + CheckDict = {'Expression':Item.GetDepex()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check + # + XmlTreeLevel = TopXmlTreeLevel + ['UserExtensions'] + for Item in Module.GetUserExtensionList(): + CheckDict = {'UserId':Item.GetUserID(), 'Identifier':Item.GetIdentifier()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + +## ValidatePS1 +# +# ValidatePS1 +# +def ValidatePS1(Package): + # + # Check DistributionPackage -> PackageSurfaceArea -> Header + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'Header'] + CheckDict = Sdict() + CheckDict['Name'] = Package.GetName() + CheckDict['BaseName'] = Package.GetBaseName() + CheckDict['GUID'] = Package.GetGuid() + CheckDict['Version'] = Package.GetVersion() + CheckDict['PackagePath'] = Package.GetPackagePath() + + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + if not IsValidInstallPath(Package.GetPackagePath()): + Logger.Error("UPT", FORMAT_INVALID, ERR_FILE_NAME_INVALIDE % Package.GetPackagePath()) + + # + # Check DistributionPackage -> PackageSurfaceArea -> ClonedFrom + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'ClonedFrom'] + for Item in Package.GetClonedFromList(): + if Item is None: + CheckDict = Sdict() + CheckDict['GUID'] = '' + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + CheckDict = Sdict() + CheckDict['GUID'] = Item.GetPackageGuid() + CheckDict['Version'] = Item.GetPackageVersion() + + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check DistributionPackage -> PackageSurfaceArea -> LibraryClassDeclarations -> LibraryClass + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'LibraryClassDeclarations'] + for Item in Package.GetLibraryClassList(): + if Item is None: + CheckDict = {'LibraryClass':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'LibraryClassDeclarations', 'LibraryClass'] + for Item in Package.GetLibraryClassList(): + CheckDict = {'Keyword':Item.GetLibraryClass(), + 'HeaderFile':Item.GetIncludeHeader()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check DistributionPackage -> PackageSurfaceArea -> IndustryStandardIncludes -> IndustryStandardHeader + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'IndustryStandardIncludes'] + for Item in Package.GetStandardIncludeFileList(): + if Item is None: + CheckDict = {'IndustryStandardHeader':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'IndustryStandardIncludes', 'IndustryStandardHeader'] + for Item in Package.GetStandardIncludeFileList(): + CheckDict = {'HeaderFile':Item.GetFilePath()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check DistributionPackage -> PackageSurfaceArea -> PackageIncludes -> PackageHeader + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PackageIncludes'] + for Item in Package.GetPackageIncludeFileList(): + if Item is None: + CheckDict = {'PackageHeader':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PackageIncludes', 'PackageHeader'] + for Item in Package.GetPackageIncludeFileList(): + CheckDict = {'HeaderFile':Item.GetFilePath()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + +## ValidatePS2 +# +# ValidatePS2 +# +def ValidatePS2(Package): + # + # Check DistributionPackage -> PackageSurfaceArea -> Modules -> ModuleSurfaceArea + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'Modules', 'ModuleSurfaceArea'] + for Item in Package.GetModuleDict().values(): + ValidateMS(Item, XmlTreeLevel) + + # + # Check DistributionPackage -> PackageSurfaceArea -> GuidDeclarations Entry + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'GuidDeclarations'] + for Item in Package.GetGuidList(): + if Item is None: + CheckDict = {'Entry':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'GuidDeclarations', 'Entry'] + for Item in Package.GetGuidList(): + CheckDict = {'CName':Item.GetCName(), + 'GuidValue':Item.GetGuid()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check DistributionPackage -> PackageSurfaceArea -> ProtocolDeclarations -> Entry + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'ProtocolDeclarations'] + for Item in Package.GetProtocolList(): + if Item is None: + CheckDict = {'Entry':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'ProtocolDeclarations', 'Entry'] + for Item in Package.GetProtocolList(): + CheckDict = {'CName':Item.GetCName(), + 'GuidValue':Item.GetGuid()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check DistributionPackage -> PackageSurfaceArea -> PpiDeclarations -> Entry + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PpiDeclarations'] + for Item in Package.GetPpiList(): + if Item is None: + CheckDict = {'Entry':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PpiDeclarations', 'Entry'] + for Item in Package.GetPpiList(): + CheckDict = {'CName':Item.GetCName(), + 'GuidValue':Item.GetGuid()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check DistributionPackage -> PackageSurfaceArea -> PcdDeclarations -> Entry + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PcdDeclarations'] + for Item in Package.GetPcdList(): + if Item is None: + CheckDict = {'PcdEntry':''} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'PcdDeclarations', 'PcdEntry'] + for Item in Package.GetPcdList(): + CheckDict = {'TokenSpaceGuidCname':Item.GetTokenSpaceGuidCName(), + 'Token':Item.GetToken(), + 'CName':Item.GetCName(), + 'DatumType':Item.GetDatumType(), + 'ValidUsage':Item.GetValidUsage(), + 'DefaultValue':Item.GetDefaultValue()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check DistributionPackage -> PackageSurfaceArea -> UserExtensions + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'UserExtensions'] + for Item in Package.GetUserExtensionList(): + CheckDict = {'UserId':Item.GetUserID(), 'Identifier':Item.GetIdentifier()} + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + + # + # Check DistributionPackage -> PackageSurfaceArea -> MiscellaneousFiles -> Filename + # + XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'MiscellaneousFiles'] + for Item in Package.GetMiscFileList(): + if not Item.GetFileList(): + CheckDict = {'Filename': '', } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + for File in Item.GetFileList(): + CheckDict = {'Filename': File.GetURI(), } + IsRequiredItemListNull(CheckDict, XmlTreeLevel) + +## ValidatePackageSurfaceArea +# +# Check if any required item is missing in PackageSurfaceArea +# +# @param Package: The PackageSurfaceArea to be checked +# +def ValidatePackageSurfaceArea(Package): + ValidatePS1(Package) + ValidatePS2(Package) diff --git a/roms/edk2/BaseTools/Source/Python/UPT/Xml/XmlParserMisc.py b/roms/edk2/BaseTools/Source/Python/UPT/Xml/XmlParserMisc.py new file mode 100644 index 000000000..48381ee8c --- /dev/null +++ b/roms/edk2/BaseTools/Source/Python/UPT/Xml/XmlParserMisc.py @@ -0,0 +1,95 @@ +## @file +# This file is used to parse a xml file of .PKG file +# +# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.
+# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# + +''' +XmlParserMisc +''' +from Object.POM.CommonObject import TextObject +from Logger.StringTable import ERR_XML_PARSER_REQUIRED_ITEM_MISSING +from Logger.ToolError import PARSER_ERROR +import Logger.Log as Logger + +## ConvertVariableName() +# Convert VariableName to be L"string", +# input of UCS-2 format Hex Array or L"string" (C style.) could be converted successfully, +# others will not. +# +# @param VariableName: string need to be converted +# @retval: the L quoted string converted if success, else None will be returned +# +def ConvertVariableName(VariableName): + VariableName = VariableName.strip() + # + # check for L quoted string + # + if VariableName.startswith('L"') and VariableName.endswith('"'): + return VariableName + + # + # check for Hex Array, it should be little endian even number of hex numbers + # + ValueList = VariableName.split(' ') + if len(ValueList)%2 == 1: + return None + + TransferedStr = '' + + Index = 0 + + while Index < len(ValueList): + FirstByte = int(ValueList[Index], 16) + SecondByte = int(ValueList[Index + 1], 16) + if SecondByte != 0: + return None + + if FirstByte not in range(0x20, 0x7F): + return None + TransferedStr += ('%c')%FirstByte + Index = Index + 2 + + return 'L"' + TransferedStr + '"' + +## IsRequiredItemListNull +# +# Check if a required XML section item/attribue is NULL +# +# @param ItemList: The list of items to be checked +# @param XmlTreeLevel: The error message tree level +# +def IsRequiredItemListNull(ItemDict, XmlTreeLevel): + for Key in ItemDict: + if not ItemDict[Key]: + Msg = "->".join(Node for Node in XmlTreeLevel) + ErrorMsg = ERR_XML_PARSER_REQUIRED_ITEM_MISSING % (Key, Msg) + Logger.Error('\nUPT', PARSER_ERROR, ErrorMsg, RaiseError=True) + +## Get help text +# +# @param HelpText +# +def GetHelpTextList(HelpText): + HelpTextList = [] + for HelT in HelpText: + HelpTextObj = TextObject() + HelpTextObj.SetLang(HelT.Lang) + HelpTextObj.SetString(HelT.HelpText) + HelpTextList.append(HelpTextObj) + return HelpTextList + +## Get Prompt text +# +# @param Prompt +# +def GetPromptList(Prompt): + PromptList = [] + for SubPrompt in Prompt: + PromptObj = TextObject() + PromptObj.SetLang(SubPrompt.Lang) + PromptObj.SetString(SubPrompt.Prompt) + PromptList.append(PromptObj) + return PromptList diff --git a/roms/edk2/BaseTools/Source/Python/UPT/Xml/__init__.py b/roms/edk2/BaseTools/Source/Python/UPT/Xml/__init__.py new file mode 100644 index 000000000..172e49845 --- /dev/null +++ b/roms/edk2/BaseTools/Source/Python/UPT/Xml/__init__.py @@ -0,0 +1,14 @@ +## @file +# Python 'Library' package initialization file. +# +# This file is required to make Python interpreter treat the directory +# as containing package. +# +# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.
+# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# + +''' +Xml +''' -- cgit