[mirror_edk2.git] / BaseTools / Source / Python / UPT / PomAdapter / InfPomAlignment.py

## @file InfPomAlignment.py\r
# This file contained the adapter for convert INF parser object to POM Object\r
#\r
# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>\r
#\r
# SPDX-License-Identifier: BSD-2-Clause-Patent\r
#\r
'''\r
InfPomAlignment\r
'''\r
##\r
# Import modules\r
#\r
import os.path\r
from Logger import StringTable as ST\r
import Logger.Log as Logger\r
from Library.StringUtils import FORMAT_INVALID\r
from Library.StringUtils import PARSER_ERROR\r
from Library.StringUtils import NormPath\r
from Library.StringUtils import GetSplitValueList\r
from Library.Misc import ConvertVersionToDecimal\r
from Library.Misc import GetHelpStringByRemoveHashKey\r
from Library.Misc import ConvertArchList\r
from Library.Misc import GetRelativePath\r
from Library.Misc import PathClass\r
from Library.Parsing import GetPkgInfoFromDec\r
from Library.UniClassObject import UniFileClassObject\r
from Library.UniClassObject import ConvertSpecialUnicodes\r
from Library.UniClassObject import GetLanguageCode1766\r
from Library import DataType as DT\r
from Library import GlobalData\r
from Library.ParserValidate import IsValidPath\r
from Object.POM import CommonObject\r
from Object.POM.ModuleObject import ModuleObject\r
from Object.POM.ModuleObject import ExternObject\r
from Object.POM.ModuleObject import HobObject\r
from Object.POM.ModuleObject import EventObject\r
from Object.POM.ModuleObject import BootModeObject\r
from Object.POM.ModuleObject import PackageDependencyObject\r
from Object.POM.ModuleObject import SourceFileObject\r
from Object.POM.ModuleObject import DepexObject\r
from Object.POM.ModuleObject import AsBuildLibraryClassObject\r
from Object.POM.ModuleObject import AsBuiltObject\r
from PomAdapter.InfPomAlignmentMisc import GenModuleHeaderUserExt\r
from PomAdapter.InfPomAlignmentMisc import GenBinaryData\r
from Parser import InfParser\r
from PomAdapter.DecPomAlignment import DecPomAlignment\r
from Common.MultipleWorkspace import MultipleWorkspace as mws\r
\r
## InfPomAlignment\r
#\r
# Inherit from ModuleObject\r
#\r
class InfPomAlignment(ModuleObject):\r
    ## Construct of InfPomAlignment\r
    # Skip means that UPT don't care the syntax of INF, this may be the not\r
    # distributed INF files during creation or the INF files checked for\r
    # dependency rule during remove.\r
    #\r
    def __init__(self, FileName, WorkSpace=None, PackagePath='', Skip=False):\r
        ModuleObject.__init__(self)\r
        self.Parser = None\r
        self.FileName = FileName\r
        self.WorkSpace = WorkSpace\r
        self.CombinePath = ''\r
        self.LibModuleTypeList = []\r
        self.FullPath = ''\r
        self.ModulePath = ''\r
        self.WorkspaceDir = " "\r
        self.CustomMakefile = []\r
        self.UniFileClassObject = None\r
        self.SetPackagePath(PackagePath)\r
        #\r
        # Call GenInfPomObjects function to fill POM object.\r
        #\r
        if Skip:\r
            OrigConfig = Logger.SUPRESS_ERROR\r
            Logger.SUPRESS_ERROR = True\r
            try:\r
                self._GenInfPomObjects(Skip)\r
            finally:\r
                Logger.SUPRESS_ERROR = OrigConfig\r
        else:\r
            self._GenInfPomObjects(Skip)\r
\r
    ##\r
    # Generate all POM objects, the original input comes\r
    # from INF parser's output\r
    #\r
    def _GenInfPomObjects(self, Skip):\r
        #\r
        # Call INF Parser to get information from INF file\r
        #\r
        self.Parser = InfParser.InfParser(self.FileName, self.WorkSpace)\r
        self.FullPath = self.Parser.FullPath\r
        self.GetFullPath()\r
        self._GenModuleHeader()\r
        #\r
        # Call GenBinaries after Module Header for Binary INF consideration.\r
        #\r
        self._GenBinaries()\r
        self._GenBuildOptions()\r
        self._GenLibraryClasses()\r
        self._GenPackages(Skip)\r
        self._GenPcds()\r
        self._GenSources()\r
        self._GenUserExtensions()\r
        self._GenGuidProtocolPpis(DT.TAB_GUIDS)\r
        self._GenGuidProtocolPpis(DT.TAB_PROTOCOLS)\r
        self._GenGuidProtocolPpis(DT.TAB_PPIS)\r
        self._GenDepexes()\r
\r
    ## Convert [Defines] section content to InfDefObject\r
    #\r
    # Convert [Defines] section content to InfDefObject\r
    #\r
    # @param Defines        The content under [Defines] section\r
    # @param ModuleHeader   An object of ModuleHeaderClass\r
    # @param Arch           The supported ARCH\r
    #\r
    def _GenModuleHeader(self):\r
        Logger.Debug(2, "Generate ModuleHeader ...")\r
        #\r
        # Get all defines information form InfParser Object\r
        #\r
        RecordSet = self.Parser.InfDefSection.Defines\r
        #\r
        # Should only have one ArchString Item.\r
        #\r
        ArchString = list(RecordSet.keys())[0]\r
        ArchList = GetSplitValueList(ArchString, ' ')\r
        ArchList = ConvertArchList(ArchList)\r
        HasCalledFlag = False\r
        #\r
        # Get data from Sdict()\r
        #\r
        ValueList = RecordSet[ArchString]\r
        self.SetFileName(self.FileName)\r
        self.SetFullPath(self.FullPath)\r
        #\r
        # The INF's filename (without the directory path or the extension)\r
        # must be used for the value of the\r
        # ModuleSurfaceArea.Header.Name element\r
        #\r
        self.SetName(os.path.splitext(os.path.basename(self.FileName))[0])\r
        self.WorkspaceDir = " "\r
        #\r
        # CombinePath and ModulePath\r
        #\r
        CombinePath = GetRelativePath(self.FullPath, self.WorkSpace)\r
        self.SetCombinePath(CombinePath)\r
        ModulePath = os.path.split(CombinePath)[0]\r
        ModuleRelativePath = ModulePath\r
        if self.GetPackagePath() != '':\r
            ModuleRelativePath = GetRelativePath(ModulePath, self.GetPackagePath())\r
        self.SetModulePath(ModuleRelativePath)\r
        #\r
        # For Define Seciton Items.\r
        #\r
        DefineObj = ValueList\r
        #\r
        # Convert UEFI/PI version to decimal number\r
        #\r
        if DefineObj.GetUefiSpecificationVersion() is not None:\r
            __UefiVersion = DefineObj.GetUefiSpecificationVersion().GetValue()\r
            __UefiVersion = ConvertVersionToDecimal(__UefiVersion)\r
            self.SetUefiSpecificationVersion(str(__UefiVersion))\r
        if DefineObj.GetPiSpecificationVersion() is not None:\r
            __PiVersion = DefineObj.GetPiSpecificationVersion().GetValue()\r
            __PiVersion = ConvertVersionToDecimal(__PiVersion)\r
