From 30fdf1140b8d1ce93f3821d986fa165552023440 Mon Sep 17 00:00:00 2001 From: lgao4 Date: Fri, 17 Jul 2009 09:10:31 +0000 Subject: Check In tool source code based on Build tool project revision r1655. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8964 6f19259b-4bc3-4df7-8a09-765794883524 --- BaseTools/Source/Python/Common/XmlParser.py | 1754 +++++++++++++++++++++++++++ 1 file changed, 1754 insertions(+) create mode 100644 BaseTools/Source/Python/Common/XmlParser.py (limited to 'BaseTools/Source/Python/Common/XmlParser.py') 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 -- cgit v1.2.3