summaryrefslogtreecommitdiff
path: root/BaseTools/Source/Python/Common/XmlParser.py
diff options
context:
space:
mode:
Diffstat (limited to 'BaseTools/Source/Python/Common/XmlParser.py')
-rw-r--r--BaseTools/Source/Python/Common/XmlParser.py1754
1 files changed, 1754 insertions, 0 deletions
diff --git a/BaseTools/Source/Python/Common/XmlParser.py b/BaseTools/Source/Python/Common/XmlParser.py
new file mode 100644
index 0000000000..4d60115925
--- /dev/null
+++ b/BaseTools/Source/Python/Common/XmlParser.py
@@ -0,0 +1,1754 @@
+## @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)
+ \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-31 06:45:06 +0000