\r
            self.SetPiSpecificationVersion(str(__PiVersion))\r
        SpecList = DefineObj.GetSpecification()\r
        NewSpecList = []\r
        for SpecItem in SpecList:\r
            NewSpecList.append((SpecItem[0], ConvertVersionToDecimal(SpecItem[1])))\r
        self.SetSpecList(NewSpecList)\r
\r
        #\r
        # must exist items in INF define section\r
        # MODULE_TYPE/BASE_NAME/INF_VERSION/FILE_GUID/VERSION_STRING\r
        #\r
        if DefineObj.GetModuleType() is None:\r
            Logger.Error("InfParser", FORMAT_INVALID,\r
                         ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("MODULE_TYPE"), File=self.FullPath)\r
        else:\r
            self.SetModuleType(DefineObj.GetModuleType().GetValue())\r
            ModuleType = DefineObj.GetModuleType().GetValue()\r
            if ModuleType:\r
                #\r
                # Drivers and applications are not allowed to have a MODULE_TYPE of "BASE". Only\r
                # libraries are permitted to a have a MODULE_TYPE of "BASE".\r
                #\r
                if len(DefineObj.LibraryClass) == 0 and ModuleType == 'BASE':\r
                    Logger.Error("InfParser",\r
                                 FORMAT_INVALID,\r
                                 ST.ERR_INF_PARSER_MODULETYPE_INVALID,\r
                                 File=self.FullPath,\r
                                 Line=DefineObj.ModuleType.CurrentLine.LineNo,\r
                                 ExtraData=DefineObj.ModuleType.CurrentLine.LineString)\r
                self.LibModuleTypeList.append(ModuleType)\r
        if DefineObj.GetBaseName() is None:\r
            Logger.Error("InfParser", FORMAT_INVALID,\r
                         ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("BASE_NAME"), File=self.FullPath)\r
        else:\r
            self.SetBaseName(DefineObj.GetBaseName().GetValue())\r
        if DefineObj.GetModuleUniFileName():\r
            self.UniFileClassObject = UniFileClassObject([PathClass(DefineObj.GetModuleUniFileName())])\r
        else:\r
            self.UniFileClassObject = None\r
        if DefineObj.GetInfVersion() is None:\r
            Logger.Error("InfParser", FORMAT_INVALID,\r
                         ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("INF_VERSION"), File=self.FullPath)\r
        else:\r
            self.SetVersion(DefineObj.GetInfVersion().GetValue())\r
        if DefineObj.GetFileGuid() is None:\r
            Logger.Error("InfParser", FORMAT_INVALID,\r
                         ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("FILE_GUID"), File=self.FullPath)\r
        else:\r
            self.SetGuid(DefineObj.GetFileGuid().GetValue())\r
        if DefineObj.GetVersionString() is None:\r
            #\r
            # VERSION_STRING is missing from the [Defines] section, tools must assume that the module's version is 0.\r
            #\r
            self.SetVersion('0')\r
        else:\r
            #\r
            # Get version of INF\r
            #\r
            if DefineObj.GetVersionString().GetValue() != "":\r
                #\r
                # EDK2 inf\r
                #\r
                VersionString = DefineObj.GetVersionString().GetValue()\r
                if len(VersionString) > 0:\r
                    VersionString = ConvertVersionToDecimal(VersionString)\r
                    self.SetVersion(VersionString)\r
            else:\r
                #\r
                # EDK1 inf\r
                #\r
                Logger.Error("Parser", PARSER_ERROR, ST.ERR_INF_PARSER_NOT_SUPPORT_EDKI_INF, ExtraData=self.FullPath,\r
                             RaiseError=Logger.IS_RAISE_ERROR)\r
        #\r
        # if there is Shadow, Should judge the MODULE_TYPE in\r
        # SEC, PEI_CORE and PEIM\r
        #\r
        if DefineObj.GetShadow():\r
            ModuleTypeValue = DefineObj.GetModuleType().GetValue()\r
            if not (ModuleTypeValue == 'SEC' or ModuleTypeValue == 'PEI_CORE' or ModuleTypeValue == 'PEIM'):\r
                Logger.Error("InfParser", FORMAT_INVALID, ST.ERR_INF_PARSER_DEFINE_SHADOW_INVALID, File=self.FullPath)\r
