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