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

## @file\r
# This file is used to parse a Module file of .PKG file\r
#\r
# Copyright (c) 2011, 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
ModuleSurfaceAreaXml\r
'''\r
from xml.dom import minidom\r
\r
from Library.String import ConvertNEToNOTEQ\r
from Library.String import ConvertNOTEQToNE\r
from Library.String import GetStringOfList\r
from Library.Xml.XmlRoutines import XmlElement\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 GuidVersionObject\r
from Object.POM.ModuleObject import BootModeObject\r
from Object.POM.ModuleObject import DepexObject\r
from Object.POM.ModuleObject import ModuleObject\r
from Object.POM.ModuleObject import EventObject\r
from Object.POM.ModuleObject import HobObject\r
from Object.POM.ModuleObject import SourceFileObject\r
from Object.POM.ModuleObject import PackageDependencyObject\r
from Object.POM.ModuleObject import ExternObject\r
from Object.POM.ModuleObject import BinaryFileObject\r
from Object.POM.ModuleObject import AsBuiltObject\r
from Object.POM.ModuleObject import BinaryBuildFlagObject\r
from Xml.CommonXml import ClonedFromXml\r
from Xml.CommonXml import HeaderXml\r
from Xml.CommonXml import HelpTextXml\r
from Xml.CommonXml import CommonDefinesXml\r
from Xml.CommonXml import LibraryClassXml\r
from Xml.CommonXml import UserExtensionsXml\r
from Xml.CommonXml import MiscellaneousFileXml\r
from Xml.CommonXml import FilenameXml\r
from Xml.GuidProtocolPpiXml import GuidXml\r
from Xml.GuidProtocolPpiXml import ProtocolXml\r
from Xml.GuidProtocolPpiXml import PpiXml\r
from Xml.PcdXml import PcdEntryXml\r
from Xml.XmlParserMisc import GetHelpTextList\r
from Library import GlobalData\r
from Library.Misc import GetSplitValueList\r
\r
##   BinaryFileXml\r
#\r
#    represent the following XML item\r
#\r
#    <BinaryFile>\r
#    <Filename\r
#    FileType=" FileType " {1}\r
#    SupArchList=" ArchListType " {0,1}\r
#    FeatureFlag=" FeatureFlagExpression " {0,1} >\r
#    xs:anyURI\r
#    </Filename> {1,}\r
#    <AsBuilt> ... </AsBuilt> {0,}\r
#    </BinaryFile> {1,}\r
#    \r
class BinaryFileXml(object):\r
    def __init__(self):\r
        self.FileNames = []\r
        self.AsBuiltList = []\r
        self.PatchPcdValues = ''\r
        self.PcdExValues = ''\r
        self.LibraryInstances = ''\r
        self.BuildFlags = ''\r
\r
    def FromXml(self, Item, Key):\r
        if self.FileNames:\r
            pass\r
        BinaryFile = BinaryFileObject()\r
        FilenameList = []\r
        for SubItem in XmlList(Item, '%s/Filename' % Key):\r
            Axml = FilenameXml()\r
            Bxml = Axml.FromXml(SubItem, 'Filename')\r
            FilenameList.append(Bxml)\r
        BinaryFile.SetFileNameList(FilenameList)\r
        if GlobalData.gIS_BINARY_INF:\r
            AsBuiltList = []\r
            for AsBuiltItem in XmlList(Item, '%s/AsBuilt' % Key):\r
                AsBuilt = AsBuiltObject()\r
\r
                PatchPcdValueList = []\r
                for SubItem in XmlList(AsBuiltItem, 'AsBuilt/PatchPcdValue'):\r
                    Axml = PcdEntryXml()\r
                    Bxml = Axml.FromXml(SubItem, 'PatchPcdValue')\r
                    PatchPcdValueList.append(Bxml)\r
                AsBuilt.SetPatchPcdList(PatchPcdValueList)\r
                PcdExValueList = []\r
                for SubItem in XmlList(AsBuiltItem, 'AsBuilt/PcdExValue'):\r
                    Axml = PcdEntryXml()\r
                    Bxml = Axml.FromXml(SubItem, 'PcdExValue')\r
                    PcdExValueList.append(Bxml)\r
                AsBuilt.SetPcdExList(PcdExValueList)\r
                LibraryList = []\r
                for SubItem in XmlList(Item, '%s/AsBuilt/LibraryInstances/GUID' % Key):\r
                    GuidVerObj = GuidVersionObject()\r
                    GUID = XmlElement(SubItem, 'GUID')\r
                    Version = XmlAttribute(XmlNode(SubItem, 'GUID'), 'Version')\r
                    GuidVerObj.SetGuid(GUID)\r
                    GuidVerObj.SetVersion(Version)\r
                    LibraryList.append(GuidVerObj)\r
                if XmlList(Item, '%s/AsBuilt/LibraryInstances' % Key) and not LibraryList:\r
                    LibraryList = [None]\r
                AsBuilt.SetLibraryInstancesList(LibraryList)\r
                BuildFlagList = []\r
                for SubItem in XmlList(Item, '%s/AsBuilt/BuildFlags' % Key):\r
                    BuildFlag = BuildFlagXml()\r
                    BuildFlagList.append(BuildFlag.FromXml2(SubItem, 'BuildFlags'))\r
                AsBuilt.SetBuildFlagsList(BuildFlagList)\r
                AsBuiltList.append(AsBuilt)\r
            BinaryFile.SetAsBuiltList(AsBuiltList)\r
        return BinaryFile\r
\r
    def ToXml(self, BinaryFile, Key):\r
        if self.FileNames:\r
            pass\r
        NodeList = []\r
        FilenameList = BinaryFile.GetFileNameList()\r
        for Filename in FilenameList:\r
            Tmp = FilenameXml()\r
            NodeList.append(Tmp.ToXml(Filename, 'Filename'))\r
\r
        if GlobalData.gIS_BINARY_INF:\r
            AsBuildList = BinaryFile.GetAsBuiltList()\r
            PatchPcdValueList = AsBuildList.GetPatchPcdList()\r
            PcdExList = AsBuildList.GetPcdExList()\r
            LibGuidVerList = AsBuildList.GetLibraryInstancesList()\r
            BuildFlagList = AsBuildList.GetBuildFlagsList()\r
\r
            AsBuiltNodeList = []\r
\r
            for Pcd in PatchPcdValueList:\r
                Tmp = PcdEntryXml()\r
                AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PatchPcdValue'))\r
\r
            for Pcd in PcdExList:\r
                Tmp = PcdEntryXml()\r
                AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PcdExValue'))\r
\r
            GuiVerElemList = []\r
            for LibGuidVer in LibGuidVerList:\r
                GuiVerElem = \\r
                CreateXmlElement('GUID', LibGuidVer.GetLibGuid(), [], [['Version', LibGuidVer.GetLibVersion()]])\r
                GuiVerElemList.append(GuiVerElem)\r
            if len(GuiVerElemList) > 0:\r
                LibGuidVerElem = CreateXmlElement('LibraryInstances', '', GuiVerElemList, [])\r
                AsBuiltNodeList.append(LibGuidVerElem)\r
\r
            for BuildFlag in BuildFlagList:\r
                Tmp = BuildFlagXml()\r
                Elem = CreateXmlElement('BuildFlags', ''.join(BuildFlag), [], [])\r
                AsBuiltNodeList.append(Elem)\r
\r
            if len(AsBuiltNodeList) > 0:\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
##\r
# PackageXml\r
#\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 = PackageDependencyObject()\r
        PackageDependency.SetPackage(self.Description)\r
        PackageDependency.SetGuid(self.Guid)\r
        PackageDependency.SetVersion(self.Version)\r
        PackageDependency.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))\r
        PackageDependency.SetSupArchList(self.CommonDefines.SupArchList)\r
\r
        return PackageDependency\r
\r
    def ToXml(self, PackageDependency, Key):\r
        if self.Guid:\r
            pass\r
        AttributeList = [['SupArchList', GetStringOfList(PackageDependency.GetSupArchList())],\r
                         ['FeatureFlag', ConvertNEToNOTEQ(PackageDependency.GetFeatureFlag())], ]\r
        Element1 = CreateXmlElement('GUID', PackageDependency.GetGuid(), [],\r
                                    [['Version', PackageDependency.GetVersion()]])\r
        NodeList = [['Description', PackageDependency.GetPackage()], Element1, ]\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
#\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.SupModList = ''\r
        self.SupArchList = ''\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
\r
        Extern = ExternObject()\r
        Extern.SetEntryPoint(self.EntryPoint)\r
        Extern.SetUnloadImage(self.UnloadImage)\r
        Extern.SetConstructor(self.Constructor)\r
        Extern.SetDestructor(self.Destructor)\r
        if self.CommonDefines.SupModList:\r
            Extern.SetSupModList(self.CommonDefines.SupModList)\r
        if self.CommonDefines.SupArchList:\r
            Extern.SetSupArchList(self.CommonDefines.SupArchList)\r
        return Extern\r
\r
    def ToXml(self, Extern, Key):\r
        if self.HelpText:\r
            pass\r
\r
        NodeList = []\r
        if Extern.GetEntryPoint():\r
            NodeList.append(['EntryPoint', Extern.GetEntryPoint()])\r
        if Extern.GetUnloadImage():\r
            NodeList.append(['UnloadImage', Extern.GetUnloadImage()])\r
        if Extern.GetConstructor():\r
            NodeList.append(['Constructor', Extern.GetConstructor()])\r
        if Extern.GetDestructor():\r
            NodeList.append(['Destructor', Extern.GetDestructor()])\r
        Root = CreateXmlElement('%s' % Key, '', NodeList, [])\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
##    \r
# DepexXml\r
#\r
class DepexXml(object):\r
    def __init__(self):\r
        self.CommonDefines = CommonDefinesXml()\r
        self.Expression = None\r
        self.HelpText = []\r
\r
    def FromXml(self, Item, Key):\r
        if not Item:\r
            return None\r
        self.CommonDefines.FromXml(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 = DepexObject()\r
        Depex.SetDepex(self.Expression)\r
        Depex.SetModuleType(self.CommonDefines.SupModList)\r
        Depex.SetSupArchList(self.CommonDefines.SupArchList)\r
        Depex.SetFeatureFlag(self.CommonDefines.FeatureFlag)\r
        Depex.SetHelpTextList(GetHelpTextList(self.HelpText))\r
\r
        return Depex\r
\r
    def ToXml(self, Depex, Key):\r
        if self.HelpText:\r
            pass\r
        AttributeList = [['SupArchList', GetStringOfList(Depex.GetSupArchList())],\r
                         ['SupModList', Depex.GetModuleType()]]\r
        NodeList = [['Expression', Depex.GetDepex()]]\r
        if Depex.GetHelpText():\r
            Tmp = HelpTextXml()\r
            NodeList.append(Tmp.ToXml(Depex.GetHelpText(), 'HelpText'))\r
\r
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)\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
##\r
# BootModeXml\r
#\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 = \\r
        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 = BootModeObject()\r
        BootMode.SetSupportedBootModes(self.SupportedBootModes)\r
        BootMode.SetUsage(self.CommonDefines.Usage)\r
        BootMode.SetHelpTextList(GetHelpTextList(self.HelpText))\r
\r
        return BootMode\r
\r
    def ToXml(self, BootMode, Key):\r
        if self.HelpText:\r
            pass\r
        AttributeList = [['Usage', BootMode.GetUsage()], ]\r
        NodeList = [['SupportedBootModes', BootMode.GetSupportedBootModes()]]\r
        for Item in BootMode.GetHelpTextList():\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
#\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 = EventObject()\r
        Event.SetEventType(self.EventType)\r
        Event.SetUsage(self.CommonDefines.Usage)\r
        Event.SetHelpTextList(GetHelpTextList(self.HelpText))\r
\r
        return Event\r
\r
    def ToXml(self, Event, Key):\r
        if self.HelpText:\r
            pass\r
        AttributeList = [['EventType', Event.GetEventType()],\r
                         ['Usage', Event.GetUsage()],\r
                        ]\r
        NodeList = []\r
        for Item in Event.GetHelpTextList():\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 = "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
#\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 = HobObject()\r
        Hob.SetHobType(self.HobType)\r
        Hob.SetSupArchList(self.CommonDefines.SupArchList)\r
        Hob.SetUsage(self.CommonDefines.Usage)\r
        Hob.SetHelpTextList(GetHelpTextList(self.HelpText))\r
\r
        return Hob\r
\r
    def ToXml(self, Hob, Key):\r
        if self.Name:\r
            pass\r
        AttributeList = [['HobType', Hob.GetHobType()],\r
                         ['Usage', Hob.GetUsage()],\r
                         ['SupArchList', GetStringOfList(Hob.GetSupArchList())], ]\r
        NodeList = []\r
        for Item in Hob.GetHelpTextList():\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 = "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
##\r
# SourceFileXml\r
#\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.SourceFile = XmlElement(Item, 'Filename')\r
        self.CommonDefines.FromXml(Item, Key)\r
\r
        self.CommonDefines.FeatureFlag = ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)\r
\r
        SourceFile = SourceFileObject()\r
        SourceFile.SetSourceFile(self.SourceFile)\r
        SourceFile.SetFamily(self.ToolChainFamily)\r
        SourceFile.SetSupArchList(self.CommonDefines.SupArchList)\r
        SourceFile.SetFeatureFlag(self.CommonDefines.FeatureFlag)\r
\r
        return SourceFile\r
\r
    def ToXml(self, SourceFile, Key):\r
        if self.SourceFile:\r
            pass\r
        FeatureFlag = ConvertNEToNOTEQ(SourceFile.GetFeatureFlag())\r
        AttributeList = [['SupArchList', GetStringOfList(SourceFile.GetSupArchList())],\r
                         ['Family', SourceFile.GetFamily()],\r
                         ['FeatureFlag', FeatureFlag], ]\r
        Root = CreateXmlElement('%s' % Key, SourceFile.GetSourceFile(), [], AttributeList)\r
        return Root\r
\r
##\r
# ModulePropertyXml\r
#\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.SpecificationList = []\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
        for SubItem in XmlList(Item, '%s/Specification' % Key):\r
            Specification = XmlElement(SubItem, '/Specification')\r
            Version = XmlAttribute(XmlNode(SubItem, '/Specification'), 'Version')\r
            self.SpecificationList.append((Specification, Version))\r
        for SubItem in XmlList(Item, '%s/BootMode' % Key):\r
            Axml = BootModeXml()\r
            BootMode = Axml.FromXml(SubItem, 'BootMode')\r
            self.BootModes.append(BootMode)\r
        for SubItem in XmlList(Item, '%s/Event' % Key):\r
            Axml = EventXml()\r
            Event = Axml.FromXml(SubItem, 'Event')\r
            self.Events.append(Event)\r
        for SubItem in XmlList(Item, '%s/HOB' % Key):\r
            Axml = HobXml()\r
            Hob = Axml.FromXml(SubItem, 'HOB')\r
            self.HOBs.append(Hob)\r
\r
        if Header == None:\r
            Header = ModuleObject()\r
\r
        Header.SetModuleType(self.ModuleType)\r
        Header.SetSupArchList(self.CommonDefines.SupArchList)\r
        Header.SetModulePath(self.Path)\r
\r
        Header.SetPcdIsDriver(self.PcdIsDriver)\r
        Header.SetUefiSpecificationVersion(self.UefiSpecificationVersion)\r
        Header.SetPiSpecificationVersion(self.PiSpecificationVersion)\r
        Header.SetSpecList(self.SpecificationList)\r
\r
        return Header, self.BootModes, self.Events, self.HOBs\r
\r
\r
    def ToXml(self, Header, BootModes, Events, Hobs, Key):\r
        if self.ModuleType:\r
            pass\r
        AttributeList = [['SupArchList', GetStringOfList(Header.GetSupArchList())], ]\r
\r
        NodeList = [['ModuleType', Header.GetModuleType()],\r
                    ['Path', Header.GetModulePath()],\r
                    ['PcdIsDriver', Header.GetPcdIsDriver()],\r
                    ['UefiSpecificationVersion', Header.GetUefiSpecificationVersion()],\r
                    ['PiSpecificationVersion', Header.GetPiSpecificationVersion()],\r
                   ]\r
        for Item in Header.GetSpecList():\r
            Spec, Version = Item\r
            SpecElem = CreateXmlElement('Specification', Spec, [], [['Version', Version]])\r
            NodeList.append(SpecElem)\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 \\r
               Specification = %s SpecificationVersion = %s %s" % \\r
        (self.ModuleType, self.Path, self.PcdIsDriver, \\r
         self.UefiSpecificationVersion, self.PiSpecificationVersion, \\r
         self.SpecificationList, 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
##\r
# ModuleXml\r
#\r
class ModuleSurfaceAreaXml(object):\r
    def __init__(self, Package=''):\r
        self.Module = None\r
        #\r
        # indicate the package that this module resides in\r
        #\r
        self.Package = Package\r
\r
    def FromXml2(self, Item, Module):\r
        if self.Module:\r
            pass\r
        #\r
        # PeiDepex\r
        #\r
        PeiDepexList = []\r
        for SubItem in XmlList(Item, '/ModuleSurfaceArea/PeiDepex'):\r
            Tmp = DepexXml()\r
            Depex = Tmp.FromXml(XmlNode(SubItem, 'PeiDepex'), 'PeiDepex')\r
            PeiDepexList.append(Depex)\r
        Module.SetPeiDepex(PeiDepexList)\r
\r
        #\r
        # DxeDepex\r
        #\r
        DxeDepexList = []\r
        for SubItem in XmlList(Item, '/ModuleSurfaceArea/DxeDepex'):\r
            Tmp = DepexXml()\r
            Depex = Tmp.FromXml(XmlNode(SubItem, 'DxeDepex'), 'DxeDepex')\r
            DxeDepexList.append(Depex)\r
        Module.SetDxeDepex(DxeDepexList)\r
\r
        #\r
        # SmmDepex\r
        #\r
        SmmDepexList = []\r
        for SubItem in XmlList(Item, '/ModuleSurfaceArea/SmmDepex'):\r
            Tmp = DepexXml()\r
            Depex = Tmp.FromXml(XmlNode(SubItem, 'SmmDepex'), 'SmmDepex')\r
            SmmDepexList.append(Depex)\r
        Module.SetSmmDepex(SmmDepexList)\r
\r
        #\r
        # MiscellaneousFile\r
        Tmp = MiscellaneousFileXml()\r
        MiscFileList = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/MiscellaneousFiles'), 'MiscellaneousFiles')\r
        if MiscFileList:\r
            Module.SetMiscFileList([MiscFileList])\r
        else:\r
            Module.SetMiscFileList([])\r
\r
        #           \r
        # UserExtensions\r
        #\r
        for Item in XmlList(Item, '/ModuleSurfaceArea/UserExtensions'):\r
            Tmp = UserExtensionsXml()\r
            UserExtension = Tmp.FromXml(Item, 'UserExtensions')\r
            Module.SetUserExtensionList(Module.GetUserExtensionList() + [UserExtension])\r
\r
        return Module\r
\r
    def FromXml(self, Item, Key, IsStandAlongModule=False):\r
        IsBinaryModule = XmlAttribute(Item, 'BinaryModule')\r
        #\r
        # Header\r
        #\r
        Tmp = HeaderXml()\r
        Module = Tmp.FromXml(XmlNode(Item, '/%s/Header' % Key), 'Header', True, IsStandAlongModule)\r
        Module.SetBinaryModule(IsBinaryModule)\r
\r
        if IsBinaryModule:\r
            GlobalData.gIS_BINARY_INF = True\r
\r
        #\r
        # ModuleProperties\r
        #\r
        Tmp = ModulePropertyXml()\r
        (Module, BootModes, Events, HOBs) = \\r
        Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ModuleProperties'), 'ModuleProperties', Module)\r
        Module.SetBootModeList(BootModes)\r
        Module.SetEventList(Events)\r
        Module.SetHobList(HOBs)\r
        #\r
        # ClonedFrom\r
        #\r
        Tmp = ClonedFromXml()\r
        ClonedFrom = Tmp.FromXml(XmlNode(Item, '/ModuleSurfaceArea/ClonedFrom'), 'ClonedFrom')\r
        if ClonedFrom:\r
            Module.SetClonedFrom(ClonedFrom)\r
\r
        #\r
        # LibraryClass\r
        #\r
        for SubItem in XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass'):\r
            Tmp = LibraryClassXml()\r
            LibraryClass = Tmp.FromXml(SubItem, 'LibraryClass')\r
            Module.SetLibraryClassList(Module.GetLibraryClassList() + [LibraryClass])\r
\r
        if XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions') and \\r
           not XmlList(Item, '/ModuleSurfaceArea/LibraryClassDefinitions/LibraryClass'):\r
            Module.SetLibraryClassList([None])\r
\r
        #\r
        # SourceFiles\r
        #\r
        for SubItem in XmlList(Item, '/ModuleSurfaceArea/SourceFiles/Filename'):\r
            Tmp = SourceFileXml()\r
            SourceFile = Tmp.FromXml(SubItem, 'Filename')\r
            Module.SetSourceFileList(Module.GetSourceFileList() + [SourceFile])\r
\r
        if XmlList(Item, '/ModuleSurfaceArea/SourceFiles') and \\r
           not XmlList(Item, '/ModuleSurfaceArea/SourceFiles/Filename') :\r
            Module.SetSourceFileList([None])\r
\r
        #\r
        # BinaryFile\r
        #\r
        for SubItem in XmlList(Item, '/ModuleSurfaceArea/BinaryFiles/BinaryFile'):\r
            Tmp = BinaryFileXml()\r
            BinaryFile = Tmp.FromXml(SubItem, 'BinaryFile')\r
            Module.SetBinaryFileList(Module.GetBinaryFileList() + [BinaryFile])\r
\r
        if XmlList(Item, '/ModuleSurfaceArea/BinaryFiles') and \\r
           not XmlList(Item, '/ModuleSurfaceArea/BinaryFiles/BinaryFile') :\r
            Module.SetBinaryFileList([None])\r
        #\r
        # PackageDependencies\r
        #\r
        for SubItem in XmlList(Item, '/ModuleSurfaceArea/PackageDependencies/Package'):\r
            Tmp = PackageXml()\r
            PackageDependency = Tmp.FromXml(SubItem, 'Package')\r
            Module.SetPackageDependencyList(Module.GetPackageDependencyList() + [PackageDependency])\r
\r
        if XmlList(Item, '/ModuleSurfaceArea/PackageDependencies') and \\r
           not XmlList(Item, '/ModuleSurfaceArea/PackageDependencies/Package'):\r
            Module.SetPackageDependencyList([None])\r
\r
        # \r
        # Guid\r
        #\r
        for SubItem in XmlList(Item, '/ModuleSurfaceArea/Guids/GuidCName'):\r
            Tmp = GuidXml('Module')\r
            GuidProtocolPpi = Tmp.FromXml(SubItem, 'GuidCName')\r
            Module.SetGuidList(Module.GetGuidList() + [GuidProtocolPpi])\r
\r
        if XmlList(Item, '/ModuleSurfaceArea/Guids') and not XmlList(Item, '/ModuleSurfaceArea/Guids/GuidCName'):\r
            Module.SetGuidList([None])\r
\r
        #\r
        # Protocol\r
        #\r
        for SubItem in XmlList(Item, '/ModuleSurfaceArea/Protocols/Protocol'):\r
            Tmp = ProtocolXml('Module')\r
            GuidProtocolPpi = Tmp.FromXml(SubItem, 'Protocol')\r
            Module.SetProtocolList(Module.GetProtocolList() + [GuidProtocolPpi])\r
\r
        if XmlList(Item, '/ModuleSurfaceArea/Protocols') and not XmlList(Item, '/ModuleSurfaceArea/Protocols/Protocol'):\r
            Module.SetProtocolList([None])\r
\r
        #\r
        # Ppi\r
        #\r
        for SubItem in XmlList(Item, '/ModuleSurfaceArea/PPIs/Ppi'):\r
            Tmp = PpiXml('Module')\r
            GuidProtocolPpi = Tmp.FromXml(SubItem, 'Ppi')\r
            Module.SetPpiList(Module.GetPpiList() + [GuidProtocolPpi])\r
\r
        if XmlList(Item, '/ModuleSurfaceArea/PPIs') and not XmlList(Item, '/ModuleSurfaceArea/PPIs/Ppi'):\r
            Module.SetPpiList([None])\r
\r
        #\r
        # Extern\r
        #\r
        for SubItem in XmlList(Item, '/ModuleSurfaceArea/Externs/Extern'):\r
            Tmp = ExternXml()\r
            Extern = Tmp.FromXml(SubItem, 'Extern')\r
            Module.SetExternList(Module.GetExternList() + [Extern])\r
\r
        if XmlList(Item, '/ModuleSurfaceArea/Externs') and not XmlList(Item, '/ModuleSurfaceArea/Externs/Extern'):\r
            Module.SetExternList([None])\r
\r
        if not Module.GetBinaryModule():\r
            #\r
            # PcdCoded\r
            #\r
            for SubItem in XmlList(Item, '/ModuleSurfaceArea/PcdCoded/PcdEntry'):\r
                Tmp = PcdEntryXml()\r
                PcdEntry = Tmp.FromXml3(SubItem, 'PcdEntry')\r
                Module.SetPcdList(Module.GetPcdList() + [PcdEntry])\r
\r
            if XmlList(Item, '/ModuleSurfaceArea/PcdCoded') and \\r
                not XmlList(Item, '/ModuleSurfaceArea/PcdCoded/PcdEntry'):\r
                Module.SetPcdList([None])\r
\r
        Module = self.FromXml2(Item, Module)\r
        #\r
        # return the module object\r
        #\r
        self.Module = Module\r
        return self.Module\r
\r
    def ToXml(self, Module):\r
        if self.Package:\r
            pass\r
        #\r
        # Create root node of module surface area\r
        #\r
        DomModule = minidom.Document().createElement('ModuleSurfaceArea')\r
        if Module.GetBinaryModule():\r
            DomModule.setAttribute('BinaryModule', 'true')\r
\r
        #\r
        # Header\r
        #\r
        Tmp = HeaderXml()\r
        DomModule.appendChild(Tmp.ToXml(Module, 'Header'))\r
        #\r
        # ModuleProperties\r
        #\r
        Tmp = ModulePropertyXml()\r
        DomModule.appendChild(Tmp.ToXml(Module, Module.GetBootModeList(), Module.GetEventList(), Module.GetHobList(), \\r
                                        'ModuleProperties'))\r
        #\r
        # ClonedFrom\r
        #\r
        Tmp = ClonedFromXml()\r
        if Module.GetClonedFrom():\r
            DomModule.appendChild(Tmp.ToXml(Module.GetClonedFrom(), 'ClonedFrom'))\r
        #\r
        # LibraryClass\r
        #\r
        LibraryClassNode = CreateXmlElement('LibraryClassDefinitions', '', [], [])\r
        for LibraryClass in Module.GetLibraryClassList():\r
            Tmp = LibraryClassXml()\r
            LibraryClassNode.appendChild(Tmp.ToXml2(LibraryClass, 'LibraryClass'))\r
        DomModule.appendChild(LibraryClassNode)\r
        #\r
        # SourceFile\r
        #\r
        SourceFileNode = CreateXmlElement('SourceFiles', '', [], [])\r
        for SourceFile in Module.GetSourceFileList():\r
            Tmp = SourceFileXml()\r
            SourceFileNode.appendChild(Tmp.ToXml(SourceFile, 'Filename'))\r
        DomModule.appendChild(SourceFileNode)\r
        #\r
        # BinaryFile\r
        #\r
        BinaryFileNode = CreateXmlElement('BinaryFiles', '', [], [])\r
        for BinaryFile in Module.GetBinaryFileList():\r
            Tmp = BinaryFileXml()\r
            BinaryFileNode.appendChild(Tmp.ToXml(BinaryFile, 'BinaryFile'))\r
        DomModule.appendChild(BinaryFileNode)\r
        #\r
        # PackageDependencies\r
        #\r
        PackageDependencyNode = CreateXmlElement('PackageDependencies', '', [], [])\r
        for PackageDependency in Module.GetPackageDependencyList():\r
            Tmp = PackageXml()\r
            PackageDependencyNode.appendChild(Tmp.ToXml(PackageDependency, 'Package'))\r
        DomModule.appendChild(PackageDependencyNode)\r
\r
        #\r
        # Guid\r
        #\r
        GuidProtocolPpiNode = CreateXmlElement('Guids', '', [], [])\r
        for GuidProtocolPpi in Module.GetGuidList():\r
            Tmp = GuidXml('Module')\r
            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'GuidCName'))\r
        DomModule.appendChild(GuidProtocolPpiNode)\r
\r
        #\r
        # Protocol\r
        #\r
        GuidProtocolPpiNode = CreateXmlElement('Protocols', '', [], [])\r
        for GuidProtocolPpi in Module.GetProtocolList():\r
            Tmp = ProtocolXml('Module')\r
            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Protocol'))\r
        DomModule.appendChild(GuidProtocolPpiNode)\r
\r
        #\r
        # Ppi\r
        #\r
        GuidProtocolPpiNode = CreateXmlElement('PPIs', '', [], [])\r
        for GuidProtocolPpi in Module.GetPpiList():\r
            Tmp = PpiXml('Module')\r
            GuidProtocolPpiNode.appendChild(Tmp.ToXml(GuidProtocolPpi, 'Ppi'))\r
        DomModule.appendChild(GuidProtocolPpiNode)\r
        #\r
        # Extern\r
        #\r
        ExternNode = CreateXmlElement('Externs', '', [], [])\r
        for Extern in Module.GetExternList():\r
            Tmp = ExternXml()\r
            ExternNode.appendChild(Tmp.ToXml(Extern, 'Extern'))\r
        DomModule.appendChild(ExternNode)\r
        #\r
        # PcdCoded\r
        #\r
        PcdEntryNode = CreateXmlElement('PcdCoded', '', [], [])\r
        for PcdEntry in Module.GetPcdList():\r
            Tmp = PcdEntryXml()\r
            PcdEntryNode.appendChild(Tmp.ToXml3(PcdEntry, 'PcdEntry'))\r
        DomModule.appendChild(PcdEntryNode)\r
\r
        #\r
        # PeiDepex\r
        #\r
        if Module.GetPeiDepex():\r
            for Item in Module.GetPeiDepex():\r
                Tmp = DepexXml()\r
                DomModule.appendChild(Tmp.ToXml(Item, 'PeiDepex'))\r
\r
        #\r
        # DxeDepex\r
        #\r
        if Module.GetDxeDepex():\r
            for Item in Module.GetDxeDepex():\r
                Tmp = DepexXml()\r
                DomModule.appendChild(Tmp.ToXml(Item, 'DxeDepex'))\r
\r
        #\r
        # SmmDepex\r
        #\r
        if Module.GetSmmDepex():\r
            for Item in Module.GetSmmDepex():\r
                Tmp = DepexXml()\r
                DomModule.appendChild(Tmp.ToXml(Item, 'SmmDepex'))\r
\r
        #\r
        # MiscellaneousFile\r
        #\r
        if Module.GetMiscFileList():\r
            Tmp = MiscellaneousFileXml()\r
            DomModule.appendChild(Tmp.ToXml(Module.GetMiscFileList()[0], 'MiscellaneousFiles'))\r
        #\r
        # UserExtensions\r
        #\r
        if Module.GetUserExtensionList():\r
            for UserExtension in Module.GetUserExtensionList():\r
                Tmp = UserExtensionsXml()\r
                DomModule.appendChild(Tmp.ToXml(UserExtension, 'UserExtensions'))\r
\r
        return DomModule\r
\r
##\r
# BuildFlagXml used to generate BuildFlag for <AsBuilt>\r
#\r
class BuildFlagXml(object):\r
    def __init__(self):\r
        self.Target = ''\r
        self.TagName = ''\r
        self.Family = ''\r
        self.AsBuiltFlags = ''\r
\r
    def FromXml(self, Item, Key):\r
        self.Target = XmlElement(Item, '%s/Target' % Key)\r
        self.TagName = XmlElement(Item, '%s/TagName' % Key)\r
        self.Family = XmlElement(Item, '%s/Family' % Key)\r
\r
        BuildFlag = BinaryBuildFlagObject()\r
\r
        BuildFlag.SetTarget(self.Target)\r
        BuildFlag.SetTagName(self.TagName)\r
        BuildFlag.SetFamily(self.Family)\r
\r
        return BuildFlag\r
\r
    #\r
    # For AsBuild INF usage\r
    #\r
    def FromXml2(self, Item, Key):\r
        self.AsBuiltFlags = XmlElement(Item, '%s' % Key)\r
\r
        LineList = GetSplitValueList(self.AsBuiltFlags, '\n')\r
        ReturnLine = ''\r
        Count = 0\r
        for Line in LineList:\r
            if Count == 0:\r
                ReturnLine = "# " + Line\r
            else:\r
                ReturnLine = ReturnLine + '\n' + '# ' + Line\r
            Count += 1\r
\r
        BuildFlag = BinaryBuildFlagObject()\r
        BuildFlag.SetAsBuiltOptionFlags(ReturnLine)\r
\r
        return BuildFlag\r
\r
    def ToXml(self, BuildFlag, Key):\r
        if self.Target:\r
            pass\r
        AttributeList = []\r
        NodeList = []\r
        NodeList.append(['BuildFlags', BuildFlag])\r
\r
        Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)\r
        return Root\r