\r
        if DefineObj.GetPcdIsDriver() is not None:\r
            self.SetPcdIsDriver(DefineObj.GetPcdIsDriver().GetValue())\r
        #\r
        # LIBRARY_CLASS\r
        #\r
        self._GenModuleHeaderLibClass(DefineObj, ArchList)\r
        #\r
        # CUSTOM_MAKEFILE\r
        #\r
        self.CustomMakefile = DefineObj.GetCustomMakefile()\r
        #\r
        # Externs in Defines section\r
        # Only one define section, so just call once.\r
        #\r
        if not HasCalledFlag:\r
            self._GenModuleHeaderExterns(DefineObj)\r
            HasCalledFlag = True\r
        #\r
        # each module has only one module header\r
        #\r
        self.SetSupArchList(ArchList)\r
        #\r
        # Get Hob/BootMode/EventList information\r
        #\r
        self._GenSpecialComments()\r
        #\r
        # put all define statement into user-extension sections\r
        #\r
        DefinesDictNew = GenModuleHeaderUserExt(DefineObj, ArchString)\r
        if DefinesDictNew:\r
            UserExtension = CommonObject.UserExtensionObject()\r
            UserExtension.SetDefinesDict(DefinesDictNew)\r
            UserExtension.SetIdentifier('DefineModifiers')\r
            UserExtension.SetUserID('EDK2')\r
            self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])\r
        #\r
        # Get all meta-file header information\r
        # the record is list of items formatted:\r
        # [LineValue, Arch, StartLine, ID, Third]\r
        #\r
        InfHeaderObj = self.Parser.InfHeader\r
        #\r
        # Put header information into POM object\r
        #\r
        if self.UniFileClassObject:\r
            Lang = DT.TAB_LANGUAGE_EN_X\r
        else:\r
            Lang = DT.TAB_LANGUAGE_EN_US\r
        if InfHeaderObj.GetAbstract():\r
            self.SetAbstract((Lang, InfHeaderObj.GetAbstract()))\r
        if InfHeaderObj.GetDescription():\r
            self.SetDescription((Lang, InfHeaderObj.GetDescription()))\r
        if InfHeaderObj.GetCopyright():\r
            self.SetCopyright(('', InfHeaderObj.GetCopyright()))\r
        if InfHeaderObj.GetLicense():\r
            self.SetLicense(('', InfHeaderObj.GetLicense()))\r
        #\r
        # Put Binary header information into POM object\r
        #\r
        InfBinaryHeaderObj = self.Parser.InfBinaryHeader\r
        if InfBinaryHeaderObj.GetAbstract():\r
            self.SetBinaryHeaderAbstract((Lang, InfBinaryHeaderObj.GetAbstract()))\r
        if InfBinaryHeaderObj.GetDescription():\r
            self.SetBinaryHeaderDescription((Lang, InfBinaryHeaderObj.GetDescription()))\r
        if InfBinaryHeaderObj.GetCopyright():\r
            self.SetBinaryHeaderCopyright(('', InfBinaryHeaderObj.GetCopyright()))\r
        if InfBinaryHeaderObj.GetLicense():\r
            self.SetBinaryHeaderLicense(('', InfBinaryHeaderObj.GetLicense()))\r
\r
    ## GenModuleHeaderLibClass\r
    #\r
    #\r
    def _GenModuleHeaderLibClass(self, DefineObj, ArchList):\r
        LibraryList = DefineObj.GetLibraryClass()\r
        for LibraryItem in LibraryList:\r
            Lib = CommonObject.LibraryClassObject()\r
            Lib.SetLibraryClass(LibraryItem.GetLibraryName())\r
            Lib.SetUsage(DT.USAGE_ITEM_PRODUCES)\r
            SupModuleList = LibraryItem.GetTypes()\r
            self.LibModuleTypeList += SupModuleList\r
            Lib.SetSupModuleList(SupModuleList)\r
            Lib.SetSupArchList(ArchList)\r
            self.SetLibraryClassList(self.GetLibraryClassList() + [Lib])\r
            self.SetIsLibrary(True)\r
            self.SetIsLibraryModList(self.GetIsLibraryModList() + SupModuleList)\r
\r
    ## GenModuleHeaderExterns\r
    #\r
    #\r
    def _GenModuleHeaderExterns(self, DefineObj):\r
        EntryPointList = DefineObj.GetEntryPoint()\r
        for EntryPoint in EntryPointList:\r
            Image = ExternObject()\r
            Image.SetEntryPoint(EntryPoint.GetCName())\r
            #\r
            # Future enhancement\r
            #\r
            self.SetExternList(self.GetExternList() + [Image])\r
        #\r
        # UNLOAD_IMAGE\r
        #\r
        UnloadImageList = DefineObj.GetUnloadImages()\r
        for UnloadImage in UnloadImageList:\r
            Image = ExternObject()\r
            #\r
            # Future enhancement\r
            #\r
            Image.SetUnloadImage(UnloadImage.GetCName())\r
            self.SetExternList(self.GetExternList() + [Image])\r
        #\r
        # CONSTRUCTOR\r
        #\r
        ConstructorList = DefineObj.GetConstructor()\r
        for ConstructorItem in ConstructorList:\r
            Image = ExternObject()\r
            #\r
            # Future enhancement\r
            #\r
            Image.SetConstructor(ConstructorItem.GetCName())\r
            self.SetExternList(self.GetExternList() + [Image])\r
        #\r
        # DESTRUCTOR\r
        #\r
        DestructorList = DefineObj.GetDestructor()\r
        for DestructorItem in DestructorList:\r
            Image = ExternObject()\r
            #\r
            # Future enhancement\r
            #\r
            Image.SetDestructor(DestructorItem.GetCName())\r
            self.SetExternList(self.GetExternList() + [Image])\r
\r
    ## GenModuleHeaderExterns\r
    # BootMode/HOB/Event\r
    #\r
    def _GenSpecialComments(self):\r
        SpecialCommentsList = self.Parser.InfSpecialCommentSection.GetSpecialComments()\r
        for Key in SpecialCommentsList:\r
            if Key == DT.TYPE_HOB_SECTION:\r
                HobList = []\r
                for Item in SpecialCommentsList[Key]:\r
                    Hob = HobObject()\r
                    Hob.SetHobType(Item.GetHobType())\r
                    Hob.SetUsage(Item.GetUsage())\r
                    Hob.SetSupArchList(Item.GetSupArchList())\r
                    if Item.GetHelpString():\r
                        HelpTextObj = CommonObject.TextObject()\r
                        if self.UniFileClassObject:\r
                            HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
                        HelpTextObj.SetString(Item.GetHelpString())\r
                        Hob.SetHelpTextList([HelpTextObj])\r
                    HobList.append(Hob)\r
                self.SetHobList(HobList)\r
            elif Key == DT.TYPE_EVENT_SECTION:\r
                EventList = []\r
                for Item in SpecialCommentsList[Key]:\r
                    Event = EventObject()\r
                    Event.SetEventType(Item.GetEventType())\r
                    Event.SetUsage(Item.GetUsage())\r
                    if Item.GetHelpString():\r
                        HelpTextObj = CommonObject.TextObject()\r
                        if self.UniFileClassObject:\r
                            HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
                        HelpTextObj.SetString(Item.GetHelpString())\r
                        Event.SetHelpTextList([HelpTextObj])\r
                    EventList.append(Event)\r
                self.SetEventList(EventList)\r
            elif Key == DT.TYPE_BOOTMODE_SECTION:\r
                BootModeList = []\r
                for Item in SpecialCommentsList[Key]:\r
                    BootMode = BootModeObject()\r
                    BootMode.SetSupportedBootModes(Item.GetSupportedBootModes())\r
                    BootMode.SetUsage(Item.GetUsage())\r
                    if Item.GetHelpString():\r
                        HelpTextObj = CommonObject.TextObject()\r
                        if self.UniFileClassObject:\r
                            HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
                        HelpTextObj.SetString(Item.GetHelpString())\r
                        BootMode.SetHelpTextList([HelpTextObj])\r
                    BootModeList.append(BootMode)\r
                self.SetBootModeList(BootModeList)\r
