add missing <BR>

[mirror_edk2.git] / BaseTools / Source / Python / Common / XmlParser.py

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