[mirror_edk2.git] / BaseTools / Source / Python / UPT / Xml / CommonXml.py

## @file\r
# This file is used to parse a PCD file of .PKG file\r
#\r
# Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials are licensed and made available \r
# under the terms and conditions of the BSD License which accompanies this \r
# 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
CommonXml\r
'''\r
\r
##\r
# Import Modules\r
#\r
\r
from Core.DistributionPackageClass import DistributionPackageHeaderObject\r
from Library.String import ConvertNEToNOTEQ\r
from Library.String import ConvertNOTEQToNE\r
from Library.String import GetSplitValueList\r
from Library.String import GetStringOfList\r
from Library.Xml.XmlRoutines import XmlElement\r
from Library.Xml.XmlRoutines import XmlElement2\r
from Library.Xml.XmlRoutines import XmlAttribute\r
from Library.Xml.XmlRoutines import XmlNode\r
from Library.Xml.XmlRoutines import XmlList\r
from Library.Xml.XmlRoutines import CreateXmlElement\r
from Object.POM.CommonObject import FileObject\r
from Object.POM.CommonObject import MiscFileObject\r
from Object.POM.CommonObject import UserExtensionObject\r
from Object.POM.CommonObject import ClonedRecordObject\r
from Object.POM.CommonObject import LibraryClassObject\r
from Object.POM.CommonObject import FileNameObject\r
from Object.POM.ModuleObject import ModuleObject\r
from Xml.XmlParserMisc import IsRequiredItemListNull\r
from Xml.XmlParserMisc import GetHelpTextList\r
\r
import Library.DataType as DataType\r
\r
##\r
# ClonedFromXml\r
#\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 = ClonedRecordObject()\r
        ClonedFrom.SetPackageGuid(self.GUID)\r
        ClonedFrom.SetPackageVersion(self.Version)\r
\r
        return ClonedFrom\r
\r
    def ToXml(self, ClonedFrom, Key):\r
        if self.GUID:\r
            pass\r
        Element1 = CreateXmlElement('GUID', ClonedFrom.GetPackageGuid(), [],\r
                                    [['Version', ClonedFrom.GetPackageVersion()]])\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
\r
##\r
# CommonDefinesXml\r
#\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
        if Key:\r
            pass\r
        self.Usage = XmlAttribute(Item, 'Usage')\r
        self.SupArchList = \\r
        [Arch for Arch in GetSplitValueList(XmlAttribute(Item, 'SupArchList'), DataType.TAB_SPACE_SPLIT) if Arch]\r
        self.SupModList = \\r
        [Mod for Mod in GetSplitValueList(XmlAttribute(Item, 'SupModList'), DataType.TAB_SPACE_SPLIT) if Mod]\r
        self.FeatureFlag = ConvertNOTEQToNE(XmlAttribute(Item, 'FeatureFlag'))\r
\r
\r
    def ToXml(self):\r
        pass\r
\r
    def __str__(self):\r
        return "Usage = %s SupArchList = %s SupModList = %s FeatureFlag = %s" \\r
                % (self.Usage, self.SupArchList, self.SupModList, self.FeatureFlag)\r
\r
\r
##\r
# HelpTextXml\r
#\r
class HelpTextXml(object):\r
    def __init__(self):\r
        self.HelpText = ''\r
        self.Lang = ''\r
\r
    def FromXml(self, Item, Key):\r
        if Key:\r
            pass\r
        self.HelpText = XmlElement2(Item, 'HelpText')\r
        self.Lang = XmlAttribute(Item, 'Lang')\r
\r
    def ToXml(self, HelpText, Key='HelpText'):\r
        if self.HelpText:\r
            pass\r
        return CreateXmlElement('%s' % Key, HelpText.GetString(), [], [['Lang', HelpText.GetLang()]])\r
    def __str__(self):\r
        return "HelpText = %s Lang = %s" % (self.HelpText, self.Lang)\r
\r
##\r
# HeaderXml\r
#\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, IsRequiredCheck=False, IsStandAlongModule=False):\r
        if not Item and IsRequiredCheck:\r
            XmlTreeLevel = []\r
            if IsStandAlongModule:\r
                XmlTreeLevel = ['DistributionPackage', 'ModuleSurfaceArea']\r
            else:\r
                XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea', 'ModuleSurfaceArea']\r
            CheckDict = {'Header':''}\r
            IsRequiredItemListNull(CheckDict, XmlTreeLevel)\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 = ModuleObject()\r
        ModuleHeader.SetName(self.Name)\r
        ModuleHeader.SetBaseName(self.BaseName)\r
        ModuleHeader.SetGuid(self.GUID)\r
        ModuleHeader.SetVersion(self.Version)\r
        ModuleHeader.SetCopyright(self.Copyright)\r
        ModuleHeader.SetLicense(self.License)\r
        ModuleHeader.SetAbstract(self.Abstract)\r
        ModuleHeader.SetDescription(self.Description)\r
\r
        return ModuleHeader\r
\r
    def ToXml(self, Header, Key):\r
        if self.GUID:\r
            pass\r
        Element1 = CreateXmlElement('Name', Header.GetName(), [], [['BaseName', Header.GetBaseName()]])\r
        Element2 = CreateXmlElement('GUID', Header.GetGuid(), [], [['Version', Header.GetVersion()]])\r
        AttributeList = []\r
        NodeList = [Element1,\r
                    Element2,\r
                    ['Copyright', Header.GetCopyright()],\r
                    ['License', Header.GetLicense()],\r
                    ['Abstract', Header.GetAbstract()],\r
                    ['Description', Header.GetDescription()],\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 \\r
        License = %s Abstract = %s Description = %s" % \\r
        (self.Name, self.BaseName, self.GUID, self.Version, self.Copyright, \\r
         self.License, self.Abstract, self.Description)\r
##\r
# DistributionPackageHeaderXml\r
#\r
class DistributionPackageHeaderXml(object):\r
    def __init__(self):\r
        self.Header = HeaderXml()\r
        self.ReadOnly = ''\r
        self.RePackage = ''\r
        self.Vendor = ''\r
        self.Date = ''\r
        self.Signature = ''\r
        self.XmlSpecification = ''\r
\r
    def FromXml(self, Item, Key):\r
        if not Item:\r
            return None\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 = DistributionPackageHeaderObject()\r
        if self.ReadOnly.upper() == 'TRUE':\r
            DistributionPackageHeader.ReadOnly = True\r
        elif self.ReadOnly.upper() == 'FALSE':\r
            DistributionPackageHeader.ReadOnly = False\r
\r
        if self.RePackage.upper() == 'TRUE':\r
            DistributionPackageHeader.RePackage = True\r
        elif self.RePackage.upper() == 'FALSE':\r
            DistributionPackageHeader.RePackage = False\r
        DistributionPackageHeader.Vendor = self.Vendor\r
        DistributionPackageHeader.Date = self.Date\r
        DistributionPackageHeader.Signature = self.Signature\r
        DistributionPackageHeader.XmlSpecification = self.XmlSpecification\r
\r
        DistributionPackageHeader.SetName(self.Header.Name)\r
        DistributionPackageHeader.SetBaseName(self.Header.BaseName)\r
        DistributionPackageHeader.SetGuid(self.Header.GUID)\r
        DistributionPackageHeader.SetVersion(self.Header.Version)\r
        DistributionPackageHeader.SetCopyright(self.Header.Copyright)\r
        DistributionPackageHeader.SetLicense(self.Header.License)\r
        DistributionPackageHeader.SetAbstract(self.Header.Abstract)\r
        DistributionPackageHeader.SetDescription(self.Header.Description)\r
\r
        return DistributionPackageHeader\r
\r
    def ToXml(self, DistributionPackageHeader, Key):\r
        if self.Header:\r
            pass\r
        Element1 = CreateXmlElement('Name', \\r
                                    DistributionPackageHeader.GetName(), [], \\r
                                    [['BaseName', \\r
                                    DistributionPackageHeader.GetBaseName()]])\r
        Element2 = CreateXmlElement('GUID', \\r
                                    DistributionPackageHeader.GetGuid(), [], \\r
                                    [['Version', \\r
                                    DistributionPackageHeader.GetVersion()]])\r
        AttributeList = []\r
        if DistributionPackageHeader.ReadOnly != '':\r
            AttributeList.append(['ReadOnly', str(DistributionPackageHeader.ReadOnly).lower()])\r
        if DistributionPackageHeader.RePackage != '':\r
            AttributeList.append(['RePackage', str(DistributionPackageHeader.RePackage).lower()])\r
\r
        NodeList = [Element1,\r
                    Element2,\r
                    ['Vendor', DistributionPackageHeader.Vendor],\r
                    ['Date', DistributionPackageHeader.Date],\r
                    ['Copyright', DistributionPackageHeader.GetCopyright()],\r
                    ['License', DistributionPackageHeader.GetLicense()],\r
                    ['Abstract', DistributionPackageHeader.GetAbstract()],\r
                    ['Description', \\r
                     DistributionPackageHeader.GetDescription()],\r
                    ['Signature', DistributionPackageHeader.Signature],\r
                    ['XmlSpecification', \\r
                     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 \\r
        Signature = %s XmlSpecification = %s %s" % \\r
        (self.ReadOnly, self.RePackage, self.Vendor, self.Date, \\r
         self.Signature, self.XmlSpecification, self.Header)\r
##\r
# PackageHeaderXml\r
#\r
class PackageHeaderXml(object):\r
    def __init__(self):\r
        self.Header = HeaderXml()\r
        self.PackagePath = ''\r
\r
    def FromXml(self, Item, Key, PackageObject2):\r
        if not Item:\r
            XmlTreeLevel = ['DistributionPackage', 'PackageSurfaceArea']\r
            CheckDict = {'PackageHeader':None, }\r
            IsRequiredItemListNull(CheckDict, XmlTreeLevel)\r
        self.PackagePath = XmlElement(Item, '%s/PackagePath' % Key)\r
        self.Header.FromXml(Item, Key)\r
\r
        PackageObject2.SetName(self.Header.Name)\r
        PackageObject2.SetBaseName(self.Header.BaseName)\r
        PackageObject2.SetGuid(self.Header.GUID)\r
        PackageObject2.SetVersion(self.Header.Version)\r
        PackageObject2.SetCopyright(self.Header.Copyright)\r
        PackageObject2.SetLicense(self.Header.License)\r
        PackageObject2.SetAbstract(self.Header.Abstract)\r
        PackageObject2.SetDescription(self.Header.Description)\r
        PackageObject2.SetPackagePath(self.PackagePath)\r
\r
    def ToXml(self, PackageObject2, Key):\r
        if self.PackagePath:\r
            pass\r
        Element1 = \\r
        CreateXmlElement('Name', PackageObject2.GetName(), [], \\r
                         [['BaseName', PackageObject2.GetBaseName()]])\r
        Element2 = CreateXmlElement('GUID', PackageObject2.GetGuid(), [], \\r
                                    [['Version', PackageObject2.GetVersion()]])\r
        AttributeList = []\r
        NodeList = [Element1,\r
                    Element2,\r
                    ['Copyright', PackageObject2.GetCopyright()],\r
                    ['License', PackageObject2.GetLicense()],\r
                    ['Abstract', PackageObject2.GetAbstract()],\r
                    ['Description', PackageObject2.GetDescription()],\r
                    ['PackagePath', PackageObject2.GetPackagePath()],\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
##\r
# MiscellaneousFileXml\r
#\r
class MiscellaneousFileXml(object):\r
    def __init__(self):\r
        self.Header = HeaderXml()\r
        self.Files = []\r
    ##\r
    # This API is used for Package or Module's MiscellaneousFile section\r
    #\r
    def FromXml(self, Item, Key):\r
        if not Item:\r
            return None\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
            if Executable.upper() == "TRUE":\r
                Executable = True\r
            elif Executable.upper() == "FALSE":\r
                Executable = False\r
            else:\r
                Executable = ''\r
            self.Files.append([Filename, Executable])\r
\r
        MiscFile = MiscFileObject()\r
        MiscFile.SetCopyright(self.Header.Copyright)\r
        MiscFile.SetLicense(self.Header.License)\r
        MiscFile.SetAbstract(self.Header.Abstract)\r
        MiscFile.SetDescription(self.Header.Description)\r
        MiscFileList = []\r
        for File in self.Files:\r
            FileObj = FileObject()\r
            FileObj.SetURI(File[0])\r
            FileObj.SetExecutable(File[1])\r
            MiscFileList.append(FileObj)\r
        MiscFile.SetFileList(MiscFileList)\r
\r
        return MiscFile\r
    ##\r
    # This API is used for DistP's tool section\r
    #\r
    def FromXml2(self, Item, Key):\r
        if Item is None:\r
            return None\r
\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 = \\r
            XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')\r
            OsType = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'OS')\r
            if Executable.upper() == "TRUE":\r
                Executable = True\r
            elif Executable.upper() == "FALSE":\r
                Executable = False\r
            else:\r
                Executable = ''\r
            self.Files.append([Filename, Executable, OsType])\r
\r
        MiscFile = MiscFileObject()\r
        MiscFile.SetName(self.Header.Name)\r
        MiscFile.SetCopyright(self.Header.Copyright)\r
        MiscFile.SetLicense(self.Header.License)\r
        MiscFile.SetAbstract(self.Header.Abstract)\r
        MiscFile.SetDescription(self.Header.Description)\r
        MiscFileList = []\r
        for File in self.Files:\r
            FileObj = FileObject()\r
            FileObj.SetURI(File[0])\r
            FileObj.SetExecutable(File[1])\r
            FileObj.SetOS(File[2])\r
            MiscFileList.append(FileObj)\r
        MiscFile.SetFileList(MiscFileList)\r
\r
        return MiscFile\r
\r
    ##\r
    # This API is used for Package or Module's MiscellaneousFile section\r
    #\r
    def ToXml(self, MiscFile, Key):\r
        if self.Header:\r
            pass\r
        if MiscFile:\r
            NodeList = [['Copyright', MiscFile.GetCopyright()],\r
                        ['License', MiscFile.GetLicense()],\r
                        ['Abstract', MiscFile.GetAbstract()],\r
                        ['Description', MiscFile.GetDescription()],\r
                       ]\r
\r
            for File in MiscFile.GetFileList():\r
                NodeList.append\\r
                (CreateXmlElement\\r
                 ('Filename', File.GetURI(), [], \\r
                  [['Executable', str(File.GetExecutable()).lower()]]))\r
            Root = CreateXmlElement('%s' % Key, '', NodeList, [])\r
\r
            return Root\r
    ##\r
    # This API is used for DistP's tool section\r
    #\r
    def ToXml2(self, MiscFile, Key):\r
        if self.Header:\r
            pass\r
        if MiscFile:\r
            NodeList = [['Name', MiscFile.GetName()],\r
                        ['Copyright', MiscFile.GetCopyright()],\r
                        ['License', MiscFile.GetLicense()],\r
                        ['Abstract', MiscFile.GetAbstract()],\r
                        ['Description', MiscFile.GetDescription()],\r
                       ]\r
            HeaderNode = CreateXmlElement('Header', '', NodeList, [])\r
            NodeList = [HeaderNode]\r
\r
            for File in MiscFile.GetFileList():\r
                NodeList.append\\r
                (CreateXmlElement\\r
                 ('Filename', File.GetURI(), [], \\r
                  [['Executable', str(File.GetExecutable()).lower()], \\r
                   ['OS', File.GetOS()]]))\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
#\r
class UserExtensionsXml(object):\r
    def __init__(self):\r
        self.UserId = ''\r
        self.Identifier = ''\r
        self.DefineDict = {}\r
        self.BuildOptionDict = {}\r
        self.IncludesDict = {}\r
        self.SourcesDict = {}\r
        self.BinariesDict = {}\r
        self.SupArchList = []\r
        self.Statement = ''\r
        self.Defines = ''\r
        self.BuildOptions = ''\r
\r
    def FromXml2(self, Item, Key):\r
        self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')\r
        self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')\r
\r
        UserExtension = UserExtensionObject()\r
        UserExtension.SetUserID(self.UserId)\r
        UserExtension.SetIdentifier(self.Identifier)\r
\r
        return UserExtension\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
\r
        DefineItem = XmlNode(Item, '%s/Define' % Key)\r
        for SubItem in XmlList(DefineItem, 'Define/Statement'):\r
            Statement = XmlElement(SubItem, '%s/Statement' % Key)\r
            self.DefineDict[Statement] = ""\r
\r
        BuildOptionItem = XmlNode(Item, '%s/BuildOption' % Key)\r
        for SubItem in XmlList(BuildOptionItem, 'BuildOption/Statement'):\r
            Statement = XmlElement(SubItem, '%s/Statement' % Key)\r
            Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')\r
            self.BuildOptionDict[Arch] = Statement\r
\r
        IncludesItem = XmlNode(Item, '%s/Includes' % Key)\r
        for SubItem in XmlList(IncludesItem, 'Includes/Statement'):\r
            Statement = XmlElement(SubItem, '%s/Statement' % Key)\r
            Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')\r
            self.IncludesDict[Statement] = Arch\r
\r
        SourcesItem = XmlNode(Item, '%s/Sources' % Key)\r
        Tmp = UserExtensionSourceXml()\r
        SourceDict = Tmp.FromXml(SourcesItem, 'Sources')\r
        self.SourcesDict = SourceDict\r
\r
        BinariesItem = XmlNode(Item, '%s/Binaries' % Key)\r
        Tmp = UserExtensionBinaryXml()\r
        BinariesDict = Tmp.FromXml(BinariesItem, 'Binaries')\r
        self.BinariesDict = BinariesDict\r
\r
        self.Statement = XmlElement(Item, 'UserExtensions')\r
        SupArch = XmlAttribute(XmlNode(Item, '%s' % Key), 'SupArchList')\r
        self.SupArchList = [Arch for Arch in GetSplitValueList(SupArch, DataType.TAB_SPACE_SPLIT) if Arch]\r
\r
        UserExtension = UserExtensionObject()\r
        UserExtension.SetUserID(self.UserId)\r
        UserExtension.SetIdentifier(self.Identifier)\r
        UserExtension.SetStatement(self.Statement)\r
        UserExtension.SetSupArchList(self.SupArchList)\r
        UserExtension.SetDefinesDict(self.DefineDict)\r
        UserExtension.SetBuildOptionDict(self.BuildOptionDict)\r
        UserExtension.SetIncludesDict(self.IncludesDict)\r
        UserExtension.SetSourcesDict(self.SourcesDict)\r
        UserExtension.SetBinariesDict(self.BinariesDict)\r
\r
        return UserExtension\r
\r
    def ToXml(self, UserExtension, Key):\r
        if self.UserId:\r
            pass\r
\r
        AttributeList = [['UserId', str(UserExtension.GetUserID())],\r
                         ['Identifier', str(UserExtension.GetIdentifier())],\r
                         ['SupArchList', \\r
                          GetStringOfList(UserExtension.GetSupArchList())],\r
                        ]\r
\r
        Root = CreateXmlElement('%s' % Key, UserExtension.GetStatement(), [], \\r
                                AttributeList)\r
\r
        NodeList = []\r
        DefineDict = UserExtension.GetDefinesDict()\r
        if DefineDict:\r
            for Item in DefineDict.keys():\r
                NodeList.append(CreateXmlElement\\r
                                ('Statement', Item, [], []))\r
            DefineElement = CreateXmlElement('Define', '', NodeList, [])\r
            Root.appendChild(DefineElement)\r
\r
        NodeList = []\r
        BuildOptionDict = UserExtension.GetBuildOptionDict()\r
        if BuildOptionDict:\r
            for Item in BuildOptionDict.keys():\r
                NodeList.append(CreateXmlElement\\r
                                ('Statement', BuildOptionDict[Item], [], \\r
                                 [['SupArchList', Item]]))\r
            BuildOptionElement = \\r
            CreateXmlElement('BuildOption', '', NodeList, [])\r
            Root.appendChild(BuildOptionElement)\r
\r
        NodeList = []\r
        IncludesDict = UserExtension.GetIncludesDict()\r
        if IncludesDict:\r
            for Item in IncludesDict.keys():\r
                NodeList.append(CreateXmlElement\\r
                                ('Statement', Item, [], \\r
                                 [['SupArchList', IncludesDict[Item]]]))\r
            IncludesElement = CreateXmlElement('Includes', '', NodeList, [])\r
            Root.appendChild(IncludesElement)\r
\r
        NodeList = []\r
        SourcesDict = UserExtension.GetSourcesDict()\r
        if SourcesDict:\r
            Tmp = UserExtensionSourceXml()\r
            Root.appendChild(Tmp.ToXml(SourcesDict, 'Sources'))\r
\r
        NodeList = []\r
        BinariesDict = UserExtension.GetBinariesDict()\r
        if BinariesDict:\r
            Tmp = UserExtensionBinaryXml()\r
            Root.appendChild(Tmp.ToXml(BinariesDict, 'Binaries'))\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
##\r
# UserExtensionSourceXml\r
#\r
class UserExtensionSourceXml(object):\r
    def __init__(self):\r
        self.UserExtensionSource = ''\r
\r
    def FromXml(self, Item, Key):\r
        if Key:\r
            pass\r
        if self.UserExtensionSource:\r
            pass\r
        Dict = {}\r
\r
        #SourcesItem = XmlNode(Item, '%s/Sources' % Key)\r
        for SubItem in XmlList(Item, 'Sources/SourceFile'):\r
            FileName = XmlElement(SubItem, 'SourceFile/FileName')\r
            Family = XmlElement(SubItem, 'SourceFile/Family')\r
            FeatureFlag = XmlElement(SubItem, 'SourceFile/FeatureFlag')\r
            SupArchStr = XmlElement(SubItem, 'SourceFile/SupArchList')\r
            DictKey = (FileName, Family, FeatureFlag, SupArchStr)\r
\r
            ValueList = []\r
            for ValueNodeItem in XmlList(SubItem, \\r
                                         'SourceFile/SourceFileOtherAttr'):\r
                TagName = XmlElement(ValueNodeItem, \\r
                                     'SourceFileOtherAttr/TagName')\r
                ToolCode = XmlElement(ValueNodeItem, \\r
                                      'SourceFileOtherAttr/ToolCode')\r
                Comment = XmlElement(ValueNodeItem, \\r
                                     'SourceFileOtherAttr/Comment')\r
                if (TagName == ' ') and (ToolCode == ' ') and (Comment == ' '):\r
                    TagName = ''\r
                    ToolCode = ''\r
                    Comment = ''\r
                ValueList.append((TagName, ToolCode, Comment))\r
\r
            Dict[DictKey] = ValueList\r
\r
        return Dict\r
\r
    def ToXml(self, Dict, Key):\r
        if self.UserExtensionSource:\r
            pass\r
        SourcesNodeList = []\r
        for Item in Dict:\r
            ValueList = Dict[Item]\r
            (FileName, Family, FeatureFlag, SupArchStr) = Item\r
            SourceFileNodeList = []\r
            SourceFileNodeList.append(["FileName", FileName])\r
            SourceFileNodeList.append(["Family", Family])\r
            SourceFileNodeList.append(["FeatureFlag", FeatureFlag])\r
            SourceFileNodeList.append(["SupArchList", SupArchStr])\r
            for (TagName, ToolCode, Comment) in ValueList:\r
                ValueNodeList = []\r
                if not (TagName or ToolCode or Comment):\r
                    TagName = ' '\r
                    ToolCode = ' '\r
                    Comment = ' '\r
                ValueNodeList.append(["TagName", TagName])\r
                ValueNodeList.append(["ToolCode", ToolCode])\r
                ValueNodeList.append(["Comment", Comment])\r
                ValueNodeXml = CreateXmlElement('SourceFileOtherAttr', '', \\r
                                                ValueNodeList, [])\r
                SourceFileNodeList.append(ValueNodeXml)\r
            SourceFileNodeXml = CreateXmlElement('SourceFile', '', \\r
                                                 SourceFileNodeList, [])\r
            SourcesNodeList.append(SourceFileNodeXml)\r
        Root = CreateXmlElement('%s' % Key, '', SourcesNodeList, [])\r
        return Root\r
\r
##\r
# UserExtensionBinaryXml\r
#\r
class UserExtensionBinaryXml(object):\r
    def __init__(self):\r
        self.UserExtensionBinary = ''\r
\r
    def FromXml(self, Item, Key):\r
        if Key:\r
            pass\r
        if self.UserExtensionBinary:\r
            pass\r
\r
        Dict = {}\r
\r
        for SubItem in XmlList(Item, 'Binaries/Binary'):\r
            FileName = XmlElement(SubItem, 'Binary/FileName')\r
            FileType = XmlElement(SubItem, 'Binary/FileType')\r
            FFE = XmlElement(SubItem, 'Binary/FeatureFlag')\r
            SupArch = XmlElement(SubItem, 'Binary/SupArchList')\r
            DictKey = (FileName, FileType, ConvertNOTEQToNE(FFE), SupArch)\r
\r
            ValueList = []\r
            for ValueNodeItem in XmlList(SubItem, \\r
                                         'Binary/BinaryFileOtherAttr'):\r
                Target = XmlElement(ValueNodeItem, \\r
                                    'BinaryFileOtherAttr/Target')\r
                Family = XmlElement(ValueNodeItem, \\r
                                    'BinaryFileOtherAttr/Family')\r
                TagName = XmlElement(ValueNodeItem, \\r
                                     'BinaryFileOtherAttr/TagName')\r
                Comment = XmlElement(ValueNodeItem, \\r
                                     'BinaryFileOtherAttr/Comment')\r
                if (Target == ' ') and (Family == ' ') and \\r
                   (TagName == ' ') and (Comment == ' '):\r
                    Target = ''\r
                    Family = ''\r
                    TagName = ''\r
                    Comment = ''\r
\r
                ValueList.append((Target, Family, TagName, Comment))\r
\r
            Dict[DictKey] = ValueList\r
\r
        return Dict\r
\r
    def ToXml(self, Dict, Key):\r
        if self.UserExtensionBinary:\r
            pass\r
        BinariesNodeList = []\r
        for Item in Dict:\r
            ValueList = Dict[Item]\r
            (FileName, FileType, FeatureFlag, SupArch) = Item\r
            FileNodeList = []\r
            FileNodeList.append(["FileName", FileName])\r
            FileNodeList.append(["FileType", FileType])\r
            FileNodeList.append(["FeatureFlag", ConvertNEToNOTEQ(FeatureFlag)])\r
            FileNodeList.append(["SupArchList", SupArch])\r
            for (Target, Family, TagName, Comment) in ValueList:\r
                ValueNodeList = []\r
                if not (Target or Family or TagName or Comment):\r
                    Target = ' '\r
                    Family = ' '\r
                    TagName = ' '\r
                    Comment = ' '\r
                ValueNodeList.append(["Target", Target])\r
                ValueNodeList.append(["Family", Family])\r
                ValueNodeList.append(["TagName", TagName])\r
                ValueNodeList.append(["Comment", Comment])\r
                ValueNodeXml = CreateXmlElement('BinaryFileOtherAttr', '', \\r
                                                ValueNodeList, [])\r
                FileNodeList.append(ValueNodeXml)\r
            FileNodeXml = CreateXmlElement('Binary', '', FileNodeList, [])\r
            BinariesNodeList.append(FileNodeXml)\r
        Root = CreateXmlElement('%s' % Key, '', BinariesNodeList, [])\r
        return Root\r
\r
##\r
# LibraryClassXml\r
#\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.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 = LibraryClassObject()\r
        LibraryClass.SetLibraryClass(self.Keyword)\r
        LibraryClass.SetIncludeHeader(self.HeaderFile)\r
        if self.CommonDefines.Usage:\r
            LibraryClass.SetUsage(self.CommonDefines.Usage)\r
        LibraryClass.SetSupArchList(self.CommonDefines.SupArchList)\r
        LibraryClass.SetSupModuleList(self.CommonDefines.SupModList)\r
        LibraryClass.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))\r
        LibraryClass.SetHelpTextList(GetHelpTextList(self.HelpText))\r
\r
        return LibraryClass\r
\r
    def ToXml(self, LibraryClass, Key):\r
        if self.HeaderFile:\r
            pass\r
        AttributeList = \\r
        [['Keyword', LibraryClass.GetLibraryClass()],\r
         ['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())],\r
         ['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())]\r
         ]\r
        NodeList = [['HeaderFile', LibraryClass.GetIncludeHeader()]]\r
        for Item in LibraryClass.GetHelpTextList():\r
            Tmp = HelpTextXml()\r
            NodeList.append(Tmp.ToXml(Item))\r
\r
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)\r
\r
        return Root\r
\r
    def ToXml2(self, LibraryClass, Key):\r
        if self.HeaderFile:\r
            pass\r
\r
        FeatureFlag = ConvertNEToNOTEQ(LibraryClass.GetFeatureFlag())\r
\r
        AttributeList = \\r
        [['Usage', LibraryClass.GetUsage()], \\r
         ['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())], \\r
         ['SupModList', GetStringOfList(LibraryClass.GetSupModuleList())], \\r
         ['FeatureFlag', FeatureFlag]\r
         ]\r
        NodeList = [['Keyword', LibraryClass.GetLibraryClass()], ]\r
        for Item in LibraryClass.GetHelpTextList():\r
            Tmp = HelpTextXml()\r
            NodeList.append(Tmp.ToXml(Item))\r
\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
##\r
# FilenameXml\r
#\r
class FilenameXml(object):\r
    def __init__(self):\r
        self.FileType = ''\r
        self.Filename = ''\r
        self.CommonDefines = CommonDefinesXml()\r
\r
    def FromXml(self, Item, Key):\r
        self.FileType = XmlAttribute(Item, 'FileType')\r
        self.Filename = XmlElement(Item, 'Filename')\r
        self.CommonDefines.FromXml(Item, Key)\r
\r
        FeatureFlag = ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)\r
\r
        Filename = FileNameObject()\r
        #\r
        # Convert File Type\r
        #\r
        if self.FileType == 'UEFI_IMAGE':\r
            self.FileType = 'PE32'\r
\r
        Filename.SetFileType(self.FileType)\r
        Filename.SetFilename(self.Filename)\r
        Filename.SetSupArchList(self.CommonDefines.SupArchList)\r
        Filename.SetFeatureFlag(FeatureFlag)\r
\r
        return Filename\r
\r
    def ToXml(self, Filename, Key):\r
        if self.Filename:\r
            pass\r
        AttributeList = [['SupArchList', \\r
                          GetStringOfList(Filename.GetSupArchList())],\r
                         ['FileType', Filename.GetFileType()],\r
                         ['FeatureFlag', ConvertNEToNOTEQ(Filename.GetFeatureFlag())],\r
                        ]\r
        Root = CreateXmlElement('%s' % Key, Filename.GetFilename(), [], AttributeList)\r
\r
        return Root\r
\r
    def __str__(self):\r
        return "FileType = %s Filename = %s %s" \\r
             % (self.FileType, self.Filename, self.CommonDefines)\r