\r
    ## GenBuildOptions\r
    #\r
    # Gen BuildOptions of Inf\r
    # [<Family>:]<ToolFlag>=Flag\r
    #\r
    #\r
    def _GenBuildOptions(self):\r
        Logger.Debug(2, "Generate %s ..." % DT.TAB_BUILD_OPTIONS)\r
        #\r
        # Get all BuildOptions\r
        #\r
        BuildOptionsList = self.Parser.InfBuildOptionSection.GetBuildOptions()\r
        if not GlobalData.gIS_BINARY_INF:\r
            BuildOptionDict = {}\r
            for BuildOptionObj in BuildOptionsList:\r
                ArchList = BuildOptionObj.GetSupArchList()\r
                ArchList = ConvertArchList(ArchList)\r
                BuildOptionsContent = BuildOptionObj.GetContent()\r
                ArchString = ' '.join(ArchList)\r
                if not BuildOptionsContent:\r
                    continue\r
                BuildOptionDict[ArchString] = BuildOptionsContent\r
            if not BuildOptionDict:\r
                return\r
            UserExtension = CommonObject.UserExtensionObject()\r
            UserExtension.SetBuildOptionDict(BuildOptionDict)\r
            UserExtension.SetIdentifier('BuildOptionModifiers')\r
            UserExtension.SetUserID('EDK2')\r
            self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])\r
        else:\r
            #\r
            # Not process this information, will be processed in GenBinaries()\r
            #\r
            pass\r
\r
    ## GenLibraryClasses\r
    #\r
    # Get LibraryClass of Inf\r
    # <LibraryClassKeyWord>|<LibraryInstance>\r
    #\r
    # @param ContainerFile: The Inf file full path\r
    #\r
    def _GenLibraryClasses(self):\r
        Logger.Debug(2, "Generate %s ..." % DT.TAB_LIBRARY_CLASSES)\r
        if not GlobalData.gIS_BINARY_INF:\r
            #\r
            # Get all LibraryClasses\r
            #\r
            for LibraryClassData in self.Parser.InfLibraryClassSection.LibraryClasses.values():\r
                for Item in LibraryClassData:\r
                    LibraryClass = CommonObject.LibraryClassObject()\r
                    LibraryClass.SetUsage(DT.USAGE_ITEM_CONSUMES)\r
                    LibraryClass.SetLibraryClass(Item.GetLibName())\r
                    LibraryClass.SetRecommendedInstance(None)\r
                    LibraryClass.SetFeatureFlag(Item.GetFeatureFlagExp())\r
                    LibraryClass.SetSupArchList(ConvertArchList(Item.GetSupArchList()))\r
                    LibraryClass.SetSupModuleList(Item.GetSupModuleList())\r
                    HelpStringObj = Item.GetHelpString()\r
                    if HelpStringObj is not None:\r
                        CommentString = GetHelpStringByRemoveHashKey(HelpStringObj.HeaderComments +\r
                                                                     HelpStringObj.TailComments)\r
                        HelpTextHeaderObj = CommonObject.TextObject()\r
                        if self.UniFileClassObject:\r
                            HelpTextHeaderObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
                        HelpTextHeaderObj.SetString(CommentString)\r
                        LibraryClass.SetHelpTextList([HelpTextHeaderObj])\r
                    self.SetLibraryClassList(self.GetLibraryClassList() + [LibraryClass])\r
\r
    ## GenPackages\r
    #\r
    # Gen Packages of Inf\r
    #\r
    #\r
    # @param ContainerFile: The Inf file full path\r
    #\r
    def _GenPackages(self, Skip):\r
        Logger.Debug(2, "Generate %s ..." % DT.TAB_PACKAGES)\r
        #\r
        # Get all Packages\r
        #\r
        PackageObj = self.Parser.InfPackageSection.Packages\r
        #\r
        # Go through each arch\r
        #\r
        for PackageItemObj in PackageObj:\r
            #\r
            # Need package information for dependency check usage\r
            #\r
            PackageDependency = PackageDependencyObject()\r
            PackageDependency.SetPackageFilePath(NormPath(PackageItemObj.GetPackageName()))\r
            PackageDependency.SetSupArchList(ConvertArchList(PackageItemObj.GetSupArchList()))\r
            PackageDependency.SetFeatureFlag(PackageItemObj.GetFeatureFlagExp())\r
\r
            PkgInfo = GetPkgInfoFromDec(mws.join(self.WorkSpace, NormPath(PackageItemObj.GetPackageName())))\r
            if PkgInfo[1] and PkgInfo[2]:\r
                PackageDependency.SetGuid(PkgInfo[1])\r
                PackageDependency.SetVersion(PkgInfo[2])\r
            elif Skip:\r
                continue\r
            else:\r
                Logger.Error("\nUPT", PARSER_ERROR,\r
                             ST.ERR_INF_GET_PKG_DEPENDENCY_FAIL % PackageItemObj.GetPackageName(), File=self.FullPath)\r
\r
            PackageDependencyList = self.GetPackageDependencyList()\r
            PackageDependencyList.append(PackageDependency)\r
            self.SetPackageDependencyList(PackageDependencyList)\r
\r
    ## GenPcds\r
    #\r
    # Gen Pcds of Inf\r
    # <TokenSpaceGuidCName>.<PcdCName>[|<Value> [|<FFE>]]\r
    #\r
    # @param ContainerFile: The Inf file full path\r
    #\r
    def _GenPcds(self):\r
        if not GlobalData.gIS_BINARY_INF:\r
            Logger.Debug(2, "Generate %s ..." % DT.TAB_PCDS)\r
            #\r
            # Get all Pcds\r
            #\r
            PcdObj = self.Parser.InfPcdSection.Pcds\r
            KeysList = PcdObj.keys()\r
            #\r
            # Go through each arch\r
            #\r
            for (PcdType, PcdKey) in KeysList:\r
                PcdData = PcdObj[PcdType, PcdKey]\r
                for PcdItemObj in PcdData:\r
                    CommentList = PcdItemObj.GetHelpStringList()\r
                    if CommentList:\r
                        for CommentItem in CommentList:\r
                            Pcd = CommonObject.PcdObject()\r
                            Pcd.SetCName(PcdItemObj.GetCName())\r
                            Pcd.SetTokenSpaceGuidCName(PcdItemObj.GetTokenSpaceGuidCName())\r
                            Pcd.SetDefaultValue(PcdItemObj.GetDefaultValue())\r
                            Pcd.SetItemType(PcdType)\r
                            Pcd.SetValidUsage(CommentItem.GetUsageItem())\r
                            Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())\r
                            Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))\r
                            HelpTextObj = CommonObject.TextObject()\r
                            if self.UniFileClassObject:\r
                                HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
                            HelpTextObj.SetString(CommentItem.GetHelpStringItem())\r
                            Pcd.SetHelpTextList([HelpTextObj])\r
                            PcdList = self.GetPcdList()\r
                            PcdList.append(Pcd)\r
                self.SetPcdList(PcdList)\r
