| ## @file | |
| # This file is used to parse a xml file of .PKG file | |
| # | |
| # Copyright (c) 2008, Intel Corporation | |
| # All rights reserved. This program and the accompanying materials | |
| # are licensed and made available under the terms and conditions of the BSD License | |
| # which accompanies this distribution. The full text of the license may be found at | |
| # http://opensource.org/licenses/bsd-license.php | |
| # | |
| # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
| # | |
| ## | |
| # Import Modules | |
| # | |
| from xml.dom import minidom | |
| from XmlRoutines import * | |
| from CommonDataClass.DistributionPackageClass import * | |
| from CommonDataClass.PackageClass import * | |
| from CommonDataClass.ModuleClass import * | |
| from Common.String import GetStringOfList | |
| # | |
| # Get Help Text | |
| # | |
| def GetHelpTextList(HelpText): | |
| HelpTextList = [] | |
| for HT in HelpText: | |
| HelpTextObj = HelpTextClass() | |
| HelpTextObj.Lang = HT.Lang | |
| HelpTextObj.String = HT.HelpText | |
| HelpTextList.append(HelpTextObj) | |
| return HelpTextList | |
| # HeaderXml | |
| class HeaderXml(object): | |
| def __init__(self): | |
| self.Name = '' | |
| self.BaseName = '' | |
| self.GUID = '' | |
| self.Version = '' | |
| self.Copyright = '' | |
| self.License = '' | |
| self.Abstract = '' | |
| self.Description = '' | |
| def FromXml(self, Item, Key): | |
| 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') | |
| self.Copyright = XmlElement(Item, '%s/Copyright' % Key) | |
| self.License = XmlElement(Item, '%s/License' % Key) | |
| self.Abstract = XmlElement(Item, '%s/Abstract' % Key) | |
| self.Description = XmlElement(Item, '%s/Description' % Key) | |
| ModuleHeader = ModuleHeaderClass() | |
| ModuleHeader.Name = self.Name | |
| ModuleHeader.BaseName = self.BaseName | |
| ModuleHeader.Guid = self.GUID | |
| ModuleHeader.Version = self.Version | |
| ModuleHeader.Copyright = self.Copyright | |
| ModuleHeader.License = self.License | |
| ModuleHeader.Abstract = self.Abstract | |
| ModuleHeader.Description = self.Description | |
| return ModuleHeader | |
| def ToXml(self, Header, Key): | |
| Element1 = CreateXmlElement('Name', Header.Name, [], [['BaseName', Header.BaseName]]) | |
| Element2 = CreateXmlElement('GUID', Header.Guid, [], [['Version', Header.Version]]) | |
| AttributeList = [] | |
| NodeList = [Element1, | |
| Element2, | |
| ['Abstract', Header.Abstract], | |
| ['Copyright', Header.Copyright], | |
| ['License', Header.License], | |
| ['Description', Header.Description], | |
| ] | |
| 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.Copyright, self.License, self.Abstract, self.Description) | |
| # DistributionPackageHeaderXml | |
| class DistributionPackageHeaderXml(object): | |
| def __init__(self): | |
| self.Header = HeaderXml() | |
| self.ReadOnly = False | |
| self.RePackage = True | |
| self.Vendor = '' | |
| self.Date = '' | |
| self.Signature = '' | |
| self.XmlSpecification = '' | |
| def FromXml(self, Item, Key): | |
| 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 = DistributionPackageHeaderClass() | |
| DistributionPackageHeader.ReadOnly = self.ReadOnly | |
| DistributionPackageHeader.RePackage = self.RePackage | |
| DistributionPackageHeader.Name = self.Header.Name | |
| DistributionPackageHeader.BaseName = self.Header.BaseName | |
| DistributionPackageHeader.Guid = self.Header.GUID | |
| DistributionPackageHeader.Version = self.Header.Version | |
| DistributionPackageHeader.Vendor = self.Vendor | |
| DistributionPackageHeader.Date = self.Date | |
| DistributionPackageHeader.Copyright = self.Header.Copyright | |
| DistributionPackageHeader.License = self.Header.License | |
| DistributionPackageHeader.Abstract = self.Header.Abstract | |
| DistributionPackageHeader.Description = self.Header.Description | |
| DistributionPackageHeader.Signature = self.Signature | |
| DistributionPackageHeader.XmlSpecification = self.XmlSpecification | |
| return DistributionPackageHeader | |
| def ToXml(self, DistributionPackageHeader, Key): | |
| Element1 = CreateXmlElement('Name', DistributionPackageHeader.Name, [], [['BaseName', DistributionPackageHeader.BaseName]]) | |
| Element2 = CreateXmlElement('GUID', DistributionPackageHeader.Guid, [], [['Version', DistributionPackageHeader.Version]]) | |
| AttributeList = [['ReadOnly', str(DistributionPackageHeader.ReadOnly)], ['RePackage', str(DistributionPackageHeader.RePackage)]] | |
| NodeList = [Element1, | |
| Element2, | |
| ['Vendor', DistributionPackageHeader.Vendor], | |
| ['Date', DistributionPackageHeader.Date], | |
| ['Copyright', DistributionPackageHeader.Copyright], | |
| ['License', DistributionPackageHeader.License], | |
| ['Abstract', DistributionPackageHeader.Abstract], | |
| ['Description', DistributionPackageHeader.Description], | |
| ['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): | |
| self.PackagePath = XmlElement(Item, '%s/PackagePath' % Key) | |
| self.Header.FromXml(Item, Key) | |
| PackageHeader = PackageHeaderClass() | |
| PackageHeader.Name = self.Header.Name | |
| PackageHeader.BaseName = self.Header.BaseName | |
| PackageHeader.Guid = self.Header.GUID | |
| PackageHeader.Version = self.Header.Version | |
| PackageHeader.Copyright = self.Header.Copyright | |
| PackageHeader.License = self.Header.License | |
| PackageHeader.Abstract = self.Header.Abstract | |
| PackageHeader.Description = self.Header.Description | |
| PackageHeader.CombinePath = self.PackagePath | |
| return PackageHeader | |
| def ToXml(self, PackageHeader, Key): | |
| Element1 = CreateXmlElement('Name', PackageHeader.Name, [], [['BaseName', PackageHeader.BaseName]]) | |
| Element2 = CreateXmlElement('GUID', PackageHeader.Guid, [], [['Version', PackageHeader.Version]]) | |
| AttributeList = [] | |
| NodeList = [Element1, | |
| Element2, | |
| ['Copyright', PackageHeader.Copyright], | |
| ['License', PackageHeader.License], | |
| ['Abstract', PackageHeader.Abstract], | |
| ['Description', PackageHeader.Description], | |
| ['PackagePath', PackageHeader.CombinePath], | |
| ] | |
| Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) | |
| return Root | |
| def __str__(self): | |
| return "PackagePath = %s %s" \ | |
| % (self.PackagePath, self.Header) | |
| # 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 = ClonedRecordClass() | |
| ClonedFrom.PackageGuid = self.GUID | |
| ClonedFrom.PackageVersion = self.Version | |
| return ClonedFrom | |
| def ToXml(self, ClonedFrom, Key): | |
| Root = minidom.Document() | |
| Element1 = CreateXmlElement('GUID', ClonedFrom.PackageGuid, [], [['Version', ClonedFrom.PackageVersion]]) | |
| 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): | |
| self.Usage = XmlAttribute(Item, 'Usage') | |
| self.SupArchList = XmlAttribute(Item, 'SupArchList') | |
| self.SupModList = XmlAttribute(Item, 'SupModList') | |
| self.FeatureFlag = 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) | |
| # HelpTextXml | |
| class HelpTextXml(object): | |
| def __init__(self): | |
| self.HelpText = '' | |
| self.Lang = '' | |
| def FromXml(self, Item, Key): | |
| self.HelpText = XmlElement(Item, 'HelpText') | |
| self.Lang = XmlAttribute(Item, 'Lang') | |
| def ToXml(self, HelpText, Key = 'HelpText'): | |
| return CreateXmlElement('%s' % Key, HelpText.String, [], [['Lang', HelpText.Lang]]) | |
| def __str__(self): | |
| return "HelpText = %s Lang = %s" % (self.HelpText, self.Lang) | |
| # 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.RecommendedInstanceGuid = XmlElement(Item, '%s/RecommendedInstance/GUID' % Key) | |
| self.RecommendedInstanceVersion = XmlAttribute(XmlNode(Item, '%s/RecommendedInstance/GUID' % Key), 'Version') | |
| 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 = LibraryClassClass() | |
| LibraryClass.LibraryClass = self.Keyword | |
| LibraryClass.IncludeHeader = self.HeaderFile | |
| LibraryClass.SupArchList = self.CommonDefines.SupArchList | |
| LibraryClass.SupModuleList = self.CommonDefines.SupModList | |
| LibraryClass.RecommendedInstanceGuid = self.RecommendedInstanceGuid | |
| LibraryClass.RecommendedInstanceVersion = self.RecommendedInstanceVersion | |
| LibraryClass.HelpTextList = GetHelpTextList(self.HelpText) | |
| return LibraryClass | |
| def ToXml(self, LibraryClass, Key): | |
| Element1 = CreateXmlElement('GUID', LibraryClass.RecommendedInstanceGuid, [], [['Version', LibraryClass.RecommendedInstanceVersion]]) | |
| Element2 = CreateXmlElement('RecommendedInstance', '', [Element1], []) | |
| AttributeList = [['Keyword', LibraryClass.LibraryClass], | |
| ['SupArchList', GetStringOfList(LibraryClass.SupArchList)], | |
| ['SupModList', GetStringOfList(LibraryClass.SupModuleList)] | |
| ] | |
| NodeList = [['HeaderFile', LibraryClass.IncludeHeader], | |
| Element2 | |
| ] | |
| for Item in LibraryClass.HelpTextList: | |
| 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 | |
| # 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 = IncludeClass() | |
| Include.FilePath = self.HeaderFile | |
| Include.HelpTextList = GetHelpTextList(self.HelpText) | |
| return Include | |
| def ToXml(self, IndustryStandardHeader, Key): | |
| AttributeList = [] | |
| NodeList = [['HeaderFile', IndustryStandardHeader.FilePath]] | |
| for Item in IndustryStandardHeader.HelpTextList: | |
| Tmp = HelpTextXml() | |
| NodeList.append(Tmp.ToXml(Item)) | |
| 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), Key) | |
| for HelpTextItem in XmlList(Item, '%s/HelpText' % Key): | |
| HelpTextObj = HelpTextXml() | |
| HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key) | |
| self.HelpText.append(HelpTextObj) | |
| Include = IncludeClass() | |
| Include.FilePath = self.HeaderFile | |
| Include.SupArchList = self.CommonDefines.SupArchList | |
| Include.SupModuleList = self.CommonDefines.SupModList | |
| Include.HelpTextList = GetHelpTextList(self.HelpText) | |
| return Include | |
| def ToXml(self, PackageIncludeHeader, Key): | |
| AttributeList = [['SupArchList', PackageIncludeHeader.SupArchList], | |
| ['SupModList', PackageIncludeHeader.SupModuleList] | |
| ] | |
| NodeList = [['HeaderFile', PackageIncludeHeader.FilePath]] | |
| for Item in PackageIncludeHeader.HelpTextList: | |
| Tmp = HelpTextXml() | |
| NodeList.append(Tmp.ToXml(Item)) | |
| Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) | |
| 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 | |
| #GUID/Protocol/Ppi | |
| class GuidProtocolPpiXml(object): | |
| def __init__(self): | |
| self.UiName = '' | |
| self.GuidTypes = '' | |
| self.Notify = '' | |
| self.CName = '' | |
| self.GuidValue = '' | |
| self.CommonDefines = CommonDefinesXml() | |
| self.HelpText = [] | |
| def FromXml(self, Item, Key): | |
| self.UiName = XmlAttribute(XmlNode(Item, '%s' % Key), 'UiName') | |
| self.GuidTypes = XmlAttribute(XmlNode(Item, '%s' % Key), 'GuidTypes') | |
| 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) | |
| GuidProtocolPpi = GuidProtocolPpiCommonClass() | |
| GuidProtocolPpi.Name = self.UiName | |
| GuidProtocolPpi.CName = self.CName | |
| GuidProtocolPpi.Guid = self.GuidValue | |
| GuidProtocolPpi.VariableName = self.VariableName | |
| GuidProtocolPpi.Notify = self.Notify | |
| GuidProtocolPpi.Usage = self.CommonDefines.Usage | |
| GuidProtocolPpi.FeatureFlag = self.CommonDefines.FeatureFlag | |
| GuidProtocolPpi.SupArchList = self.CommonDefines.SupArchList | |
| GuidProtocolPpi.SupModuleList = self.CommonDefines.SupModList | |
| GuidProtocolPpi.GuidTypeLists = self.GuidTypes | |
| GuidProtocolPpi.GuidTypeList = self.GuidType | |
| GuidProtocolPpi.HelpTextList = GetHelpTextList(self.HelpText) | |
| return GuidProtocolPpi | |
| def ToXml(self, GuidProtocolPpi, Key): | |
| AttributeList = [['Usage', GetStringOfList(GuidProtocolPpi.Usage)], | |
| ['UiName', GuidProtocolPpi.Name], | |
| ['GuidTypes', GetStringOfList(GuidProtocolPpi.GuidTypeLists)], | |
| ['GuidType', GetStringOfList(GuidProtocolPpi.GuidTypeList)], | |
| ['Notify', str(GuidProtocolPpi.Notify)], | |
| ['SupArchList', GetStringOfList(GuidProtocolPpi.SupArchList)], | |
| ['SupModList', GetStringOfList(GuidProtocolPpi.SupModuleList)], | |
| ['FeatureFlag', GuidProtocolPpi.FeatureFlag] | |
| ] | |
| NodeList = [['CName', GuidProtocolPpi.CName], | |
| ['GuidValue', GuidProtocolPpi.Guid], | |
| ['VariableName', GuidProtocolPpi.VariableName] | |
| ] | |
| for Item in GuidProtocolPpi.HelpTextList: | |
| 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 | |
| # 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 = 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 = PcdErrorClass() | |
| Error.ValidValueList = self.ValidValueList | |
| Error.ValidValueListLang = self.ValidValueListLang | |
| Error.ValidValueRange = self.ValidValueRange | |
| Error.Expression = self.Expression | |
| Error.ErrorNumber = self.ErrorNumber | |
| Error.ErrorMessage = self.ErrorMessage | |
| return Error | |
| def ToXml(self, PcdError, Key): | |
| AttributeList = [] | |
| Element1 = CreateXmlElement('ValidValueList', PcdError.ValidValueList, [], [['Lang', PcdError.ValidValueListLang]]) | |
| NodeList = [Element1, | |
| ['ValidValueRange', PcdError.ValidValueRange], | |
| ['Expression', PcdError.Expression], | |
| ['ErrorNumber', PcdError.ErrorNumber], | |
| ] | |
| for Item in PcdError.ErrorMessage: | |
| Element = CreateXmlElement('ErrorMessage', Item[1], [], [['Lang', Item[0]]]) | |
| NodeList.append(Element) | |
| Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) | |
| return Root | |
| 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.HelpText = [] | |
| self.PcdError = [] | |
| 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) | |
| self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % 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): | |
| PcdErrorObj = PcdErrorXml() | |
| PcdErrorObj.FromXml(PcdErrorItem, 'PcdError') | |
| self.PcdError.append(PcdErrorObj) | |
| PcdEntry = PcdClass() | |
| PcdEntry.SupArchList = self.CommonDefines.SupArchList | |
| PcdEntry.SupModuleList = self.CommonDefines.SupModList | |
| PcdEntry.TokenSpaceGuidCName = self.TokenSpaceGuidCName | |
| PcdEntry.TokenSpaceGuidValue = self.TokenSpaceGuidValue | |
| PcdEntry.Token = self.Token | |
| PcdEntry.CName = self.CName | |
| PcdEntry.PcdCName = self.PcdCName | |
| PcdEntry.DatumType = self.DatumType | |
| PcdEntry.ValidUsage = self.ValidUsage | |
| PcdEntry.PcdUsage = self.PcdUsage | |
| PcdEntry.Usage = self.CommonDefines.Usage | |
| PcdEntry.DefaultValue = self.DefaultValue | |
| PcdEntry.Value = self.Value | |
| PcdEntry.Offset = self.Offset | |
| PcdEntry.MaxDatumSize = self.MaxDatumSize | |
| PcdEntry.FeatureFlag = self.CommonDefines.FeatureFlag | |
| PcdEntry.PcdItemType = self.PcdItemType | |
| PcdEntry.HelpTextList = GetHelpTextList(self.HelpText) | |
| PcdEntry.PcdErrors = self.PcdError | |
| return PcdEntry | |
| def ToXml(self, PcdEntry, Key): | |
| AttributeList = [['SupArchList', GetStringOfList(PcdEntry.SupArchList)], | |
| ['PcdUsage', PcdEntry.PcdUsage], | |
| ['PcdItemType', PcdEntry.PcdItemType], | |
| ['FeatureFlag', PcdEntry.FeatureFlag], | |
| ['SupModList', GetStringOfList(PcdEntry.SupModuleList)] | |
| ] | |
| NodeList = [['TokenSpaceGuidCName', PcdEntry.TokenSpaceGuidCName], | |
| ['TokenSpaceGuidValue', PcdEntry.TokenSpaceGuidValue], | |
| ['Token', PcdEntry.Token], | |
| ['CName', PcdEntry.CName], | |
| ['PcdCName', PcdEntry.PcdCName], | |
| ['DatumType', PcdEntry.DatumType], | |
| ['ValidUsage', GetStringOfList(PcdEntry.ValidUsage)], | |
| ['DefaultValue', PcdEntry.DefaultValue], | |
| ['Value', PcdEntry.Value], | |
| ['Offset', PcdEntry.Offset], | |
| ['MaxDatumSize', PcdEntry.MaxDatumSize], | |
| ] | |
| for Item in PcdEntry.HelpTextList: | |
| Tmp = HelpTextXml() | |
| NodeList.append(Tmp.ToXml(Item, 'HelpText')) | |
| for Item in PcdEntry.PcdErrors: | |
| 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 | |
| # PcdCheckXml | |
| class PcdCheckXml(object): | |
| def __init__(self): | |
| self.PcdCheck = '' | |
| def FromXml(self, Item, Key): | |
| self.PcdCheck = XmlElement(Item, 'PcdCheck') | |
| return self.PcdCheck | |
| def ToXml(self, PcdCheck, Key): | |
| Root = CreateXmlElement('%s' % Key, PcdCheck, [], []) | |
| return Root | |
| def __str__(self): | |
| return "PcdCheck = %s" % (self.PcdCheck) | |
| # MiscellaneousFileXml | |
| class MiscellaneousFileXml(object): | |
| def __init__(self): | |
| self.Header = HeaderXml() | |
| self.Files = [] | |
| def FromXml(self, Item, Key): | |
| 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') | |
| self.Files.append([Filename, Executable]) | |
| MiscFile = MiscFileClass() | |
| MiscFile.Copyright = self.Header.Copyright | |
| MiscFile.License = self.Header.License | |
| MiscFile.Abstract = self.Header.Abstract | |
| MiscFile.Description = self.Header.Description | |
| for File in self.Files: | |
| FileObj = FileClass() | |
| FileObj.Filename = File[0] | |
| FileObj.Executable = File[1] | |
| MiscFile.Files.append(FileObj) | |
| return MiscFile | |
| def FromXml2(self, 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') | |
| self.Files.append([Filename, Executable]) | |
| MiscFile = MiscFileClass() | |
| MiscFile.Name = self.Header.Name | |
| MiscFile.Copyright = self.Header.Copyright | |
| MiscFile.License = self.Header.License | |
| MiscFile.Abstract = self.Header.Abstract | |
| MiscFile.Description = self.Header.Description | |
| for File in self.Files: | |
| FileObj = FileClass() | |
| FileObj.Filename = File[0] | |
| FileObj.Executable = File[1] | |
| MiscFile.Files.append(FileObj) | |
| return MiscFile | |
| def ToXml(self, MiscFile, Key): | |
| if MiscFile: | |
| NodeList = [['Copyright', MiscFile.Copyright], | |
| ['License', MiscFile.License], | |
| ['Abstract', MiscFile.Abstract], | |
| ['Description', MiscFile.Description], | |
| ] | |
| if MiscFile != None: | |
| for File in MiscFile.Files: | |
| NodeList.append(CreateXmlElement('Filename', File.Filename, [], [['Executable', File.Executable]])) | |
| Root = CreateXmlElement('%s' % Key, '', NodeList, []) | |
| return Root | |
| def ToXml2(self, MiscFile, Key): | |
| if MiscFile: | |
| NodeList = [['Name', MiscFile.Name], | |
| ['Copyright', MiscFile.Copyright], | |
| ['License', MiscFile.License], | |
| ['Abstract', MiscFile.Abstract], | |
| ['Description', MiscFile.Description], | |
| ] | |
| HeaderNode = CreateXmlElement('Header', '', NodeList, []) | |
| NodeList = [HeaderNode] | |
| for File in MiscFile.Files: | |
| NodeList.append(CreateXmlElement('Filename', File.Filename, [], [['Executable', File.Executable]])) | |
| 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.Defines = [] | |
| self.BuildOptions = [] | |
| def FromXml(self, Item, Key): | |
| self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId') | |
| self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier') | |
| for SubItem in XmlList(Item, '%s/Define' % Key): | |
| self.Defines.append(XmlElement(SubItem, '%s/Define' % Key)) | |
| for SubItem in XmlList(Item, '%s/BuildOption' % Key): | |
| self.BuildOptions.append(XmlElement(SubItem, '%s/BuildOption' % Key)) | |
| UserExtension = UserExtensionsClass() | |
| UserExtension.UserID = self.UserId | |
| UserExtension.Identifier = self.Identifier | |
| UserExtension.Defines = self.Defines | |
| UserExtension.BuildOptions = self.BuildOptions | |
| return UserExtension | |
| def ToXml(self, UserExtension, Key): | |
| AttributeList = [['UserId', str(UserExtension.UserID)], | |
| ['Identifier', str(UserExtension.Identifier)] | |
| ] | |
| NodeList = [] | |
| for Item in UserExtension.Defines: | |
| NodeList.append(['Define', Item]) | |
| for Item in UserExtension.BuildOptions: | |
| NodeList.append(['BuildOption', Item]) | |
| Root = CreateXmlElement('%s' % Key, UserExtension.Content, NodeList, AttributeList) | |
| 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 | |
| # 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 = ModuleBootModeClass() | |
| BootMode.Name = self.SupportedBootModes | |
| BootMode.SupArchList = self.CommonDefines.SupArchList | |
| BootMode.Usage = self.CommonDefines.Usage | |
| BootMode.FeatureFlag = self.CommonDefines.FeatureFlag | |
| BootMode.HelpTextList = GetHelpTextList(self.HelpText) | |
| return BootMode | |
| def ToXml(self, BootMode, Key): | |
| AttributeList = [['Usage', BootMode.Usage], | |
| ['SupArchList', GetStringOfList(BootMode.SupArchList)], | |
| ['FeatureFlag', BootMode.FeatureFlag], | |
| ] | |
| NodeList = [['SupportedBootModes', BootMode.Name]] | |
| for Item in BootMode.HelpTextList: | |
| 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 = ModuleEventClass() | |
| Event.Type = self.EventType | |
| Event.GuidCName = self.Name | |
| Event.SupArchList = self.CommonDefines.SupArchList | |
| Event.Usage = self.CommonDefines.Usage | |
| Event.FeatureFlag = self.CommonDefines.FeatureFlag | |
| Event.HelpTextList = GetHelpTextList(self.HelpText) | |
| return Event | |
| def ToXml(self, Event, Key): | |
| AttributeList = [['EventType', Event.Type], | |
| ['Usage', Event.Usage], | |
| ['SupArchList', GetStringOfList(Event.SupArchList)], | |
| ['FeatureFlag', Event.FeatureFlag], | |
| ] | |
| NodeList = [] | |
| for Item in Event.HelpTextList: | |
| Tmp = HelpTextXml() | |
| NodeList.append(Tmp.ToXml(Item, 'HelpText')) | |
| Root = CreateXmlElement('%s' % Key, Event.GuidCName, 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 = ModuleHobClass() | |
| Hob.Type = self.HobType | |
| Hob.GuidCName = self.Name | |
| Hob.SupArchList = self.CommonDefines.SupArchList | |
| Hob.Usage = self.CommonDefines.Usage | |
| Hob.FeatureFlag = self.CommonDefines.FeatureFlag | |
| Hob.HelpTextList = GetHelpTextList(self.HelpText) | |
| return Hob | |
| def ToXml(self, Hob, Key): | |
| AttributeList = [['EventType', Hob.Type], | |
| ['Usage', Hob.Usage], | |
| ['SupArchList', GetStringOfList(Hob.SupArchList)], | |
| ['FeatureFlag', Hob.FeatureFlag], | |
| ] | |
| NodeList = [] | |
| for Item in Hob.HelpTextList: | |
| Tmp = HelpTextXml() | |
| NodeList.append(Tmp.ToXml(Item, 'HelpText')) | |
| Root = CreateXmlElement('%s' % Key, Hob.GuidCName, 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 | |
| # ModulePropertyXml | |
| class ModulePropertyXml(object): | |
| def __init__(self): | |
| self.CommonDefines = CommonDefinesXml() | |
| self.ModuleType = '' | |
| self.Path = '' | |
| self.PcdIsDriver = '' | |
| self.UefiSpecificationVersion = '' | |
| self.PiSpecificationVersion = '' | |
| self.Specification = '' | |
| 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) | |
| self.Specification = XmlElement(Item, '%s/Specification' % Key) | |
| self.SpecificationVersion = XmlAttribute(XmlNode(Item, '%s/Specification' % Key), 'Version') | |
| for SubItem in XmlList(Item, '%s/BootMode' % Key): | |
| A = BootModeXml() | |
| BootMode = A.FromXml(SubItem, 'BootMode') | |
| self.BootModes.append(BootMode) | |
| for SubItem in XmlList(Item, '%s/Event' % Key): | |
| A = EventXml() | |
| Event = A.FromXml(SubItem, 'Event') | |
| self.Events.append(Event) | |
| for SubItem in XmlList(Item, '%s/HOB' % Key): | |
| A = HobXml() | |
| Hob = A.FromXml(SubItem, 'HOB') | |
| self.HOBs.append(Hob) | |
| if Header == None: | |
| Header = ModuleHeaderClass() | |
| Header.ModuleType = self.ModuleType | |
| Header.SupArchList = self.CommonDefines.SupArchList | |
| Header.SupModuleList = self.CommonDefines.SupModList | |
| Header.CombinePath = self.Path | |
| Header.PcdIsDriver = self.PcdIsDriver | |
| Header.UefiSpecificationVersion = self.UefiSpecificationVersion | |
| Header.PiSpecificationVersion = self.PiSpecificationVersion | |
| return Header, self.BootModes, self.Events, self.HOBs | |
| def ToXml(self, Header, BootModes, Events, Hobs, Key): | |
| AttributeList = [['SupArchList', GetStringOfList(Header.SupArchList)], | |
| ['SupModList', GetStringOfList(Header.SupModuleList)], | |
| ] | |
| NodeList = [['ModuleType', Header.ModuleType], | |
| ['Path', Header.CombinePath], | |
| ['PcdIsDriver', Header.PcdIsDriver], | |
| ['UefiSpecificationVersion', Header.UefiSpecificationVersion], | |
| ['PiSpecificationVersion', Header.PiSpecificationVersion], | |
| ] | |
| 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.Specification, 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 | |
| # 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.FileType = XmlAttribute(Item, 'FileType') | |
| self.SourceFile = XmlElement(Item, 'Filename') | |
| self.CommonDefines.FromXml(Item, Key) | |
| SourceFile = ModuleSourceFileClass() | |
| SourceFile.SourceFile = self.SourceFile | |
| SourceFile.FileType = self.FileType | |
| SourceFile.ToolChainFamily = self.ToolChainFamily | |
| SourceFile.SupArchList = self.CommonDefines.SupArchList | |
| SourceFile.FeatureFlag = self.CommonDefines.FeatureFlag | |
| return SourceFile | |
| def ToXml(self, SourceFile, Key): | |
| AttributeList = [['SupArchList', GetStringOfList(SourceFile.SupArchList)], | |
| ['Family', SourceFile.ToolChainFamily], | |
| ['FileType', SourceFile.FileType], | |
| ['FeatureFlag', SourceFile.FeatureFlag], | |
| ] | |
| Root = CreateXmlElement('%s' % Key, SourceFile.SourceFile, [], AttributeList) | |
| return Root | |
| # FilenameXml | |
| class FilenameXml(object): | |
| def __init__(self): | |
| self.OS = '' | |
| self.Family = '' | |
| self.FileType = '' | |
| self.Filename = '' | |
| self.Executable = '' | |
| self.CommonDefines = CommonDefinesXml() | |
| def FromXml(self, Item, Key): | |
| self.OS = XmlAttribute(Item, 'OS') | |
| self.Family = XmlAttribute(Item, 'Family') | |
| self.FileType = XmlAttribute(Item, 'FileType') | |
| self.Filename = XmlElement(Item, 'Filename') | |
| self.Executable = XmlElement(Item, 'Executable') | |
| self.CommonDefines.FromXml(Item, Key) | |
| Filename = FileClass() | |
| Filename.Family = self.Family | |
| Filename.FileType = self.FileType | |
| Filename.Filename = self.Filename | |
| Filename.Executable = self.Executable | |
| Filename.SupArchList = self.CommonDefines.SupArchList | |
| Filename.FeatureFlag = self.CommonDefines.FeatureFlag | |
| return Filename | |
| def ToXml(self, Filename, Key): | |
| AttributeList = [['SupArchList', GetStringOfList(Filename.SupArchList)], | |
| ['Family', Filename.Family], | |
| ['FileType', Filename.FileType], | |
| ['Executable', Filename.Executable], | |
| ['FeatureFlag', Filename.FeatureFlag], | |
| ] | |
| NodeList = [['Filename', Filename.Filename], | |
| ] | |
| Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) | |
| return Root | |
| def __str__(self): | |
| return "OS = %s Family = %s FileType = %s Filename = %s Executable = %s %s" \ | |
| % (self.OS, self.Family, self.FileType, self.Filename, self.Executable, self.CommonDefines) | |
| class BinaryFileXml(object): | |
| def __init__(self): | |
| self.Filenames = [] | |
| self.PatchPcdValues = [] | |
| self.PcdExValues = [] | |
| self.LibraryInstances = [] | |
| self.BuildFlags = [] | |
| def FromXml(self, Item, Key): | |
| BinaryFile = ModuleBinaryFileClass() | |
| for SubItem in XmlList(Item, '%s/Filename' % Key): | |
| A = FilenameXml() | |
| B = A.FromXml(SubItem, 'Filename') | |
| BinaryFile.Filenames.append(B) | |
| for SubItem in XmlList(Item, '%s/AsBuilt/PatchPcdValue' % Key): | |
| A = PcdEntryXml() | |
| B = A.FromXml(SubItem, 'PatchPcdValue') | |
| BinaryFile.PatchPcdValues.append(B) | |
| for SubItem in XmlList(Item, '%s/AsBuilt/PcdExValue' % Key): | |
| A = PcdEntryXml() | |
| B = A.FromXml(SubItem, 'PcdExValue') | |
| BinaryFile.PatchPcdValues.append(B) | |
| for SubItem in XmlList(Item, '%s/AsBuilt/LibraryInstances/GUID' % Key): | |
| GUID = XmlElement(SubItem, 'GUID') | |
| Version = XmlAttribute(XmlNode(SubItem, 'GUID'), 'Version') | |
| BinaryFile.LibraryInstances.append([GUID, Version]) | |
| for SubItem in XmlList(Item, '%s/AsBuilt/BuildFlags' % Key): | |
| BinaryFile.BuildFlags.append(XmlElement(SubItem, 'BuildFlags')) | |
| return BinaryFile | |
| def ToXml(self, BinaryFile, Key): | |
| NodeList = [] | |
| for Item in BinaryFile.Filenames: | |
| Tmp = FilenameXml() | |
| NodeList.append(Tmp.ToXml(Item, 'Filename')) | |
| AsBuiltNodeList = [] | |
| for Item in BinaryFile.PatchPcdValues: | |
| Tmp = PcdEntryXml() | |
| AsBuiltNodeList.append(Tmp.ToXml(Item, 'PatchPcdValue')) | |
| for Item in BinaryFile.PcdExValues: | |
| Tmp = PcdEntryXml() | |
| AsBuiltNodeList.append(Tmp.ToXml(Item, 'PcdExValue')) | |
| LibNodeList = [] | |
| for Item in BinaryFile.LibraryInstances: | |
| LibNode = CreateXmlElement('GUID', Item[0], [], [['Version', Item[1]]]) | |
| LibNodeList.append(LibNode) | |
| if LibNodeList: | |
| AsBuiltNodeList.append(CreateXmlElement('LibraryInstances', '', LibNodeList, [])) | |
| for Item in BinaryFile.BuildFlags: | |
| AsBuiltNodeList.append(CreateXmlElement('BuildFlags', Item, [], [])) | |
| 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 = ModulePackageDependencyClass() | |
| PackageDependency.FilePath = self.Description | |
| PackageDependency.PackageGuid = self.Guid | |
| PackageDependency.PackageVersion = self.Version | |
| PackageDependency.FeatureFlag = self.CommonDefines.FeatureFlag | |
| PackageDependency.SupArchList = self.CommonDefines.SupArchList | |
| return PackageDependency | |
| def ToXml(self, PackageDependency, Key): | |
| AttributeList = [['SupArchList', GetStringOfList(PackageDependency.SupArchList)], | |
| ['FeatureFlag', PackageDependency.FeatureFlag], | |
| ] | |
| Element1 = CreateXmlElement('GUID', PackageDependency.PackageGuid, [], [['Version', PackageDependency.PackageVersion]]) | |
| NodeList = [['Description', PackageDependency.FilePath], | |
| 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.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) | |
| for HelpTextItem in XmlList(Item, '%s/HelpText' % Key): | |
| HelpTextObj = HelpTextXml() | |
| HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key) | |
| self.HelpText.append(HelpTextObj) | |
| Extern = ModuleExternClass() | |
| Extern.EntryPoint = self.EntryPoint | |
| Extern.UnloadImage = self.UnloadImage | |
| Extern.Constructor = self.Constructor | |
| Extern.Destructor = self.Destructor | |
| Extern.SupArchList = self.CommonDefines.SupArchList | |
| Extern.FeatureFlag = self.CommonDefines.FeatureFlag | |
| Extern.HelpTextList = GetHelpTextList(self.HelpText) | |
| return Extern | |
| def ToXml(self, Extern, Key): | |
| AttributeList = [['SupArchList', GetStringOfList(Extern.SupArchList)], | |
| ['FeatureFlag', Extern.FeatureFlag], | |
| ] | |
| NodeList = [['EntryPoint', Extern.EntryPoint], | |
| ['UnloadImage', Extern.UnloadImage], | |
| ['Constructor', Extern.Constructor], | |
| ['Destructor', Extern.Destructor], | |
| ] | |
| for Item in Extern.HelpTextList: | |
| Tmp = HelpTextXml() | |
| NodeList.append(Tmp.ToXml(Item, 'HelpText')) | |
| Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList) | |
| 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.Expression = '' | |
| #self.HelpText = HelpTextXml() | |
| self.HelpText = [] | |
| def FromXml(self, 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 = ModuleDepexClass() | |
| Depex.Depex = self.Expression | |
| Depex.HelpTextList = GetHelpTextList(self.HelpText) | |
| return Depex | |
| def ToXml(self, Depex, Key): | |
| AttributeList = [] | |
| NodeList = [['Expression', Depex.Depex], | |
| ] | |
| for Item in Depex.HelpTextList: | |
| Tmp = HelpTextXml() | |
| NodeList.append(Tmp.ToXml(Item, '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 | |
| # PackageSurfaceAreaXml | |
| class PackageSurfaceAreaXml(object): | |
| def __init__(self): | |
| self.Package = None | |
| def FromXml(self, Item, Key): | |
| # Create a package object | |
| Package = PackageClass() | |
| # Header | |
| Tmp = PackageHeaderXml() | |
| PackageHeader = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/Header'), 'Header') | |
| Package.PackageHeader = PackageHeader | |
| # ClonedFrom | |
| Tmp = ClonedFromXml() | |
| ClonedFrom = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/ClonedFrom'), 'ClonedFrom') | |
| if ClonedFrom: | |
| Package.PackageHeader.ClonedFrom.append(ClonedFrom) | |
| # LibraryClass | |
| for SubItem in XmlList(Item, '/PackageSurfaceArea/LibraryClassDeclarations/LibraryClass'): | |
| Tmp = LibraryClassXml() | |
| LibraryClass = Tmp.FromXml(SubItem, 'LibraryClass') | |
| Package.LibraryClassDeclarations.append(LibraryClass) | |
| # IndustryStandardHeader | |
| for SubItem in XmlList(Item, '/PackageSurfaceArea/IndustryStandardIncludes/IndustryStandardHeader'): | |
| Tmp = IndustryStandardHeaderXml() | |
| Include = Tmp.FromXml(SubItem, 'IndustryStandardHeader') | |
| Package.IndustryStdHeaders.append(Include) | |
| # PackageHeader | |
| for SubItem in XmlList(Item, '/PackageSurfaceArea/PackageIncludes/PackageHeader'): | |
| Tmp = PackageIncludeHeaderXml() | |
| Include = Tmp.FromXml(SubItem, 'PackageHeader') | |
| Package.PackageIncludePkgHeaders.append(Include) | |
| # Guid | |
| for SubItem in XmlList(Item, '/PackageSurfaceArea/GuidDeclarations/Entry'): | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry') | |
| Package.GuidDeclarations.append(GuidProtocolPpi) | |
| # Protocol | |
| for SubItem in XmlList(Item, '/PackageSurfaceArea/ProtocolDeclarations/Entry'): | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry') | |
| Package.ProtocolDeclarations.append(GuidProtocolPpi) | |
| # Ppi | |
| for SubItem in XmlList(Item, '/PackageSurfaceArea/PpiDeclarations/Entry'): | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpi = Tmp.FromXml(SubItem, 'Entry') | |
| Package.PpiDeclarations.append(GuidProtocolPpi) | |
| # PcdEntry | |
| for SubItem in XmlList(Item, '/PackageSurfaceArea/PcdDeclarations/PcdEntry'): | |
| Tmp = PcdEntryXml() | |
| PcdEntry = Tmp.FromXml(SubItem, 'PcdEntry') | |
| Package.PcdDeclarations.append(PcdEntry) | |
| # PcdCheck | |
| for SubItem in XmlList(Item, '/PackageSurfaceArea/PcdRelationshipChecks/PcdCheck'): | |
| Tmp = PcdCheckXml() | |
| PcdCheck = Tmp.FromXml(SubItem, 'PcdCheck') | |
| Package.PcdChecks.append(PcdCheck) | |
| # MiscellaneousFile | |
| Tmp = MiscellaneousFileXml() | |
| Package.MiscFiles = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles') | |
| # UserExtensions | |
| Tmp = UserExtensionsXml() | |
| Package.UserExtensions = Tmp.FromXml(XmlNode(Item, '/PackageSurfaceArea/UserExtensions'), 'UserExtensions') | |
| # Modules | |
| for SubItem in XmlList(Item, '/PackageSurfaceArea/Modules/ModuleSurfaceArea'): | |
| Tmp = ModuleSurfaceAreaXml() | |
| Module = Tmp.FromXml(SubItem, 'ModuleSurfaceArea') | |
| Package.Modules[(Module.ModuleHeader.Guid, Module.ModuleHeader.Version, Module.ModuleHeader.CombinePath)] = Module | |
| self.Package = Package | |
| return self.Package | |
| def ToXml(self, Package): | |
| # Create PackageSurfaceArea node | |
| DomPackage = minidom.Document().createElement('PackageSurfaceArea') | |
| # Header | |
| Tmp = PackageHeaderXml() | |
| DomPackage.appendChild(Tmp.ToXml(Package.PackageHeader, 'Header')) | |
| # ClonedFrom | |
| Tmp = ClonedFromXml() | |
| if Package.PackageHeader.ClonedFrom != []: | |
| DomPackage.appendChild(Tmp.ToXml(Package.PackageHeader.ClonedFrom[0], 'ClonedFrom')) | |
| # LibraryClass | |
| LibraryClassNode = CreateXmlElement('LibraryClassDeclarations', '', [], []) | |
| for LibraryClass in Package.LibraryClassDeclarations: | |
| Tmp = LibraryClassXml() | |
| LibraryClassNode.appendChild(Tmp.ToXml(LibraryClass, 'LibraryClass')) | |
| DomPackage.appendChild(LibraryClassNode) | |
| # IndustryStandardHeader | |
| IndustryStandardHeaderNode = CreateXmlElement('IndustryStandardIncludes', '', [], []) | |
| for Include in Package.IndustryStdHeaders: | |
| Tmp = IndustryStandardHeaderXml() | |
| IndustryStandardHeaderNode.appendChild(Tmp.ToXml(Include, 'IndustryStandardHeader')) | |
| DomPackage.appendChild(IndustryStandardHeaderNode) | |
| # PackageHeader | |
| PackageIncludeHeaderNode = CreateXmlElement('PackageIncludes', '', [], []) | |
| for Include in Package.PackageIncludePkgHeaders: | |
| Tmp = PackageIncludeHeaderXml() | |
| PackageIncludeHeaderNode.appendChild(Tmp.ToXml(Include, 'PackageHeader')) | |
| DomPackage.appendChild(PackageIncludeHeaderNode) | |
| # Guid | |
| GuidProtocolPpiNode = CreateXmlElement('GuidDeclarations', '', [], []) | |
| for GuidProtocolPpi in Package.GuidDeclarations: | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Entry')) | |
| DomPackage.appendChild(GuidProtocolPpiNode) | |
| # Protocol | |
| GuidProtocolPpiNode = CreateXmlElement('ProtocolDeclarations', '', [], []) | |
| for GuidProtocolPpi in Package.ProtocolDeclarations: | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Entry')) | |
| DomPackage.appendChild(GuidProtocolPpiNode) | |
| # Ppi | |
| GuidProtocolPpiNode = CreateXmlElement('PpiDeclarations', '', [], []) | |
| for GuidProtocolPpi in Package.PpiDeclarations: | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Entry')) | |
| DomPackage.appendChild(GuidProtocolPpiNode) | |
| # PcdEntry | |
| PcdEntryNode = CreateXmlElement('PcdDeclarations', '', [], []) | |
| for PcdEntry in Package.PcdDeclarations: | |
| Tmp = PcdEntryXml() | |
| PcdEntryNode.appendChild(Tmp.ToXml(PcdEntry, 'PcdEntry')) | |
| DomPackage.appendChild(PcdEntryNode) | |
| # PcdCheck | |
| PcdCheckNode = CreateXmlElement('PcdRelationshipChecks', '', [], []) | |
| for PcdCheck in Package.PcdChecks: | |
| Tmp = PcdCheckXml() | |
| PcdCheckNode.appendChild(Tmp.ToXml(PcdCheck, 'PcdCheck')) | |
| DomPackage.appendChild(PcdCheckNode) | |
| # MiscellaneousFile | |
| Tmp = MiscellaneousFileXml() | |
| DomPackage.appendChild(Tmp.ToXml(Package.MiscFiles, 'MiscellaneousFiles')) | |
| # UserExtensions | |
| Tmp = UserExtensionsXml() | |
| DomPackage.appendChild(Tmp.ToXml(Package.UserExtensions, 'UserExtensions')) | |
| # Modules | |
| ModuleNode = CreateXmlElement('Modules', '', [], []) | |
| for Module in Package.Modules.values(): | |
| Tmp = ModuleSurfaceAreaXml() | |
| ModuleNode.appendChild(Tmp.ToXml(Module)) | |
| DomPackage.appendChild(ModuleNode) | |
| return DomPackage | |
| # ModuleXml | |
| class ModuleSurfaceAreaXml(object): | |
| def __init__(self): | |
| self.Module = None | |
| def FromXml(self, Item, Key): | |
| # Create a package object | |
| Module = ModuleClass() | |
| # Header | |
| Tmp = HeaderXml() | |
| ModuleHeader = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/Header'), 'Header') | |
| Module.ModuleHeader = ModuleHeader | |
| # ModuleProperties | |
| Tmp = ModulePropertyXml() | |
| (Header, BootModes, Events, HOBs) = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ModuleProperties'), 'ModuleProperties', ModuleHeader) | |
| Module.ModuleHeader = Header | |
| Module.BootModes = BootModes | |
| Module.Events = Events | |
| Module.Hobs = HOBs | |
| # ClonedFrom | |
| Tmp = ClonedFromXml() | |
| ClonedFrom = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ClonedFrom'), 'ClonedFrom') | |
| if ClonedFrom: | |
| Module.ModuleHeader.ClonedFrom.append(ClonedFrom) | |
| # LibraryClass | |
| #LibraryClassNode = CreateXmlElement('LibraryClassDefinitions', '', [], []) | |
| for SubItem in XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass'): | |
| Tmp = LibraryClassXml() | |
| LibraryClass = Tmp.FromXml(SubItem, 'LibraryClass') | |
| Module.LibraryClasses.append(LibraryClass) | |
| # SourceFile | |
| #SourceFileNode = CreateXmlElement('SourceFiles', '', [], []) | |
| for SubItem in XmlList(Item, '/ModuleSurfaceArea/SourceFiles/Filename'): | |
| Tmp = SourceFileXml() | |
| SourceFile = Tmp.FromXml(SubItem, 'Filename') | |
| Module.Sources.append(SourceFile) | |
| # BinaryFile | |
| #BinaryFileNode = CreateXmlElement('BinaryFiles', '', [], []) | |
| for SubItem in XmlList(Item, '/ModuleSurfaceArea/BinaryFiles/BinaryFile'): | |
| Tmp = BinaryFileXml() | |
| BinaryFile = Tmp.FromXml(SubItem, 'BinaryFile') | |
| Module.Binaries.append(BinaryFile) | |
| # PackageDependencies | |
| #PackageDependencyNode = CreateXmlElement('PackageDependencies', '', [], []) | |
| for SubItem in XmlList(Item, '/ModuleSurfaceArea/PackageDependencies/Package'): | |
| Tmp = PackageXml() | |
| PackageDependency = Tmp.FromXml(SubItem, 'Package') | |
| Module.PackageDependencies.append(PackageDependency) | |
| # Guid | |
| #GuidProtocolPpiNode = CreateXmlElement('Guids', '', [], []) | |
| for SubItem in XmlList(Item, '/ModuleSurfaceArea/Guids/GuidCName'): | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpi = Tmp.FromXml(SubItem, 'GuidCName') | |
| Module.Guids.append(GuidProtocolPpi) | |
| # Protocol | |
| #GuidProtocolPpiNode = CreateXmlElement('Protocols', '', [], []) | |
| for SubItem in XmlList(Item, '/ModuleSurfaceArea/Protocols/Protocol'): | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpi = Tmp.FromXml(SubItem, 'Protocol') | |
| Module.Protocols.append(GuidProtocolPpi) | |
| # Ppi | |
| #GuidProtocolPpiNode = CreateXmlElement('PPIs', '', [], []) | |
| for SubItem in XmlList(Item, '/ModuleSurfaceArea/PPIs/Ppi'): | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpi = Tmp.FromXml(SubItem, 'Ppi') | |
| Module.Ppis.append(GuidProtocolPpi) | |
| # Extern | |
| #ExternNode = CreateXmlElement('Externs', '', [], []) | |
| for SubItem in XmlList(Item, '/ModuleSurfaceArea/Externs/Extern'): | |
| Tmp = ExternXml() | |
| Extern = Tmp.FromXml(SubItem, 'Extern') | |
| Module.Externs.append(Extern) | |
| # PcdCoded | |
| #PcdEntryNode = CreateXmlElement('PcdCoded', '', [], []) | |
| for SubItem in XmlList(Item, '/ModuleSurfaceArea/PcdCoded/PcdEntry'): | |
| Tmp = PcdEntryXml() | |
| PcdEntry = Tmp.FromXml(SubItem, 'PcdEntry') | |
| Module.PcdCodes.append(PcdEntry) | |
| # PeiDepex | |
| #DepexNode = CreateXmlElement('PeiDepex', '', [], []) | |
| Tmp = DepexXml() | |
| Module.PeiDepex = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/PeiDepex'), 'PeiDepex') | |
| # DxeDepex | |
| #DepexNode = CreateXmlElement('DxeDepex', '', [], []) | |
| Tmp = DepexXml() | |
| Module.DxeDepex = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/DxeDepex'), 'DxeDepex') | |
| # SmmDepex | |
| #DepexNode = CreateXmlElement('SmmDepex', '', [], []) | |
| Tmp = DepexXml() | |
| Module.SmmDepex = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/DxeDepex'), 'SmmDepex') | |
| # MiscellaneousFile | |
| Tmp = MiscellaneousFileXml() | |
| Module.MiscFiles = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles') | |
| # UserExtensions | |
| Tmp = UserExtensionsXml() | |
| Module.UserExtensions = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/UserExtensions'), 'UserExtensions') | |
| # return the module object | |
| self.Module = Module | |
| return self.Module | |
| def ToXml(self, Module): | |
| # Create root node of module surface area | |
| DomModule = minidom.Document().createElement('ModuleSurfaceArea') | |
| # Header | |
| Tmp = HeaderXml() | |
| DomModule.appendChild(Tmp.ToXml(Module.ModuleHeader, 'Header')) | |
| # ModuleProperties | |
| Tmp = ModulePropertyXml() | |
| DomModule.appendChild(Tmp.ToXml(Module.ModuleHeader, Module.BootModes, Module.Events, Module.Hobs, 'ModuleProperties')) | |
| # ClonedFrom | |
| Tmp = ClonedFromXml() | |
| if Module.ModuleHeader.ClonedFrom != []: | |
| DomModule.appendChild(Tmp.ToXml(Module.ModuleHeader.ClonedFrom[0], 'ClonedFrom')) | |
| # LibraryClass | |
| LibraryClassNode = CreateXmlElement('LibraryClassDefinitions', '', [], []) | |
| for LibraryClass in Module.LibraryClasses: | |
| Tmp = LibraryClassXml() | |
| LibraryClassNode.appendChild(Tmp.ToXml(LibraryClass, 'LibraryClass')) | |
| DomModule.appendChild(LibraryClassNode) | |
| # SourceFile | |
| SourceFileNode = CreateXmlElement('SourceFiles', '', [], []) | |
| for SourceFile in Module.Sources: | |
| Tmp = SourceFileXml() | |
| SourceFileNode.appendChild(Tmp.ToXml(SourceFile, 'Filename')) | |
| DomModule.appendChild(SourceFileNode) | |
| # BinaryFile | |
| BinaryFileNode = CreateXmlElement('BinaryFiles', '', [], []) | |
| for BinaryFile in Module.Binaries: | |
| Tmp = BinaryFileXml() | |
| BinaryFileNode.appendChild(Tmp.ToXml(BinaryFile, 'BinaryFile')) | |
| DomModule.appendChild(BinaryFileNode) | |
| # PackageDependencies | |
| PackageDependencyNode = CreateXmlElement('PackageDependencies', '', [], []) | |
| for PackageDependency in Module.PackageDependencies: | |
| Tmp = PackageXml() | |
| PackageDependencyNode.appendChild(Tmp.ToXml(PackageDependency, 'Package')) | |
| DomModule.appendChild(PackageDependencyNode) | |
| # Guid | |
| GuidProtocolPpiNode = CreateXmlElement('Guids', '', [], []) | |
| for GuidProtocolPpi in Module.Guids: | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'GuidCName')) | |
| DomModule.appendChild(GuidProtocolPpiNode) | |
| # Protocol | |
| GuidProtocolPpiNode = CreateXmlElement('Protocols', '', [], []) | |
| for GuidProtocolPpi in Module.Protocols: | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Protocol')) | |
| DomModule.appendChild(GuidProtocolPpiNode) | |
| # Ppi | |
| GuidProtocolPpiNode = CreateXmlElement('PPIs', '', [], []) | |
| for GuidProtocolPpi in Module.Ppis: | |
| Tmp = GuidProtocolPpiXml() | |
| GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Ppi')) | |
| DomModule.appendChild(GuidProtocolPpiNode) | |
| # Extern | |
| ExternNode = CreateXmlElement('Externs', '', [], []) | |
| for Extern in Module.Externs: | |
| Tmp = ExternXml() | |
| ExternNode.appendChild(Tmp.ToXml(Extern, 'Extern')) | |
| DomModule.appendChild(ExternNode) | |
| # PcdCoded | |
| PcdEntryNode = CreateXmlElement('PcdCoded', '', [], []) | |
| for PcdEntry in Module.PcdCodes: | |
| Tmp = PcdEntryXml() | |
| PcdEntryNode.appendChild(Tmp.ToXml(PcdEntry, 'PcdEntry')) | |
| DomModule.appendChild(PcdEntryNode) | |
| # PeiDepex | |
| if Module.PeiDepex: | |
| DepexNode = CreateXmlElement('PeiDepex', '', [], []) | |
| Tmp = DepexXml() | |
| DomModule.appendChild(Tmp.ToXml(Module.PeiDepex, 'PeiDepex')) | |
| # DxeDepex | |
| if Module.DxeDepex: | |
| DepexNode = CreateXmlElement('DxeDepex', '', [], []) | |
| Tmp = DepexXml() | |
| DomModule.appendChild(Tmp.ToXml(Module.DxeDepex, 'DxeDepex')) | |
| # SmmDepex | |
| if Module.SmmDepex: | |
| DepexNode = CreateXmlElement('SmmDepex', '', [], []) | |
| Tmp = DepexXml() | |
| DomModule.appendChild(Tmp.ToXml(Module.SmmDepex, 'SmmDepex')) | |
| # MiscellaneousFile | |
| Tmp = MiscellaneousFileXml() | |
| DomModule.appendChild(Tmp.ToXml(Module.MiscFiles, 'MiscellaneousFiles')) | |
| # UserExtensions | |
| Tmp = UserExtensionsXml() | |
| DomModule.appendChild(Tmp.ToXml(Module.UserExtensions, 'UserExtensions')) | |
| return DomModule | |
| # DistributionPackageXml | |
| class DistributionPackageXml(object): | |
| def __init__(self): | |
| self.Dp = DistributionPackageClass() | |
| def FromXml(self, Filename = None): | |
| if Filename != None: | |
| self.Dp = DistributionPackageClass() | |
| # Load to XML | |
| self.Pkg = XmlParseFile(Filename) | |
| # Parse Header information | |
| Tmp = DistributionPackageHeaderXml() | |
| DistributionPackageHeader = Tmp.FromXml(XmlNode(self.Pkg, '/DistributionPackage/DistributionHeader'), 'DistributionHeader') | |
| self.Dp.Header = DistributionPackageHeader | |
| # Parse each PackageSurfaceArea | |
| for Item in XmlList(self.Pkg, '/DistributionPackage/PackageSurfaceArea'): | |
| Psa = PackageSurfaceAreaXml() | |
| Package = Psa.FromXml(Item, 'PackageSurfaceArea') | |
| self.Dp.PackageSurfaceArea[(Package.PackageHeader.Guid, Package.PackageHeader.Version, Package.PackageHeader.CombinePath)] = Package | |
| # Parse each ModuleSurfaceArea | |
| for Item in XmlList(self.Pkg, '/DistributionPackage/ModuleSurfaceArea'): | |
| Msa = ModuleSurfaceAreaXml() | |
| Module = Msa.FromXml(Item, 'ModuleSurfaceArea') | |
| self.Dp.ModuleSurfaceArea[(Module.ModuleHeader.Guid, Module.ModuleHeader.Version, Module.ModuleHeader.CombinePath)] = Module | |
| # Parse Tools | |
| Tmp = MiscellaneousFileXml() | |
| self.Dp.Tools = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/Tools'), 'Tools') | |
| # Parse MiscFiles | |
| Tmp = MiscellaneousFileXml() | |
| self.Dp.MiscellaneousFiles = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/MiscellaneousFiles'), 'MiscellaneousFiles') | |
| return self.Dp | |
| def ToXml(self, Dp): | |
| if Dp != None: | |
| # Parse DistributionPackageHeader | |
| Attrs = [['xmlns', 'http://www.uefi.org/2008/2.1'], | |
| ['xmlns:xsi', 'http:/www.w3.org/2001/XMLSchema-instance'], | |
| ] | |
| Root = CreateXmlElement('DistributionPackage', '', [], Attrs) | |
| Tmp = DistributionPackageHeaderXml() | |
| Root.appendChild(Tmp.ToXml(Dp.Header, 'DistributionHeader')) | |
| # Parse each PackageSurfaceArea | |
| for Package in Dp.PackageSurfaceArea.values(): | |
| Psa = PackageSurfaceAreaXml() | |
| DomPackage = Psa.ToXml(Package) | |
| Root.appendChild(DomPackage) | |
| # Parse each ModuleSurfaceArea | |
| for Module in Dp.ModuleSurfaceArea.values(): | |
| Msa = ModuleSurfaceAreaXml() | |
| DomModule = Msa.ToXml(Module) | |
| Root.appendChild(DomModule) | |
| # Parse Tools | |
| Tmp = MiscellaneousFileXml() | |
| #Tools = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/Tools'), 'Tools') | |
| Root.appendChild(Tmp.ToXml2(Dp.Tools, 'Tools')) | |
| # Parse MiscFiles | |
| Tmp = MiscellaneousFileXml() | |
| #Tools = Tmp.FromXml2(XmlNode(self.Pkg, '/DistributionPackage/MiscellaneousFiles'), 'MiscellaneousFiles') | |
| Root.appendChild(Tmp.ToXml2(Dp.MiscellaneousFiles, 'MiscellaneousFiles')) | |
| return Root.toprettyxml(indent = ' ') | |
| return '' | |
| if __name__ == '__main__': | |
| M = DistributionPackageXml() | |
| M.FromXml('C:\Test.xml') | |
| print M.ToXml(M.Dp) | |