## @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)