\r
    ## GenSources\r
    #\r
    # Gen Sources of Inf\r
    # <Filename>[|<Family>[|<TagName>[|<ToolCode>[|<PcdFeatureFlag>]]]]\r
    #\r
    # @param ContainerFile: The Inf file full path\r
    #\r
    def _GenSources(self):\r
        Logger.Debug(2, "Generate %s ..." % DT.TAB_SOURCES)\r
\r
        #\r
        # Get all SourceFiles\r
        #\r
        SourceObj = self.Parser.InfSourcesSection.Sources\r
        DataList = SourceObj.keys()\r
        #\r
        # Go through each arch\r
        #\r
        SourceList = []\r
        for Key in DataList:\r
            SourceData = SourceObj[Key]\r
            for Item in SourceData:\r
                SourceFile = Item.GetSourceFileName()\r
                Family = Item.GetFamily()\r
                FeatureFlag = Item.GetFeatureFlagExp()\r
                SupArchList = sorted(ConvertArchList(Item.GetSupArchList()))\r
                Source = SourceFileObject()\r
                Source.SetSourceFile(SourceFile)\r
                Source.SetFamily(Family)\r
                Source.SetFeatureFlag(FeatureFlag)\r
                Source.SetSupArchList(SupArchList)\r
                SourceList.append(Source)\r
\r
        self.SetSourceFileList(self.GetSourceFileList() + SourceList)\r
\r
\r
    ## GenUserExtensions\r
    #\r
    # Gen UserExtensions of Inf\r
    #\r
    def _GenUserExtensions(self):\r
        #\r
        # UserExtensions\r
        #\r
        UserExtensionObj = self.Parser.InfUserExtensionSection.UserExtension\r
        Keys = UserExtensionObj.keys()\r
\r
        for Key in Keys:\r
            UserExtensionData = UserExtensionObj[Key]\r
            for UserExtensionDataObj in UserExtensionData:\r
                UserExtension = CommonObject.UserExtensionObject()\r
                UserId = UserExtensionDataObj.GetUserId()\r
                if UserId.startswith('"') and UserId.endswith('"'):\r
                    UserId = UserId[1:-1]\r
                UserExtension.SetUserID(UserId)\r
                Identifier = UserExtensionDataObj.GetIdString()\r
                if Identifier.startswith('"') and Identifier.endswith('"'):\r
                    Identifier = Identifier[1:-1]\r
                #\r
                # Generate miscellaneous files on INF file\r
                #\r
                if UserId == 'TianoCore' and Identifier == 'ExtraFiles':\r
                    self._GenMiscFiles(UserExtensionDataObj.GetContent())\r
                UserExtension.SetIdentifier(Identifier)\r
                UserExtension.SetStatement(UserExtensionDataObj.GetContent())\r
                UserExtension.SetSupArchList(ConvertArchList(UserExtensionDataObj.GetSupArchList()))\r
                self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])\r
\r
        #\r
        #  Gen UserExtensions of TianoCore."BinaryHeader"\r
        #\r
\r
        #Get Binary header from INF file\r
        BinaryAbstractList = self.BinaryHeaderAbstractList\r
        BinaryDescriptionList = self.BinaryHeaderDescriptionList\r
        BinaryCopyrightList = self.BinaryHeaderCopyrightList\r
        BinaryLicenseList = self.BinaryHeaderLicenseList\r
        #Get Binary header from UNI file\r
        # Initialize UniStrDict, the top keys are language codes\r
        UniStrDict = {}\r
        if self.UniFileClassObject:\r
            UniStrDict = self.UniFileClassObject.OrderedStringList\r
            for Lang in UniStrDict:\r
                for StringDefClassObject in UniStrDict[Lang]:\r
                    Lang = GetLanguageCode1766(Lang)\r
                    if StringDefClassObject.StringName == DT.TAB_INF_BINARY_ABSTRACT:\r
                        BinaryAbstractList.append((Lang, ConvertSpecialUnicodes(StringDefClassObject.StringValue)))\r
                    if StringDefClassObject.StringName == DT.TAB_INF_BINARY_DESCRIPTION:\r
                        BinaryDescriptionList.append((Lang, ConvertSpecialUnicodes(StringDefClassObject.StringValue)))\r
        if BinaryAbstractList or BinaryDescriptionList or BinaryCopyrightList or BinaryLicenseList:\r
            BinaryUserExtension = CommonObject.UserExtensionObject()\r
            BinaryUserExtension.SetBinaryAbstract(BinaryAbstractList)\r
            BinaryUserExtension.SetBinaryDescription(BinaryDescriptionList)\r
            BinaryUserExtension.SetBinaryCopyright(BinaryCopyrightList)\r
            BinaryUserExtension.SetBinaryLicense(BinaryLicenseList)\r
            BinaryUserExtension.SetIdentifier(DT.TAB_BINARY_HEADER_IDENTIFIER)\r
            BinaryUserExtension.SetUserID(DT.TAB_BINARY_HEADER_USERID)\r
            self.SetUserExtensionList(self.GetUserExtensionList() + [BinaryUserExtension])\r
\r
    def _GenDepexesList(self, SmmDepexList, DxeDepexList, PeiDepexList):\r
        if SmmDepexList:\r
            self.SetSmmDepex(SmmDepexList)\r
        if DxeDepexList:\r
            self.SetDxeDepex(DxeDepexList)\r
        if PeiDepexList:\r
            self.SetPeiDepex(PeiDepexList)\r
\r
    ## GenDepexes\r
    #\r
    # Gen Depex of Inf\r
    #\r
    # @param ContainerFile: The Inf file full path\r
    #\r
    def _GenDepexes(self):\r
        Logger.Debug(2, "Generate %s ..." % DT.TAB_DEPEX)\r
\r
        PEI_LIST = [DT.SUP_MODULE_PEIM]\r
        SMM_LIST = [DT.SUP_MODULE_DXE_SMM_DRIVER]\r
        DXE_LIST = [DT.SUP_MODULE_DXE_DRIVER, DT.SUP_MODULE_DXE_SAL_DRIVER,\r
                    DT.SUP_MODULE_DXE_RUNTIME_DRIVER]\r
\r
        IsLibraryClass = self.GetIsLibrary()\r
        #\r
        # Get all Depexes\r
        #\r
        DepexData = self.Parser.InfDepexSection.GetDepex()\r
        SmmDepexList = []\r
        DxeDepexList = []\r
        PeiDepexList = []\r
        for Depex in DepexData:\r
            ModuleType = Depex.GetModuleType()\r
            ModuleTypeList = []\r
            if IsLibraryClass:\r
                if self.GetModuleType() == 'BASE' and not ModuleType:\r
                    Logger.Error("\nMkPkg", PARSER_ERROR,\r
                                 ST.ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_BASE_LIBRARY_CLASS,\r
                                 self.GetFullPath(), RaiseError=True)\r
                if self.GetModuleType() != 'BASE' and not self.GetIsLibraryModList():\r
                    Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_LIBRARY_CLASS,\r
                                 self.GetFullPath(), RaiseError=True)\r
                if self.GetModuleType() != 'BASE' and ModuleType and ModuleType not in self.GetIsLibraryModList():\r
                    Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_NOT_DETERMINED,\r
                                 self.GetFullPath(), RaiseError=True)\r
                if ModuleType:\r
                    ModuleTypeList = [ModuleType]\r
                else:\r
                    for ModuleTypeInList in self.GetIsLibraryModList():\r
                        if ModuleTypeInList in DT.VALID_DEPEX_MODULE_TYPE_LIST:\r
                            ModuleTypeList.append(ModuleTypeInList)\r
                if not ModuleTypeList:\r
                    Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_NOT_DETERMINED,\r
                                 self.GetFullPath(), RaiseError=True)\r
            else:\r
                if not ModuleType:\r
                    ModuleType = self.ModuleType\r
                if ModuleType not in DT.VALID_DEPEX_MODULE_TYPE_LIST:\r
                    Logger.Error("\nMkPkg", PARSER_ERROR,\r
                                 ST.ERR_INF_PARSER_DEPEX_SECTION_MODULE_TYPE_ERROR % (ModuleType),\r
                                 self.GetFullPath(), RaiseError=True)\r
                if ModuleType != self.ModuleType:\r
                    Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_NOT_DETERMINED,\r
                                 self.GetFullPath(), RaiseError=True)\r
                ModuleTypeList = [ModuleType]\r
            for ModuleType in ModuleTypeList:\r
                DepexIns = DepexObject()\r
                DepexIns.SetDepex(Depex.GetDepexContent())\r
                if IsLibraryClass:\r
                    DepexIns.SetModuleType(ModuleType)\r
                else:\r
                    if Depex.GetModuleType():\r
                        DepexIns.SetModuleType(Depex.GetModuleType())\r
                DepexIns.SetSupArchList(ConvertArchList([Depex.GetSupArch()]))\r
                DepexIns.SetFeatureFlag(Depex.GetFeatureFlagExp())\r
                if Depex.HelpString:\r
                    HelpIns = CommonObject.TextObject()\r
                    if self.UniFileClassObject:\r
                        HelpIns.SetLang(DT.TAB_LANGUAGE_EN_X)\r
                    HelpIns.SetString(GetHelpStringByRemoveHashKey(Depex.HelpString))\r
                    DepexIns.SetHelpText(HelpIns)\r
\r
                if ModuleType in SMM_LIST:\r
                    SmmDepexList.append(DepexIns)\r
                if ModuleType in DXE_LIST:\r
                    DxeDepexList.append(DepexIns)\r
                if ModuleType in PEI_LIST:\r
                    PeiDepexList.append(DepexIns)\r
                if ModuleType == DT.SUP_MODULE_UEFI_DRIVER:\r
                    if IsLibraryClass:\r
                        DxeDepexList.append(DepexIns)\r
                    else:\r
                        Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_DRIVER,\r
                                     self.GetFullPath(), RaiseError=True)\r
\r
            #End of for ModuleType in ModuleTypeList\r
            self._GenDepexesList(SmmDepexList, DxeDepexList, PeiDepexList)\r
        #End of for Depex in DepexData\r
\r
    ## GenBinaries\r
    #\r
    # Gen Binary of Inf, must be called after Pcd/Library is generated\r
    # <FileType>|<Filename>|<Target>[|<TokenSpaceGuidCName>.<PcdCName>]\r
    #\r
    # @param ContainerFile: The Inf file full path\r
    #\r
    def _GenBinaries(self):\r
        Logger.Debug(2, "Generate %s ..." % DT.TAB_BINARIES)\r
        BinariesDict = {}\r
\r
        #\r
        # Get all Binary data\r
        #\r
        BinaryObj = self.Parser.InfBinariesSection.GetBinary()\r
\r
        BinaryData = BinaryObj.keys()\r
\r
        #\r
        # If the INF file does not contain a [Sources] section, and the INF file does contain a [Binaries] section,\r
        # then the ModuleSurfaceArea.BinaryModule attribute must be set to true. Otherwise, do not use the attribute\r
        #\r
        if BinaryObj and not self.Parser.InfSourcesSection.GetSources():\r
            self.BinaryModule = True\r
        else:\r
            self.BinaryModule = False\r
\r
        BinaryFileObjectList = []\r
        AsBuildLibraryClassList = []\r
        AsBuildBuildOptionList = []\r
        AsBuildIns = AsBuiltObject()\r
        #\r
        # Library AsBuild Info\r
        #\r
        for LibItem in self.Parser.InfLibraryClassSection.GetLibraryClasses():\r
            AsBuildLibIns = AsBuildLibraryClassObject()\r
            AsBuildLibIns.SetLibGuid(LibItem.GetFileGuid())\r
            AsBuildLibIns.SetLibVersion(LibItem.GetVersion())\r
            AsBuildLibIns.SetSupArchList(LibItem.GetSupArchList())\r
            AsBuildLibraryClassList.append(AsBuildLibIns)\r
        AsBuildIns.SetLibraryInstancesList(AsBuildLibraryClassList)\r
\r
        #\r
        # BuildOption AsBuild Info\r
        #\r
        for BuildOptionItem in self.Parser.InfBuildOptionSection.GetBuildOptions():\r
            AsBuildBuildOptionList.append(BuildOptionItem)\r
        AsBuildIns.SetBuildFlagsList(AsBuildBuildOptionList)\r
\r
        #\r
        # PatchPcd and PcdEx\r
        #\r
        AsBuildIns = self._GenAsBuiltPcds(self.Parser.InfPcdSection.GetPcds(), AsBuildIns)\r
\r
        #\r
        # Parse the DEC file that contains the GUID value of the GUID CName which is used by\r
        # SUBTYPE_GUID type binary file in the Binaries section in the INF file\r
        #\r
        DecObjList = []\r
        if not self.PackagePath:\r
            WorkSpace = os.path.normpath(self.WorkSpace)\r
            TempPath = ModulePath = os.path.normpath(self.ModulePath)\r
            while ModulePath:\r
                TempPath = ModulePath\r
                ModulePath = os.path.dirname(ModulePath)\r
            PackageName = TempPath\r
            DecFilePath = os.path.normpath(os.path.join(WorkSpace, PackageName))\r
            if DecFilePath:\r
                for File in os.listdir(DecFilePath):\r
                    if File.upper().endswith('.DEC'):\r
                        DecFileFullPath = os.path.normpath(os.path.join(DecFilePath, File))\r
                        DecObjList.append(DecPomAlignment(DecFileFullPath, self.WorkSpace))\r
\r
\r
        BinariesDict, AsBuildIns, BinaryFileObjectList = GenBinaryData(BinaryData, BinaryObj,\r
                                                                       BinariesDict,\r
                                                                       AsBuildIns,\r
                                                                       BinaryFileObjectList,\r
                                                                       self.GetSupArchList(),\r
                                                                       self.BinaryModule,\r
                                                                       DecObjList)\r
\r
        BinariesDict2 = {}\r
        for Key in BinariesDict:\r
            ValueList = BinariesDict[Key]\r
            if len(ValueList) > 1:\r
                BinariesDict2[Key] = ValueList\r
            else:\r
                #\r
                # if there is no TagName, ToolCode, HelpStr,\r
                # then do not need to put them into userextension\r
                #\r
                (Target, Family, TagName, HelpStr) = ValueList[0]\r
                if not (Target or Family or TagName or HelpStr):\r
                    continue\r
                else:\r
                    BinariesDict2[Key] = ValueList\r
\r
        self.SetBinaryFileList(self.GetBinaryFileList() + BinaryFileObjectList)\r
\r
        if BinariesDict2:\r
            UserExtension = CommonObject.UserExtensionObject()\r
            UserExtension.SetBinariesDict(BinariesDict2)\r
            UserExtension.SetIdentifier('BinaryFileModifiers')\r
            UserExtension.SetUserID('EDK2')\r
            self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])\r
\r
    ## GenAsBuiltPcds\r
    #\r
    #\r
    def _GenAsBuiltPcds(self, PcdList, AsBuildIns):\r
        AsBuildPatchPcdList = []\r
        AsBuildPcdExList = []\r
        #\r
        # Pcd AsBuild Info\r
        #\r
        for PcdItem in PcdList:\r
            if PcdItem[0].upper() == DT.TAB_INF_PATCH_PCD.upper():\r
                PcdItemObj = PcdItem[1]\r
                Pcd = CommonObject.PcdObject()\r
                Pcd.SetCName(PcdItemObj.GetCName())\r
                Pcd.SetTokenSpaceGuidCName(PcdItemObj.GetTokenSpaceGuidCName())\r
                if PcdItemObj.GetTokenSpaceGuidValue() == '' and self.BinaryModule:\r
                    Logger.Error("\nMkPkg",\r
                                 PARSER_ERROR,\r
                                 ST.ERR_ASBUILD_PCD_TOKENSPACE_GUID_VALUE_MISS % \\r
                                 (PcdItemObj.GetTokenSpaceGuidCName()),\r
                                 self.GetFullPath(), RaiseError=True)\r
                else:\r
                    Pcd.SetTokenSpaceGuidValue(PcdItemObj.GetTokenSpaceGuidValue())\r
                if (PcdItemObj.GetToken() == '' or PcdItemObj.GetDatumType() == '') and self.BinaryModule:\r
                    Logger.Error("\nMkPkg",\r
                                 PARSER_ERROR,\r
                                 ST.ERR_ASBUILD_PCD_DECLARITION_MISS % \\r
                                 (PcdItemObj.GetTokenSpaceGuidCName() + '.' + PcdItemObj.GetCName()),\r
                                 self.GetFullPath(), RaiseError=True)\r
                Pcd.SetToken(PcdItemObj.GetToken())\r
                Pcd.SetDatumType(PcdItemObj.GetDatumType())\r
                Pcd.SetMaxDatumSize(PcdItemObj.GetMaxDatumSize())\r
                Pcd.SetDefaultValue(PcdItemObj.GetDefaultValue())\r
                Pcd.SetOffset(PcdItemObj.GetOffset())\r
                Pcd.SetItemType(PcdItem[0])\r
                Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())\r
                Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))\r
                Pcd.SetValidUsage(PcdItemObj.GetValidUsage())\r
                for CommentItem in PcdItemObj.GetHelpStringList():\r
                    HelpTextObj = CommonObject.TextObject()\r
                    if self.UniFileClassObject:\r
                        HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
                    HelpTextObj.SetString(CommentItem.GetHelpStringItem())\r
                    Pcd.SetHelpTextList(Pcd.GetHelpTextList() + [HelpTextObj])\r
                AsBuildPatchPcdList.append(Pcd)\r
            elif PcdItem[0].upper() == DT.TAB_INF_PCD_EX.upper():\r
                PcdItemObj = PcdItem[1]\r
                Pcd = CommonObject.PcdObject()\r
                Pcd.SetTokenSpaceGuidValue(PcdItemObj.GetTokenSpaceGuidValue())\r
                Pcd.SetToken(PcdItemObj.GetToken())\r
                Pcd.SetDatumType(PcdItemObj.GetDatumType())\r
                Pcd.SetMaxDatumSize(PcdItemObj.GetMaxDatumSize())\r
                Pcd.SetDefaultValue(PcdItemObj.GetDefaultValue())\r
                Pcd.SetItemType(PcdItem[0])\r
                Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())\r
                Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))\r
                Pcd.SetValidUsage(PcdItemObj.GetValidUsage())\r
                for CommentItem in PcdItemObj.GetHelpStringList():\r
                    HelpTextObj = CommonObject.TextObject()\r
                    if self.UniFileClassObject:\r
                        HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
                    HelpTextObj.SetString(CommentItem.GetHelpStringItem())\r
                    Pcd.SetHelpTextList(Pcd.GetHelpTextList() + [HelpTextObj])\r
                AsBuildPcdExList.append(Pcd)\r
        AsBuildIns.SetPatchPcdList(AsBuildPatchPcdList)\r
        AsBuildIns.SetPcdExList(AsBuildPcdExList)\r
\r
        return AsBuildIns\r
\r
    ## GenGuidProtocolPpis\r
    #\r
    # Gen Guids/Protocol/Ppis of INF\r
    # <CName>=<GuidValue>\r
    #\r
    def _GenGuidProtocolPpis(self, Type):\r
        Logger.Debug(2, "Generate %s ..." % Type)\r
        #\r
        # Get all Guid/Protocol/Ppis data\r
        #\r
        GuidObj = self.Parser.InfGuidSection.GetGuid()\r
        ProtocolObj = self.Parser.InfProtocolSection.GetProtocol()\r
        PpisObj = self.Parser.InfPpiSection.GetPpi()\r
\r
        GuidProtocolPpiList = []\r
\r
        if Type == DT.TAB_GUIDS:\r
            GuidData = GuidObj.keys()\r
            for Item in GuidData:\r
                CommentList = Item.GetCommentList()\r
                #\r
                # Depend on CommentList content\r
                # generate muti-guid-obj\r
                #\r
                if CommentList:\r
                    for GuidComentItem in CommentList:\r
                        ListObject = CommonObject.GuidObject()\r
                        ListObject.SetGuidTypeList([GuidComentItem.GetGuidTypeItem()])\r
                        ListObject.SetVariableName(GuidComentItem.GetVariableNameItem())\r
                        ListObject.SetUsage(GuidComentItem.GetUsageItem())\r
                        ListObject.SetName(Item.GetName())\r
                        ListObject.SetCName(Item.GetName())\r
                        ListObject.SetSupArchList(ConvertArchList(Item.GetSupArchList()))\r
                        ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())\r
                        HelpString = GuidComentItem.GetHelpStringItem()\r
                        if HelpString.strip():\r
                            HelpTxtTailObj = CommonObject.TextObject()\r
                            if self.UniFileClassObject:\r
                                HelpTxtTailObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
                            HelpTxtTailObj.SetString(HelpString)\r
                            ListObject.SetHelpTextList([HelpTxtTailObj])\r
\r
                        GuidProtocolPpiList.append(ListObject)\r
        elif Type == DT.TAB_PROTOCOLS:\r
            ProtocolData = ProtocolObj.keys()\r
            for Item in ProtocolData:\r
                CommentList = Item.GetCommentList()\r
                for CommentItem in CommentList:\r
                    ListObject = CommonObject.ProtocolObject()\r
                    ListObject.SetCName(Item.GetName())\r
                    ListObject.SetSupArchList(ConvertArchList(Item.GetSupArchList()))\r
                    ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())\r
                    ListObject.SetNotify(CommentItem.GetNotify())\r
                    ListObject.SetUsage(CommentItem.GetUsageItem())\r
                    HelpString = CommentItem.GetHelpStringItem()\r
                    if HelpString.strip():\r
                        HelpTxtObj = CommonObject.TextObject()\r
                        if self.UniFileClassObject:\r
                            HelpTxtObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
                        HelpTxtObj.SetString(HelpString)\r
                        ListObject.SetHelpTextList([HelpTxtObj])\r
                    GuidProtocolPpiList.append(ListObject)\r
        elif Type == DT.TAB_PPIS:\r
            PpiData = PpisObj.keys()\r
            for Item in PpiData:\r
                CommentList = Item.GetCommentList()\r
                for CommentItem in CommentList:\r
                    ListObject = CommonObject.PpiObject()\r
                    ListObject.SetCName(Item.GetName())\r
                    ListObject.SetSupArchList(ConvertArchList(Item.GetSupArchList()))\r
                    ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())\r
                    ListObject.SetNotify(CommentItem.GetNotify())\r
                    ListObject.SetUsage(CommentItem.GetUsage())\r
                    HelpString = CommentItem.GetHelpStringItem()\r
                    if HelpString.strip():\r
                        HelpTextObj = CommonObject.TextObject()\r
                        if self.UniFileClassObject:\r
                            HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
                        HelpTextObj.SetString(HelpString)\r
                        ListObject.SetHelpTextList([HelpTextObj])\r
                    GuidProtocolPpiList.append(ListObject)\r
\r
        if Type == DT.TAB_GUIDS:\r
            self.SetGuidList(self.GetGuidList() + GuidProtocolPpiList)\r
        elif Type == DT.TAB_PROTOCOLS:\r
            self.SetProtocolList(self.GetProtocolList() + GuidProtocolPpiList)\r
        elif Type == DT.TAB_PPIS:\r
            self.SetPpiList(self.GetPpiList() + GuidProtocolPpiList)\r
\r
    ## GenMiscFiles\r
    #\r
    # Gen MiscellaneousFiles of Inf\r
    #\r
    # @param ContainerFile: The Inf file full path\r
    #\r
    def _GenMiscFiles(self, Content):\r
        MiscFileObj = CommonObject.MiscFileObject()\r
        for Line in Content.splitlines():\r
            FileName = ''\r
            if '#' in Line:\r
                FileName = Line[:Line.find('#')]\r
            else:\r
                FileName = Line\r
            if FileName:\r
                if IsValidPath(FileName, GlobalData.gINF_MODULE_DIR):\r
                    FileObj = CommonObject.FileObject()\r
                    FileObj.SetURI(FileName)\r
                    MiscFileObj.SetFileList(MiscFileObj.GetFileList()+[FileObj])\r
                else:\r
                    Logger.Error("InfParser",\r
                                 FORMAT_INVALID,\r
                                 ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(Line),\r
                                 File=GlobalData.gINF_MODULE_NAME,\r
                                 ExtraData=Line)\r
        self.SetMiscFileList(self.GetMiscFileList()+[MiscFileObj])\r
\r